feat(wasm-utxo): improve code organization and add transaction parsing

Reorganize code structure with better modularization and add transaction
parsing capability. This includes:
- Create a shared input handling module
- Support for transaction parsing via new `tx parse` command
- Move parsers into organized submodules
- Improve file reading with better error handling
- Add support for decoding different input formats (hex/base64/raw)
- Fix clippy warnings in existing code

Issue: BTC-2652

Co-authored-by: llm-git <[email protected]>

Author: OttoAllmendinger

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

@@ -0,0 +1,42 @@
+use anyhow::{Context, Result};
+use base64::Engine;
+use std::fs;
+use std::io::{self, Read};
+use std::path::PathBuf;
+
+/// Decode input bytes, attempting to interpret as base64, hex, or raw bytes
+pub fn decode_input(raw_bytes: &[u8]) -> Result<Vec<u8>> {
+    // Try to interpret as text first (for base64/hex encoded input)
+    if let Ok(text) = std::str::from_utf8(raw_bytes) {
+        let trimmed = text.trim();
+
+        // Try hex first (more common format)
+        if let Ok(decoded) = hex::decode(trimmed) {
+            return Ok(decoded);
+        }
+
+        // Try base64
+        if let Ok(decoded) = base64::engine::general_purpose::STANDARD.decode(trimmed) {
+            return Ok(decoded);
+        }
+    }
+
+    // Fall back to raw bytes
+    Ok(raw_bytes.to_vec())
+}
+
+/// Read bytes from a file path or stdin (if path is "-")
+pub fn read_input_bytes(path: &PathBuf, file_type: &str) -> Result<Vec<u8>> {
+    if path.to_str() == Some("-") {
+        // Read from stdin
+        let mut buffer = Vec::new();
+        io::stdin()
+            .read_to_end(&mut buffer)
+            .context("Failed to read from stdin")?;
+        Ok(buffer)
+    } else {
+        // Read from file
+        fs::read(path)
+            .with_context(|| format!("Failed to read {} file: {}", file_type, path.display()))
+    }
+}

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

@@ -3,10 +3,11 @@ use clap::{Parser, Subcommand};
 
 mod address;
 mod format;
+mod input;
 mod node;
-mod parse_node;
-mod parse_node_raw;
+mod parse;
 mod psbt;
+mod tx;
 
 #[cfg(test)]
 pub mod test_utils;
@@ -32,6 +33,11 @@ enum Commands {
         #[command(subcommand)]
         command: psbt::PsbtCommand,
     },
+    /// Transaction parsing and inspection operations
+    Tx {
+        #[command(subcommand)]
+        command: tx::TxCommand,
+    },
 }
 
 fn main() -> Result<()> {
@@ -40,5 +46,6 @@ fn main() -> Result<()> {
     match cli.command {
         Commands::Address { command } => address::handle_command(command),
         Commands::Psbt { command } => psbt::handle_command(command),
+        Commands::Tx { command } => tx::handle_command(command),
     }
 }

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

@@ -0,0 +1,5 @@
+pub mod node;
+pub mod node_raw;
+
+pub use node::{parse_psbt_bytes_internal, parse_tx_bytes_internal};
+pub use node_raw::parse_psbt_bytes_raw;

packages/wasm-utxo/cli/src/parse_node.rs renamed to packages/wasm-utxo/cli/src/parse/node.rs

@@ -103,7 +103,7 @@ pub fn psbt_to_node(psbt: &Psbt, network: Network) -> Node {
 
     psbt_node.add_child(xpubs_to_node(&psbt.xpub));
 
-    if psbt.proprietary.len() > 0 {
+    if !psbt.proprietary.is_empty() {
         let mut proprietary_node =
             Node::new("proprietary", Primitive::U64(psbt.proprietary.len() as u64));
         proprietary_node.extend(proprietary_to_nodes(&psbt.proprietary));
@@ -177,7 +177,7 @@ pub fn psbt_to_node(psbt: &Psbt, network: Network) -> Node {
 
         input_node.extend(bip32_derivations_to_nodes(&input.bip32_derivation));
 
-        if input.proprietary.len() > 0 {
+        if !input.proprietary.is_empty() {
             let mut prop_node = Node::new(
                 "proprietary",
                 Primitive::U64(input.proprietary.len() as u64),
@@ -203,7 +203,7 @@ pub fn psbt_to_node(psbt: &Psbt, network: Network) -> Node {
             output_node.add_child(script_buf_to_node("witness_script", script));
         }
 
-        if output.proprietary.len() > 0 {
+        if !output.proprietary.is_empty() {
             let mut prop_node = Node::new(
                 "proprietary",
                 Primitive::U64(output.proprietary.len() as u64),
@@ -339,4 +339,22 @@ mod tests {
         assert_tree_matches_fixture(&node, "psbt_bitcoin_fullsigned")?;
         Ok(())
     }
+
+    #[test]
+    fn test_parse_tx_bitcoin_fullsigned() -> Result<(), Box<dyn std::error::Error>> {
+        use crate::format::fixtures::assert_tree_matches_fixture;
+        use crate::test_utils::{load_tx_bytes, SignatureState, TxFormat};
+        use wasm_utxo::Network as WasmNetwork;
+
+        let tx_bytes = load_tx_bytes(
+            WasmNetwork::Bitcoin,
+            SignatureState::Fullsigned,
+            TxFormat::PsbtLite,
+        )?;
+
+        let node = parse_tx_bytes_internal(&tx_bytes)?;
+
+        assert_tree_matches_fixture(&node, "tx_bitcoin_fullsigned")?;
+        Ok(())
+    }
 }

packages/wasm-utxo/cli/src/parse_node_raw.rs renamed to packages/wasm-utxo/cli/src/parse/node_raw.rs

@@ -14,7 +14,7 @@
 /// # Example
 ///
 /// ```ignore
-/// use parse_node_raw::parse_psbt_bytes_raw;
+/// use parse::node_raw::parse_psbt_bytes_raw;
 ///
 /// let psbt_bytes = /* your PSBT data */;
 /// let node = parse_psbt_bytes_raw(&psbt_bytes)?;

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

@@ -0,0 +1,30 @@
+use anyhow::Result;
+use clap::Subcommand;
+
+mod parse;
+
+#[derive(Subcommand)]
+pub enum PsbtCommand {
+    /// Parse a PSBT file and display its contents
+    Parse {
+        /// Path to the PSBT file (use '-' to read from stdin)
+        path: std::path::PathBuf,
+        /// Disable colored output
+        #[arg(long)]
+        no_color: bool,
+        /// Show raw key-value pairs instead of parsed structure
+        #[arg(long)]
+        raw: bool,
+    },
+}
+
+pub fn handle_command(command: PsbtCommand) -> Result<()> {
+    match command {
+        PsbtCommand::Parse {
+            path,
+            no_color,
+            raw,
+        } => parse::handle_parse_command(path, no_color, raw),
+    }
+}
+

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

@@ -0,0 +1,33 @@
+use anyhow::Result;
+use std::path::PathBuf;
+
+use crate::format::{render_tree_with_scheme, ColorScheme};
+use crate::input::{decode_input, read_input_bytes};
+use crate::parse::{parse_psbt_bytes_internal, parse_psbt_bytes_raw};
+
+pub fn handle_parse_command(path: PathBuf, no_color: bool, raw: bool) -> 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)
+            .map_err(|e| anyhow::anyhow!("Failed to parse PSBT (raw): {}", e))?
+    } else {
+        parse_psbt_bytes_internal(&bytes)
+            .map_err(|e| anyhow::anyhow!("Failed to parse PSBT: {}", e))?
+    };
+
+    let color_scheme = if no_color {
+        ColorScheme::no_color()
+    } else {
+        ColorScheme::default()
+    };
+
+    render_tree_with_scheme(&node, &color_scheme)?;
+
+    Ok(())
+}
+

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

@@ -44,6 +44,12 @@ struct PsbtFixtureBase64 {
     psbt_base64: String,
 }
 
+#[derive(Deserialize)]
+struct TxFixture {
+    #[serde(rename = "extractedTransaction")]
+    extracted_transaction: String,
+}
+
 /// Load PSBT bytes from a fixture file
 ///
 /// # Arguments
@@ -87,3 +93,47 @@ pub fn load_psbt_bytes(
     let psbt_bytes = general_purpose::STANDARD.decode(&fixture.psbt_base64)?;
     Ok(psbt_bytes)
 }
+
+/// Load transaction bytes from a fixture file's extractedTransaction field
+///
+/// # Arguments
+/// * `network` - The network type
+/// * `signature_state` - The signature state of the transaction
+/// * `tx_format` - The transaction format (Psbt or PsbtLite)
+///
+/// # Example
+/// ```rust,no_run
+/// use cli::test_utils::*;
+/// use wasm_utxo::Network;
+///
+/// let tx_bytes = load_tx_bytes(
+///     Network::Bitcoin,
+///     SignatureState::Fullsigned,
+///     TxFormat::PsbtLite
+/// ).expect("Failed to load fixture");
+/// ```
+pub fn load_tx_bytes(
+    network: Network,
+    signature_state: SignatureState,
+    tx_format: TxFormat,
+) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+    let filename = format!(
+        "{}.{}.{}.json",
+        tx_format.as_str(),
+        network.to_utxolib_name(),
+        signature_state.as_str()
+    );
+    let path = format!(
+        "{}/test/fixtures/fixed-script/{}",
+        env!("CARGO_MANIFEST_DIR"),
+        filename
+    );
+
+    let contents = std::fs::read_to_string(&path)
+        .unwrap_or_else(|_| panic!("Failed to load fixture: {}", path));
+
+    let fixture: TxFixture = serde_json::from_str(&contents)?;
+
+    let tx_bytes = hex::decode(&fixture.extracted_transaction)?;
+    Ok(tx_bytes)
+}

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

@@ -0,0 +1,23 @@
+use anyhow::Result;
+use clap::Subcommand;
+
+mod parse;
+
+#[derive(Subcommand)]
+pub enum TxCommand {
+    /// Parse a transaction file and display its contents
+    Parse {
+        /// Path to the transaction file (use '-' to read from stdin)
+        path: std::path::PathBuf,
+        /// Disable colored output
+        #[arg(long)]
+        no_color: bool,
+    },
+}
+
+pub fn handle_command(command: TxCommand) -> Result<()> {
+    match command {
+        TxCommand::Parse { path, no_color } => parse::handle_parse_command(path, no_color),
+    }
+}
+