feat(wasm-utxo): add enum-based network selection for CLI

Refactor network handling to use an enum-based approach for improved
type safety and better user experience. Replace string-based network
arguments with structured enum types that explicitly list all supported
networks. This change:

- Adds NetworkArg enum for CLI commands that use network parameters
- Updates address, psbt, and tx commands to use the new network type
- Removes hard-coded string handling for network parsing
- Simplifies interface by requiring explicit network parameter
- Removes redundant internal parse functions

Issue: BTC-0

Co-authored-by: llm-git <llm-git@ttll.de>

Author: OttoAllmendinger

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

@@ -3,37 +3,39 @@ use clap::Subcommand;
 use wasm_utxo::bitcoin::Script;
 use wasm_utxo::{from_output_script_with_network, to_output_script_with_network, Network};
 
+use crate::network::NetworkArg;
+
 #[derive(Subcommand)]
 pub enum AddressCommand {
     /// Decode an address to its output script (hex)
     Decode {
         /// The address to decode
         address: String,
-        /// Network (bitcoin, testnet, litecoin, zcash, etc.)
-        #[arg(short, long, default_value = "bitcoin")]
-        network: String,
+        /// Network (btc, tbtc, ltc, bch, zec, etc.)
+        #[arg(short, long, value_enum)]
+        network: NetworkArg,
     },
     /// Encode an output script (hex) to an address
     Encode {
         /// Output script as hex
         script: String,
-        /// Network (bitcoin, testnet, litecoin, zcash, etc.)
-        #[arg(short, long, default_value = "bitcoin")]
-        network: String,
+        /// Network (btc, tbtc, ltc, bch, zec, etc.)
+        #[arg(short, long, value_enum)]
+        network: NetworkArg,
     },
 }
 
 pub fn handle_command(command: AddressCommand) -> Result<()> {
     match command {
         AddressCommand::Decode { address, network } => {
-            let network = parse_network(&network)?;
+            let network: Network = network.into();
             let script = to_output_script_with_network(&address, network)
                 .context("Failed to decode address")?;
             println!("{}", hex::encode(script.as_bytes()));
             Ok(())
         }
         AddressCommand::Encode { script, network } => {
-            let network = parse_network(&network)?;
+            let network: Network = network.into();
             let script_bytes =
                 hex::decode(&script).context("Invalid hex string for output script")?;
             let script_obj = Script::from_bytes(&script_bytes);
@@ -44,32 +46,3 @@ pub fn handle_command(command: AddressCommand) -> Result<()> {
         }
     }
 }
-
-fn parse_network(network: &str) -> Result<Network> {
-    // Try utxolib name first (e.g., "bitcoin", "testnet", "bitcoincash")
-    if let Some(net) = Network::from_utxolib_name(network) {
-        return Ok(net);
-    }
-
-    // Try coin name (e.g., "btc", "ltc", "bch")
-    if let Some(net) = Network::from_coin_name(network) {
-        return Ok(net);
-    }
-
-    // Try common aliases
-    let normalized = network.to_lowercase();
-    match normalized.as_str() {
-        "test" | "testnet3" => Ok(Network::BitcoinTestnet3),
-        "signet" => Ok(Network::BitcoinPublicSignet),
-        "ltctest" => Ok(Network::LitecoinTestnet),
-        "bchtest" => Ok(Network::BitcoinCashTestnet),
-        "bsvtest" => Ok(Network::BitcoinSVTestnet),
-        "btgtest" => Ok(Network::BitcoinGoldTestnet),
-        "dashtest" => Ok(Network::DashTestnet),
-        "zectest" => Ok(Network::ZcashTestnet),
-        "dogetest" => Ok(Network::DogecoinTestnet),
-        "xec" => Ok(Network::Ecash),
-        "xectest" => Ok(Network::EcashTestnet),
-        _ => anyhow::bail!("Unknown network: {}", network),
-    }
-}

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

@@ -4,9 +4,12 @@ use clap::{Parser, Subcommand};
 mod address;
 mod format;
 mod input;
+mod network;
 mod psbt;
 mod tx;
 
+pub use network::NetworkArg;
+
 #[cfg(test)]
 mod parse_tests;
 #[cfg(test)]

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

@@ -0,0 +1,54 @@
+//! Network argument type for CLI commands
+
+use clap::ValueEnum;
+use wasm_utxo::Network;
+
+/// CLI argument type for network selection
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum NetworkArg {
+    Btc,
+    Tbtc,
+    Tbtc4,
+    Ltc,
+    Tltc,
+    Bch,
+    Tbch,
+    Bcha,
+    Tbcha,
+    Btg,
+    Tbtg,
+    Bsv,
+    Tbsv,
+    Dash,
+    Tdash,
+    Doge,
+    Tdoge,
+    Zec,
+    Tzec,
+}
+
+impl From<NetworkArg> for Network {
+    fn from(arg: NetworkArg) -> Self {
+        match arg {
+            NetworkArg::Btc => Network::Bitcoin,
+            NetworkArg::Tbtc => Network::BitcoinTestnet3,
+            NetworkArg::Tbtc4 => Network::BitcoinTestnet4,
+            NetworkArg::Ltc => Network::Litecoin,
+            NetworkArg::Tltc => Network::LitecoinTestnet,
+            NetworkArg::Bch => Network::BitcoinCash,
+            NetworkArg::Tbch => Network::BitcoinCashTestnet,
+            NetworkArg::Bcha => Network::Ecash,
+            NetworkArg::Tbcha => Network::EcashTestnet,
+            NetworkArg::Btg => Network::BitcoinGold,
+            NetworkArg::Tbtg => Network::BitcoinGoldTestnet,
+            NetworkArg::Bsv => Network::BitcoinSV,
+            NetworkArg::Tbsv => Network::BitcoinSVTestnet,
+            NetworkArg::Dash => Network::Dash,
+            NetworkArg::Tdash => Network::DashTestnet,
+            NetworkArg::Doge => Network::Dogecoin,
+            NetworkArg::Tdoge => Network::DogecoinTestnet,
+            NetworkArg::Zec => Network::Zcash,
+            NetworkArg::Tzec => Network::ZcashTestnet,
+        }
+    }
+}

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

@@ -7,8 +7,11 @@
 mod tests {
     use crate::format::fixtures::assert_tree_matches_fixture;
     use crate::test_utils::{load_psbt_bytes, load_tx_bytes, SignatureState, TxFormat};
-    use wasm_utxo::parse_node::{parse_psbt_bytes_internal, parse_psbt_bytes_raw, parse_tx_bytes_internal};
     use wasm_utxo::Network;
+    use wasm_utxo::parse_node::{
+        parse_psbt_bytes_raw_with_network, parse_psbt_bytes_with_network,
+        parse_tx_bytes_with_network,
+    };
 
     #[test]
     fn test_parse_psbt_bitcoin_fullsigned() -> Result<(), Box<dyn std::error::Error>> {
@@ -18,7 +21,7 @@ mod tests {
             TxFormat::Psbt,
         )?;
 
-        let node = parse_psbt_bytes_internal(&psbt_bytes)?;
+        let node = parse_psbt_bytes_with_network(&psbt_bytes, Network::Bitcoin)?;
 
         assert_tree_matches_fixture(&node, "psbt_bitcoin_fullsigned")?;
         Ok(())
@@ -32,7 +35,7 @@ mod tests {
             TxFormat::PsbtLite,
         )?;
 
-        let node = parse_tx_bytes_internal(&tx_bytes)?;
+        let node = parse_tx_bytes_with_network(&tx_bytes, Network::Bitcoin)?;
 
         assert_tree_matches_fixture(&node, "tx_bitcoin_fullsigned")?;
         Ok(())
@@ -43,7 +46,7 @@ mod tests {
         let psbt_bytes =
             load_psbt_bytes(Network::Bitcoin, SignatureState::Fullsigned, TxFormat::Psbt)?;
 
-        let node = parse_psbt_bytes_raw(&psbt_bytes)?;
+        let node = parse_psbt_bytes_raw_with_network(&psbt_bytes, Network::Bitcoin)?;
 
         assert_tree_matches_fixture(&node, "psbt_raw_bitcoin_fullsigned")?;
         Ok(())

packages/wasm-utxo/cli/src/psbt/mod.rs

@@ -1,6 +1,8 @@
 use anyhow::Result;
 use clap::Subcommand;
 
+use crate::network::NetworkArg;
+
 mod parse;
 
 #[derive(Subcommand)]
@@ -9,6 +11,9 @@ pub enum PsbtCommand {
     Parse {
         /// Path to the PSBT file (use '-' to read from stdin)
         path: std::path::PathBuf,
+        /// Network for address formatting
+        #[arg(long, short, value_enum)]
+        network: NetworkArg,
         /// Disable colored output
         #[arg(long)]
         no_color: bool,
@@ -24,6 +29,7 @@ pub fn handle_command(command: PsbtCommand) -> Result<()> {
             path,
             no_color,
             raw,
-        } => parse::handle_parse_command(path, no_color, raw),
+            network,
+        } => parse::handle_parse_command(path, no_color, raw, network.into()),
     }
 }

packages/wasm-utxo/cli/src/psbt/parse.rs

@@ -3,20 +3,26 @@ use std::path::PathBuf;
 
 use crate::format::{render_tree_with_scheme, ColorScheme};
 use crate::input::{decode_input, read_input_bytes};
-use wasm_utxo::parse_node::{parse_psbt_bytes_internal, parse_psbt_bytes_raw};
+use wasm_utxo::parse_node::{parse_psbt_bytes_raw_with_network, parse_psbt_bytes_with_network};
+use wasm_utxo::Network;
 
-pub fn handle_parse_command(path: PathBuf, no_color: bool, raw: bool) -> Result<()> {
+pub fn handle_parse_command(
+    path: PathBuf,
+    no_color: bool,
+    raw: bool,
+    network: Network,
+) -> Result<()> {
     // Read from file or stdin
     let raw_bytes = read_input_bytes(&path, "PSBT")?;
 
     // Decode input (auto-detect hex, base64, or raw bytes)
     let bytes = decode_input(&raw_bytes)?;
 
     let node = if raw {
-        parse_psbt_bytes_raw(&bytes)
+        parse_psbt_bytes_raw_with_network(&bytes, network)
             .map_err(|e| anyhow::anyhow!("Failed to parse PSBT (raw): {}", e))?
     } else {
-        parse_psbt_bytes_internal(&bytes)
+        parse_psbt_bytes_with_network(&bytes, network)
             .map_err(|e| anyhow::anyhow!("Failed to parse PSBT: {}", e))?
     };
 

packages/wasm-utxo/cli/src/tx/mod.rs

@@ -1,6 +1,8 @@
 use anyhow::Result;
 use clap::Subcommand;
 
+use crate::network::NetworkArg;
+
 mod parse;
 
 #[derive(Subcommand)]
@@ -9,6 +11,9 @@ pub enum TxCommand {
     Parse {
         /// Path to the transaction file (use '-' to read from stdin)
         path: std::path::PathBuf,
+        /// Network for address formatting
+        #[arg(long, short, value_enum)]
+        network: NetworkArg,
         /// Disable colored output
         #[arg(long)]
         no_color: bool,
@@ -17,6 +22,10 @@ pub enum TxCommand {
 
 pub fn handle_command(command: TxCommand) -> Result<()> {
     match command {
-        TxCommand::Parse { path, no_color } => parse::handle_parse_command(path, no_color),
+        TxCommand::Parse {
+            path,
+            no_color,
+            network,
+        } => parse::handle_parse_command(path, no_color, network.into()),
     }
 }

packages/wasm-utxo/cli/src/tx/parse.rs

@@ -3,16 +3,17 @@ use std::path::PathBuf;
 
 use crate::format::{render_tree_with_scheme, ColorScheme};
 use crate::input::{decode_input, read_input_bytes};
-use wasm_utxo::parse_node::parse_tx_bytes_internal;
+use wasm_utxo::Network;
+use wasm_utxo::parse_node::parse_tx_bytes_with_network;
 
-pub fn handle_parse_command(path: PathBuf, no_color: bool) -> Result<()> {
+pub fn handle_parse_command(path: PathBuf, no_color: bool, network: Network) -> Result<()> {
     // Read from file or stdin
     let raw_bytes = read_input_bytes(&path, "transaction")?;
 
     // Decode input (auto-detect hex, base64, or raw bytes)
     let bytes = decode_input(&raw_bytes)?;
 
-    let node = parse_tx_bytes_internal(&bytes)
+    let node = parse_tx_bytes_with_network(&bytes, network)
         .map_err(|e| anyhow::anyhow!("Failed to parse transaction: {}", e))?;
 
     let color_scheme = if no_color {

packages/wasm-utxo/js/parseNode.ts

@@ -86,7 +86,7 @@ export interface Node {
  * @returns A Node tree representing the parsed PSBT structure
  * @throws If the PSBT bytes are invalid or network is unknown
  */
-export function parsePsbtToNode(psbtBytes: Uint8Array, network: CoinName = "btc"): Node {
+export function parsePsbtToNode(psbtBytes: Uint8Array, network: CoinName): Node {
   const json = wasmParsePsbtToJson(psbtBytes, network);
   return JSON.parse(json) as Node;
 }
@@ -99,7 +99,7 @@ export function parsePsbtToNode(psbtBytes: Uint8Array, network: CoinName = "btc"
  * @returns A Node tree representing the parsed transaction structure
  * @throws If the transaction bytes are invalid or network is unknown
  */
-export function parseTxToNode(txBytes: Uint8Array, network: CoinName = "btc"): Node {
+export function parseTxToNode(txBytes: Uint8Array, network: CoinName): Node {
   const json = wasmParseTxToJson(txBytes, network);
   return JSON.parse(json) as Node;
 }
@@ -162,7 +162,7 @@ export function tryParseTx(
  * @returns A Node tree representing the raw PSBT key-value structure
  * @throws If the PSBT bytes are invalid or network is unknown
  */
-export function parsePsbtRawToNode(psbtBytes: Uint8Array, network: CoinName = "btc"): Node {
+export function parsePsbtRawToNode(psbtBytes: Uint8Array, network: CoinName): Node {
   const json = wasmParsePsbtRawToJson(psbtBytes, network);
   return JSON.parse(json) as Node;
 }

packages/wasm-utxo/src/parse_node/mod.rs

@@ -4,7 +4,7 @@ mod psbt_raw;
 
 pub use node::{Buffer, Node, Primitive};
 pub use psbt::{
-    parse_psbt_bytes_internal, parse_psbt_bytes_with_network, parse_tx_bytes_internal,
-    parse_tx_bytes_with_network, psbt_to_node, tx_to_node, zcash_psbt_to_node, zcash_tx_to_node,
+    parse_psbt_bytes_with_network, parse_tx_bytes_with_network, psbt_to_node, tx_to_node,
+    zcash_psbt_to_node, zcash_tx_to_node,
 };
-pub use psbt_raw::{parse_psbt_bytes_raw, parse_psbt_bytes_raw_with_network};
+pub use psbt_raw::parse_psbt_bytes_raw_with_network;