feat(wasm-utxo-cli): add address from-descriptor subcommand

Print the address for a descriptor (WIF/hex/xpub-based), which may
embed a private key (e.g. pkh(<wif>)) via wasm-utxo's
script_pubkey_from_descriptor. General utility for deriving addresses
from descriptors on the command line, not tied to any particular coin
or script type.

Refs: T1-3672

Author: OttoAllmendinger

packages/wasm-utxo/cli/README.md

@@ -68,6 +68,29 @@ wasm-utxo-cli address encode 0014e8df018c7e326cc253faac7e46cdc51e68542c42
 # Output: bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq
 ```
 
+#### Derive an address from a descriptor
+
+```bash
+wasm-utxo-cli address from-descriptor <DESCRIPTOR> --network <NETWORK>
+```
+
+The descriptor may name a plain public key or embed a private key directly (e.g. a WIF) —
+either way, the resulting address is derived from the corresponding public key. Works for any
+network, not just Bitcoin.
+
+**Examples:**
+
+```bash
+# BTC: derive a P2PKH address from a public key
+wasm-utxo-cli address from-descriptor "pkh(039ab0771c5f88913208a26f81ab8223e98d25176e4648a5a2bb8ff79cf1c5198b)" --network btc
+# Output: 1GwwqAWsJzDHMZ9ceJqrJDfch4gsro4c3x
+
+# Zcash: derive a t-address directly from a WIF private key (e.g. for zebrad's miner_address on
+# regtest — Zcash regtest reuses testnet address prefixes, so pass --network tzec)
+wasm-utxo-cli address from-descriptor "pkh(KzEGYtKcbhYwUWcZygbsqmF31f3iV7HC3iUQug7MBecwCz9hm1Tv)" --network tzec
+# Output: tmRfJALRQfyWP6SPxFTxiHhSHYhxn7rwkLv
+```
+
 ### PSBT Operations
 
 #### Parse and inspect a PSBT

packages/wasm-utxo/cli/src/address.rs

@@ -1,7 +1,10 @@
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use clap::Subcommand;
 use wasm_utxo::bitcoin::Script;
-use wasm_utxo::{from_output_script_with_network, to_output_script_with_network, Network};
+use wasm_utxo::{
+    from_output_script_with_network, script_pubkey_from_descriptor, to_output_script_with_network,
+    Network,
+};
 
 use crate::network::NetworkArg;
 
@@ -23,6 +26,15 @@ pub enum AddressCommand {
         #[arg(short, long, value_enum)]
         network: NetworkArg,
     },
+    /// Print the address for a descriptor, which may embed a private key (e.g. `pkh(<wif>)`,
+    /// `wpkh(<wif>)`)
+    FromDescriptor {
+        /// Descriptor, e.g. `pkh(<privkey>)`
+        descriptor: String,
+        /// Network (btc, tbtc, ltc, bch, zec, tzec, etc.)
+        #[arg(short, long, value_enum)]
+        network: NetworkArg,
+    },
 }
 
 pub fn handle_command(command: AddressCommand) -> Result<()> {
@@ -44,5 +56,16 @@ pub fn handle_command(command: AddressCommand) -> Result<()> {
             println!("{}", address);
             Ok(())
         }
+        AddressCommand::FromDescriptor {
+            descriptor,
+            network,
+        } => {
+            let network: Network = network.into();
+            let script = script_pubkey_from_descriptor(&descriptor).map_err(|e| anyhow!(e))?;
+            let address = from_output_script_with_network(&script, network)
+                .context("Failed to encode address")?;
+            println!("{}", address);
+            Ok(())
+        }
     }
 }

packages/wasm-utxo/cli/src/input.rs

@@ -3,6 +3,18 @@ use base64::Engine;
 use std::fs;
 use std::io::{self, Read};
 use std::path::PathBuf;
+use std::str::FromStr;
+use wasm_utxo::bitcoin::network::Network as BitcoinNetwork;
+use wasm_utxo::bitcoin::PrivateKey;
+
+/// Parse a private key given as WIF or raw hex bytes.
+pub fn parse_private_key(s: &str) -> Result<PrivateKey> {
+    if let Ok(pk) = PrivateKey::from_str(s) {
+        return Ok(pk);
+    }
+    let bytes = hex::decode(s).context("private key must be WIF or hex")?;
+    PrivateKey::from_slice(&bytes, BitcoinNetwork::Bitcoin).context("invalid private key bytes")
+}
 
 /// Decode input bytes, attempting to interpret as base64, hex, or raw bytes
 pub fn decode_input(raw_bytes: &[u8]) -> Result<Vec<u8>> {