feat(wasm-utxo): add legacy tx to PSBT conversion and introspection

Add bidirectional conversion between half-signed legacy transactions
and PSBTs. Implement transaction introspection API for accessing
inputs, outputs, and metadata across all transaction types.

- Add `fromHalfSignedLegacyTransaction()` to convert legacy txs to PSBT
- Extract partial sigs from scriptSig/witness in `unsign_legacy_input()`
- Expose input/output accessors on Transaction/ZcashTransaction/DashTransaction
- Add `getInputs()`, `getOutputs()`, `getOutputsWithAddress()` methods
- Include version, lockTime, input/output counts
- Export `HydrationUnspent` type for legacy conversion
- Add comprehensive round-trip tests for p2sh, p2shP2wsh, p2wsh

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

Author: OttoAllmendinger

packages/wasm-utxo/js/fixedScriptWallet/BitGoPsbt.ts

@@ -126,6 +126,12 @@ export type ParseOutputsOptions = {
   payGoPubkeys?: ECPairArg[];
 };
 
+export type HydrationUnspent = {
+  chain: number;
+  index: number;
+  value: bigint;
+};
+
 export class BitGoPsbt implements IPsbtWithAddress {
   protected constructor(protected _wasm: WasmBitGoPsbt) {}
 
@@ -185,6 +191,34 @@ export class BitGoPsbt implements IPsbtWithAddress {
     return new BitGoPsbt(wasm);
   }
 
+  /**
+   * Convert a half-signed legacy transaction to a psbt-lite.
+   *
+   * Extracts partial signatures from scriptSig/witness and creates a PSBT
+   * with proper wallet metadata (bip32Derivation, scripts, witnessUtxo).
+   * Only supports p2sh, p2shP2wsh, and p2wsh inputs (not taproot).
+   *
+   * @param txBytes - The serialized half-signed legacy transaction
+   * @param network - Network name
+   * @param walletKeys - The wallet's root keys
+   * @param unspents - Chain, index, and value for each input
+   */
+  static fromHalfSignedLegacyTransaction(
+    txBytes: Uint8Array,
+    network: NetworkName,
+    walletKeys: WalletKeysArg,
+    unspents: HydrationUnspent[],
+  ): BitGoPsbt {
+    const keys = RootWalletKeys.from(walletKeys);
+    const wasm = WasmBitGoPsbt.from_half_signed_legacy_transaction(
+      txBytes,
+      network,
+      keys.wasm,
+      unspents,
+    );
+    return new BitGoPsbt(wasm);
+  }
+
   /**
    * Add an input to the PSBT
    *

packages/wasm-utxo/js/fixedScriptWallet/index.ts

@@ -31,6 +31,7 @@ export {
   type AddWalletOutputOptions,
   type ParseTransactionOptions,
   type ParseOutputsOptions,
+  type HydrationUnspent,
 } from "./BitGoPsbt.js";
 
 // Zcash-specific PSBT subclass

packages/wasm-utxo/js/index.ts

@@ -86,10 +86,35 @@ declare module "./wasm/wasm_utxo.js" {
   interface PsbtOutputDataWithAddress extends PsbtOutputData {
     address: string;
   }
+
+  /** Outpoint referencing a previous transaction output */
+  interface TxOutPoint {
+    txid: string;
+    vout: number;
+  }
+
+  /** Raw transaction input data returned by Transaction.getInputs() */
+  interface TxInputData {
+    previousOutput: TxOutPoint;
+    sequence: number;
+    scriptSig: Uint8Array;
+    witness: Uint8Array[];
+  }
+
+  /** Raw transaction output data returned by Transaction.getOutputs() */
+  interface TxOutputData {
+    script: Uint8Array;
+    value: bigint;
+  }
+
+  /** Transaction output data with resolved address */
+  interface TxOutputDataWithAddress extends TxOutputData {
+    address: string;
+  }
 }
 
 export { WrapDescriptor as Descriptor } from "./wasm/wasm_utxo.js";
 export { WrapMiniscript as Miniscript } from "./wasm/wasm_utxo.js";
 export { Psbt } from "./descriptorWallet/Psbt.js";
-export { DashTransaction, Transaction, ZcashTransaction } from "./transaction.js";
+export { DashTransaction, Transaction, ZcashTransaction, type ITransaction } from "./transaction.js";
 export { hasPsbtMagic, type IPsbt, type IPsbtWithAddress } from "./psbt.js";

packages/wasm-utxo/js/transaction.ts

@@ -1,11 +1,26 @@
-import { WasmDashTransaction, WasmTransaction, WasmZcashTransaction } from "./wasm/wasm_utxo.js";
+import {
+  WasmDashTransaction,
+  WasmTransaction,
+  WasmZcashTransaction,
+  type TxInputData,
+  type TxOutputData,
+  type TxOutputDataWithAddress,
+} from "./wasm/wasm_utxo.js";
+import type { CoinName } from "./coinName.js";
 
 /**
  * Common interface for all transaction types
  */
 export interface ITransaction {
   toBytes(): Uint8Array;
   getId(): string;
+  inputCount(): number;
+  outputCount(): number;
+  get version(): number;
+  get lockTime(): number;
+  getInputs(): TxInputData[];
+  getOutputs(): TxOutputData[];
+  getOutputsWithAddress(coin: CoinName): TxOutputDataWithAddress[];
 }
 
 /**
@@ -27,9 +42,7 @@ export class Transaction implements ITransaction {
     return new Transaction(WasmTransaction.from_bytes(bytes));
   }
 
-  /**
-   * @internal Create from WASM instance directly (avoids re-parsing bytes)
-   */
+  /** @internal Create from WASM instance directly (avoids re-parsing bytes) */
   static fromWasm(wasm: WasmTransaction): Transaction {
     return new Transaction(wasm);
   }
@@ -84,9 +97,35 @@ export class Transaction implements ITransaction {
     return this._wasm.get_vsize();
   }
 
-  /**
-   * @internal
-   */
+  inputCount(): number {
+    return this._wasm.input_count();
+  }
+
+  outputCount(): number {
+    return this._wasm.output_count();
+  }
+
+  get version(): number {
+    return this._wasm.version();
+  }
+
+  get lockTime(): number {
+    return this._wasm.lock_time();
+  }
+
+  getInputs(): TxInputData[] {
+    return this._wasm.get_inputs() as TxInputData[];
+  }
+
+  getOutputs(): TxOutputData[] {
+    return this._wasm.get_outputs() as TxOutputData[];
+  }
+
+  getOutputsWithAddress(coin: CoinName): TxOutputDataWithAddress[] {
+    return this._wasm.get_outputs_with_address(coin) as TxOutputDataWithAddress[];
+  }
+
+  /** @internal */
   get wasm(): WasmTransaction {
     return this._wasm;
   }
@@ -104,9 +143,7 @@ export class ZcashTransaction implements ITransaction {
     return new ZcashTransaction(WasmZcashTransaction.from_bytes(bytes));
   }
 
-  /**
-   * @internal Create from WASM instance directly (avoids re-parsing bytes)
-   */
+  /** @internal Create from WASM instance directly (avoids re-parsing bytes) */
   static fromWasm(wasm: WasmZcashTransaction): ZcashTransaction {
     return new ZcashTransaction(wasm);
   }
@@ -127,9 +164,35 @@ export class ZcashTransaction implements ITransaction {
     return this._wasm.get_txid();
   }
 
-  /**
-   * @internal
-   */
+  inputCount(): number {
+    return this._wasm.input_count();
+  }
+
+  outputCount(): number {
+    return this._wasm.output_count();
+  }
+
+  get version(): number {
+    return this._wasm.version();
+  }
+
+  get lockTime(): number {
+    return this._wasm.lock_time();
+  }
+
+  getInputs(): TxInputData[] {
+    return this._wasm.get_inputs() as TxInputData[];
+  }
+
+  getOutputs(): TxOutputData[] {
+    return this._wasm.get_outputs() as TxOutputData[];
+  }
+
+  getOutputsWithAddress(coin: CoinName): TxOutputDataWithAddress[] {
+    return this._wasm.get_outputs_with_address(coin) as TxOutputDataWithAddress[];
+  }
+
+  /** @internal */
   get wasm(): WasmZcashTransaction {
     return this._wasm;
   }
@@ -147,9 +210,7 @@ export class DashTransaction implements ITransaction {
     return new DashTransaction(WasmDashTransaction.from_bytes(bytes));
   }
 
-  /**
-   * @internal Create from WASM instance directly (avoids re-parsing bytes)
-   */
+  /** @internal Create from WASM instance directly (avoids re-parsing bytes) */
   static fromWasm(wasm: WasmDashTransaction): DashTransaction {
     return new DashTransaction(wasm);
   }
@@ -170,9 +231,35 @@ export class DashTransaction implements ITransaction {
     return this._wasm.get_txid();
   }
 
-  /**
-   * @internal
-   */
+  inputCount(): number {
+    return this._wasm.input_count();
+  }
+
+  outputCount(): number {
+    return this._wasm.output_count();
+  }
+
+  get version(): number {
+    return this._wasm.version();
+  }
+
+  get lockTime(): number {
+    return this._wasm.lock_time();
+  }
+
+  getInputs(): TxInputData[] {
+    return this._wasm.get_inputs() as TxInputData[];
+  }
+
+  getOutputs(): TxOutputData[] {
+    return this._wasm.get_outputs() as TxOutputData[];
+  }
+
+  getOutputsWithAddress(coin: CoinName): TxOutputDataWithAddress[] {
+    return this._wasm.get_outputs_with_address(coin) as TxOutputDataWithAddress[];
+  }
+
+  /** @internal */
   get wasm(): WasmDashTransaction {
     return this._wasm;
   }

packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/legacy_txformat.rs

@@ -7,9 +7,10 @@
 use crate::fixed_script_wallet::wallet_scripts::parse_multisig_script_2_of_3;
 use miniscript::bitcoin::blockdata::opcodes::all::OP_PUSHBYTES_0;
 use miniscript::bitcoin::blockdata::script::Builder;
+use miniscript::bitcoin::ecdsa::Signature as EcdsaSig;
 use miniscript::bitcoin::psbt::Psbt;
 use miniscript::bitcoin::script::PushBytesBuf;
-use miniscript::bitcoin::{Transaction, Witness};
+use miniscript::bitcoin::{CompressedPublicKey, ScriptBuf, Transaction, TxIn, Witness};
 
 /// Build a half-signed transaction in legacy format from a PSBT.
 ///
@@ -147,3 +148,106 @@ pub fn build_half_signed_legacy_tx(psbt: &Psbt) -> Result<Transaction, String> {
 
     Ok(tx)
 }
+
+/// A partial signature extracted from a legacy half-signed input.
+pub struct LegacyPartialSig {
+    pub pubkey: CompressedPublicKey,
+    pub sig: EcdsaSig,
+}
+
+/// Determines whether a legacy input uses segwit (witness data) and whether it
+/// has a p2sh wrapper (scriptSig pushing a redeem script).
+///
+/// Returns `(is_p2sh, is_segwit, multisig_script)`.
+fn classify_legacy_input(tx_in: &TxIn) -> Result<(bool, bool, ScriptBuf), String> {
+    let has_witness = !tx_in.witness.is_empty();
+    let has_script_sig = !tx_in.script_sig.is_empty();
+
+    if has_witness {
+        // Segwit: witness contains [empty, sig0?, sig1?, sig2?, witnessScript]
+        let witness_items: Vec<&[u8]> = tx_in.witness.iter().collect();
+        if witness_items.len() < 5 {
+            return Err(format!(
+                "Expected at least 5 witness items, got {}",
+                witness_items.len()
+            ));
+        }
+        let multisig_script = ScriptBuf::from(witness_items.last().unwrap().to_vec());
+        let is_p2sh = has_script_sig; // p2shP2wsh has scriptSig, p2wsh does not
+        Ok((is_p2sh, true, multisig_script))
+    } else if has_script_sig {
+        // p2sh only: scriptSig = [OP_0, sig0?, sig1?, sig2?, redeemScript]
+        // Parse the scriptSig instructions to extract the redeemScript (last push)
+        let instructions: Vec<_> = tx_in
+            .script_sig
+            .instructions()
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("Failed to parse scriptSig: {}", e))?;
+        if instructions.len() < 5 {
+            return Err(format!(
+                "Expected at least 5 scriptSig items, got {}",
+                instructions.len()
+            ));
+        }
+        let last = instructions.last().unwrap();
+        let multisig_bytes = match last {
+            miniscript::bitcoin::script::Instruction::PushBytes(bytes) => bytes.as_bytes(),
+            _ => return Err("Last scriptSig item is not a push".to_string()),
+        };
+        Ok((true, false, ScriptBuf::from(multisig_bytes.to_vec())))
+    } else {
+        Err("Input has neither witness nor scriptSig".to_string())
+    }
+}
+
+/// Extract a partial signature from a legacy half-signed input.
+///
+/// This is the inverse of the signature placement in `build_half_signed_legacy_tx`.
+/// It parses the scriptSig/witness to find the single signature and its position
+/// in the 2-of-3 multisig, then returns the corresponding pubkey and signature.
+pub fn unsign_legacy_input(tx_in: &TxIn) -> Result<LegacyPartialSig, String> {
+    let (_, is_segwit, multisig_script) = classify_legacy_input(tx_in)?;
+
+    let pubkeys = parse_multisig_script_2_of_3(&multisig_script)?;
+
+    // Extract the 3 signature slots (index 1..=3, skipping the leading OP_0/empty)
+    let sig_slots: Vec<Vec<u8>> = if is_segwit {
+        let items: Vec<&[u8]> = tx_in.witness.iter().collect();
+        // witness = [empty, sig0?, sig1?, sig2?, witnessScript]
+        items[1..=3].iter().map(|s| s.to_vec()).collect()
+    } else {
+        // scriptSig = [OP_0, sig0?, sig1?, sig2?, redeemScript]
+        let instructions: Vec<_> = tx_in
+            .script_sig
+            .instructions()
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("Failed to parse scriptSig: {}", e))?;
+        // instructions[0] = OP_0, [1..=3] = sigs, [4] = redeemScript
+        instructions[1..=3]
+            .iter()
+            .map(|inst| match inst {
+                miniscript::bitcoin::script::Instruction::PushBytes(bytes) => {
+                    bytes.as_bytes().to_vec()
+                }
+                miniscript::bitcoin::script::Instruction::Op(_) => vec![],
+            })
+            .collect()
+    };
+
+    // Find the non-empty signature slot
+    let mut found_sig = None;
+    for (i, slot) in sig_slots.iter().enumerate() {
+        if !slot.is_empty() {
+            if found_sig.is_some() {
+                return Err("Expected exactly 1 signature, found multiple".to_string());
+            }
+            let sig = EcdsaSig::from_slice(slot)
+                .map_err(|e| format!("Failed to parse signature at position {}: {}", i, e))?;
+            let pubkey = CompressedPublicKey::from_slice(&pubkeys[i].to_bytes())
+                .map_err(|e| format!("Failed to convert pubkey: {}", e))?;
+            found_sig = Some(LegacyPartialSig { pubkey, sig });
+        }
+    }
+
+    found_sig.ok_or_else(|| "No signature found in input".to_string())
+}