@bitgo/wasm-utxo 2.1.0 → 3.1.0

package/dist/esm/js/testutils/AcidTest.js

@@ -1,13 +1,29 @@
 import { BitGoPsbt } from "../fixedScriptWallet/BitGoPsbt.js";
 import { ZcashBitGoPsbt } from "../fixedScriptWallet/ZcashBitGoPsbt.js";
 import { ECPair } from "../ecpair.js";
-import { assertChainCode, ChainCode, createOpReturnScript, inputScriptTypes, outputScript, outputScriptTypes, supportsScriptType, } from "../fixedScriptWallet/index.js";
+import { Transaction } from "../transaction.js";
+import { ChainCode, createOpReturnScript, inputScriptTypes, outputScript, outputScriptTypes, p2shP2pkOutputScript, supportsScriptType, } from "../fixedScriptWallet/index.js";
 import { coinNames, isMainnet } from "../coinName.js";
 import { getDefaultWalletKeys, getWalletKeysForSeed, getKeyTriple } from "./keys.js";
 export const signStages = ["unsigned", "halfsigned", "fullsigned"];
 export const txFormats = ["psbt", "psbt-lite"];
 // Re-export for convenience
 export { inputScriptTypes, outputScriptTypes };
+/** Map InputScriptType to the OutputScriptType used for chain code derivation */
+function inputScriptTypeToOutputScriptType(scriptType) {
+    switch (scriptType) {
+        case "p2sh":
+        case "p2shP2wsh":
+        case "p2wsh":
+        case "p2trLegacy":
+            return scriptType;
+        case "p2shP2pk":
+            return "p2sh";
+        case "p2trMusig2ScriptPath":
+        case "p2trMusig2KeyPath":
+            return "p2trMusig2";
+    }
+}
 /**
  * Creates a valid PSBT with as many features as possible (kitchen sink).
  *
@@ -30,7 +46,7 @@ export { inputScriptTypes, outputScriptTypes };
  * - psbt-lite: Only witness_utxo (no non_witness_utxo)
  */
 export class AcidTest {
-    network;
+    coin;
     signStage;
     txFormat;
     rootWalletKeys;
@@ -41,8 +57,8 @@ export class AcidTest {
     userXprv;
     backupXprv;
     bitgoXprv;
-    constructor(network, signStage, txFormat, rootWalletKeys, otherWalletKeys, inputs, outputs, xprvTriple) {
-        this.network = network;
+    constructor(coin, signStage, txFormat, rootWalletKeys, otherWalletKeys, inputs, outputs, xprvTriple) {
+        this.coin = coin;
         this.signStage = signStage;
         this.txFormat = txFormat;
         this.rootWalletKeys = rootWalletKeys;
@@ -56,7 +72,7 @@ export class AcidTest {
     /**
      * Create an AcidTest with specific configuration
      */
-    static withConfig(network, signStage, txFormat, suiteConfig = {}) {
+    static withConfig(coin, signStage, txFormat, suiteConfig = {}) {
         const rootWalletKeys = getDefaultWalletKeys();
         const otherWalletKeys = getWalletKeysForSeed("too many secrets");
         // Filter inputs based on network support
@@ -67,9 +83,9 @@ export class AcidTest {
                 return true;
             // Map input script types to output script types for support check
             if (scriptType === "p2trMusig2KeyPath" || scriptType === "p2trMusig2ScriptPath") {
-                return supportsScriptType(network, "p2trMusig2");
+                return supportsScriptType(coin, "p2trMusig2");
             }
-            return supportsScriptType(network, scriptType);
+            return supportsScriptType(coin, scriptType);
         })
             .filter((scriptType) => (suiteConfig.includeP2trMusig2ScriptPath ?? false) ||
             scriptType !== "p2trMusig2ScriptPath")
@@ -79,7 +95,7 @@ export class AcidTest {
         }));
         // Filter outputs based on network support
         const outputs = outputScriptTypes
-            .filter((scriptType) => supportsScriptType(network, scriptType))
+            .filter((scriptType) => supportsScriptType(coin, scriptType))
             .map((scriptType, index) => ({
             scriptType,
             value: BigInt(900 + index * 100), // Deterministic amounts
@@ -92,13 +108,13 @@ export class AcidTest {
         outputs.push({ opReturn: "setec astronomy", value: BigInt(0) });
         // Get private keys for signing
         const xprvTriple = getKeyTriple("default");
-        return new AcidTest(network, signStage, txFormat, rootWalletKeys, otherWalletKeys, inputs, outputs, xprvTriple);
+        return new AcidTest(coin, signStage, txFormat, rootWalletKeys, otherWalletKeys, inputs, outputs, xprvTriple);
     }
     /**
      * Get a human-readable name for this test configuration
      */
     get name() {
-        return `${this.network} ${this.signStage} ${this.txFormat}`;
+        return `${this.coin} ${this.signStage} ${this.txFormat}`;
     }
     /**
      * Get the BIP32 user key for replay protection (p2shP2pk)
@@ -111,58 +127,55 @@ export class AcidTest {
      */
     createPsbt() {
         // Use ZcashBitGoPsbt for Zcash networks
-        const isZcash = this.network === "zec" || this.network === "tzec";
+        const isZcash = this.coin === "zec" || this.coin === "tzec";
         const psbt = isZcash
-            ? ZcashBitGoPsbt.createEmptyWithConsensusBranchId(this.network, this.rootWalletKeys, {
-                version: 2,
-                lockTime: 0,
-                consensusBranchId: 0xc2d6d0b4, // NU5
+            ? ZcashBitGoPsbt.createEmpty(this.coin, this.rootWalletKeys, {
+                // Sapling activation height: mainnet=419200, testnet=280000
+                blockHeight: this.coin === "zec" ? 419200 : 280000,
             })
-            : BitGoPsbt.createEmpty(this.network, this.rootWalletKeys, {
+            : BitGoPsbt.createEmpty(this.coin, this.rootWalletKeys, {
                 version: 2,
                 lockTime: 0,
             });
+        // Build a fake previous transaction for non_witness_utxo (psbt format)
+        const usePrevTx = this.txFormat === "psbt" && !isZcash;
+        const buildPrevTx = (vout, script, value) => {
+            if (!usePrevTx)
+                return undefined;
+            const tx = Transaction.create();
+            tx.addInput("0".repeat(64), 0xffffffff);
+            for (let i = 0; i < vout; i++) {
+                tx.addOutput(new Uint8Array(0), 0n);
+            }
+            tx.addOutput(script, value);
+            return tx.toBytes();
+        };
         // Add inputs with deterministic outpoints
         this.inputs.forEach((input, index) => {
-            // Resolve scriptId: either from explicit scriptId or from scriptType + index
-            const scriptId = input.scriptId ?? {
-                chain: ChainCode.value("p2sh", "external"),
-                index: input.index ?? index,
-            };
             const walletKeys = input.walletKeys ?? this.rootWalletKeys;
-            // Get scriptType: either explicit or derive from scriptId chain
-            const scriptType = input.scriptType ?? ChainCode.scriptType(assertChainCode(scriptId.chain));
-            if (scriptType === "p2shP2pk") {
-                // Add replay protection input
-                const replayKey = this.getReplayProtectionKey();
-                // Convert BIP32 to ECPair using public key
-                const ecpair = ECPair.fromPublicKey(replayKey.publicKey);
-                psbt.addReplayProtectionInput({
-                    txid: "0".repeat(64),
-                    vout: index,
-                    value: input.value,
-                }, ecpair);
+            const outpoint = { txid: "0".repeat(64), vout: index, value: input.value };
+            // scriptId variant: caller provides explicit chain + index
+            if (input.scriptId) {
+                const script = outputScript(walletKeys, input.scriptId.chain, input.scriptId.index, this.coin);
+                psbt.addWalletInput({ ...outpoint, prevTx: buildPrevTx(index, script, input.value) }, walletKeys, { scriptId: input.scriptId, signPath: { signer: "user", cosigner: "bitgo" } });
+                return;
             }
-            else {
-                // Determine signing path based on input type
-                let signPath;
-                if (scriptType === "p2trMusig2ScriptPath") {
-                    // Script path uses user + backup
-                    signPath = { signer: "user", cosigner: "backup" };
-                }
-                else {
-                    // Default: user + bitgo
-                    signPath = { signer: "user", cosigner: "bitgo" };
-                }
-                psbt.addWalletInput({
-                    txid: "0".repeat(64),
-                    vout: index,
-                    value: input.value,
-                }, walletKeys, {
-                    scriptId,
-                    signPath,
-                });
+            const scriptType = input.scriptType ?? "p2sh";
+            if (scriptType === "p2shP2pk") {
+                const ecpair = ECPair.fromPublicKey(this.getReplayProtectionKey().publicKey);
+                const script = p2shP2pkOutputScript(ecpair.publicKey);
+                psbt.addReplayProtectionInput({ ...outpoint, prevTx: buildPrevTx(index, script, input.value) }, ecpair);
+                return;
             }
+            const scriptId = {
+                chain: ChainCode.value(inputScriptTypeToOutputScriptType(scriptType), "external"),
+                index: input.index ?? index,
+            };
+            const signPath = scriptType === "p2trMusig2ScriptPath"
+                ? { signer: "user", cosigner: "backup" }
+                : { signer: "user", cosigner: "bitgo" };
+            const script = outputScript(walletKeys, scriptId.chain, scriptId.index, this.coin);
+            psbt.addWalletInput({ ...outpoint, prevTx: buildPrevTx(index, script, input.value) }, walletKeys, { scriptId, signPath });
         });
         // Add outputs
         this.outputs.forEach((output, index) => {
@@ -193,7 +206,7 @@ export class AcidTest {
                         chain: scriptId.chain,
                         index: output.index ?? 1000 + index,
                     };
-                    const script = outputScript(this.rootWalletKeys, externalScriptId.chain, externalScriptId.index, this.network);
+                    const script = outputScript(this.rootWalletKeys, externalScriptId.chain, externalScriptId.index, this.coin);
                     psbt.addOutput(script, output.value);
                 }
                 else {
@@ -224,36 +237,22 @@ export class AcidTest {
         // Generate MuSig2 nonces for user if needed
         const hasMusig2Inputs = this.inputs.some((input) => input.scriptType === "p2trMusig2KeyPath" || input.scriptType === "p2trMusig2ScriptPath");
         if (hasMusig2Inputs) {
-            const isZcash = this.network === "zec" || this.network === "tzec";
-            if (isZcash) {
+            if (this.coin === "zec" || this.coin === "tzec") {
                 throw new Error("Zcash does not support MuSig2/Taproot inputs");
             }
-            // Generate nonces with user key
+            // MuSig2 requires ALL participant nonces before ANY signing.
+            // Generate nonces directly on the same PSBT for each participant key.
             psbt.generateMusig2Nonces(userKey);
-            if (this.signStage === "fullsigned") {
-                // Create a second PSBT with cosigner nonces for combination
-                // For p2trMusig2ScriptPath use backup, for p2trMusig2KeyPath use bitgo
-                // Since we might have both types, we need to generate nonces separately
-                const bytes = psbt.serialize();
-                const hasKeyPath = this.inputs.some((input) => input.scriptType === "p2trMusig2KeyPath");
-                const hasScriptPath = this.inputs.some((input) => input.scriptType === "p2trMusig2ScriptPath");
-                if (hasKeyPath && !hasScriptPath) {
-                    // Only key path inputs - generate bitgo nonces for all
-                    const psbt2 = BitGoPsbt.fromBytes(bytes, this.network);
-                    psbt2.generateMusig2Nonces(bitgoKey);
-                    psbt.combineMusig2Nonces(psbt2);
-                }
-                else if (hasScriptPath && !hasKeyPath) {
-                    // Only script path inputs - generate backup nonces for all
-                    const psbt2 = BitGoPsbt.fromBytes(bytes, this.network);
-                    psbt2.generateMusig2Nonces(backupKey);
-                    psbt.combineMusig2Nonces(psbt2);
-                }
-                else {
-                    const psbt2 = BitGoPsbt.fromBytes(bytes, this.network);
-                    psbt2.generateMusig2Nonces(bitgoKey);
-                    psbt.combineMusig2Nonces(psbt2);
-                }
+            const hasKeyPath = this.inputs.some((input) => input.scriptType === "p2trMusig2KeyPath");
+            const hasScriptPath = this.inputs.some((input) => input.scriptType === "p2trMusig2ScriptPath");
+            // Key path uses user+bitgo, script path uses user+backup.
+            // generateMusig2Nonces fails if the key isn't a participant in any musig2 input,
+            // so we only call it for keys that match.
+            if (hasKeyPath) {
+                psbt.generateMusig2Nonces(bitgoKey);
+            }
+            if (hasScriptPath) {
+                psbt.generateMusig2Nonces(backupKey);
             }
         }
         // Sign all wallet inputs with user key (bulk - more efficient)
@@ -296,7 +295,7 @@ export class AcidTest {
      */
     static forAllNetworksSignStagesTxFormats(suiteConfig = {}) {
         return coinNames
-            .filter((network) => isMainnet(network) && network !== "bsv") // Exclude bitcoinsv
+            .filter((network) => isMainnet(network) && network !== "bsv")
             .flatMap((network) => signStages.flatMap((signStage) => txFormats.map((txFormat) => AcidTest.withConfig(network, signStage, txFormat, suiteConfig))));
     }
 }

package/dist/esm/js/wasm/wasm_utxo.d.ts

@@ -36,6 +36,11 @@ export class Bip322Namespace {
      * The index of the added input
      */
     static add_bip322_input(psbt: BitGoPsbt, message: string, chain: number, index: number, wallet_keys: WasmRootWalletKeys, signer?: string | null, cosigner?: string | null, tag?: string | null): number;
+    /**
+     * Get the BIP322 message stored at a PSBT input index.
+     * Returns null if no message is stored.
+     */
+    static get_bip322_message(psbt: BitGoPsbt, input_index: number): string | undefined;
     /**
      * Verify a single input of a BIP-0322 PSBT proof
      *
@@ -318,16 +323,7 @@ export class BitGoPsbt {
      * generated for security. Custom session_id is only allowed on testnets for testing purposes.
      */
     generate_musig2_nonces(xpriv: WasmBIP32, session_id_bytes?: Uint8Array | null): void;
-    /**
-     * Returns the global xpubs from the PSBT as an array of WasmBIP32 instances.
-     */
     get_global_xpubs(): any;
-    /**
-     * Get all PSBT inputs as an array of PsbtInputData
-     *
-     * Returns an array with witness_utxo, bip32_derivation, and tap_bip32_derivation
-     * for each input.
-     */
     get_inputs(): any;
     /**
      * Get the network type for transaction extraction
@@ -336,23 +332,8 @@ export class BitGoPsbt {
      * wrapper class should be used in TypeScript.
      */
     get_network_type(): string;
-    /**
-     * Get all PSBT outputs as an array of PsbtOutputData
-     *
-     * Returns an array with script, value, bip32_derivation, and tap_bip32_derivation
-     * for each output.
-     */
     get_outputs(): any;
-    /**
-     * Get all PSBT outputs with resolved address strings.
-     *
-     * Unlike the generic WrapPsbt which requires a coin parameter, BitGoPsbt
-     * uses the network it was created/deserialized with to resolve addresses.
-     */
     get_outputs_with_address(): any;
-    /**
-     * Get the number of inputs in the PSBT
-     */
     input_count(): number;
     /**
      * Check if an input is a MuSig2 keypath input.
@@ -368,17 +349,11 @@ export class BitGoPsbt {
      * - `false` otherwise (or if input_index is out of bounds)
      */
     is_musig2_input(input_index: number): boolean;
-    /**
-     * Get the transaction lock time
-     */
     lock_time(): number;
     /**
      * Get the network of the PSBT
      */
     network(): string;
-    /**
-     * Get the number of outputs in the PSBT
-     */
     output_count(): number;
     /**
      * Parse outputs with wallet keys to identify which outputs belong to a wallet
@@ -659,9 +634,6 @@ export class BitGoPsbt {
      * - `Err(WasmUtxoError)` if the input index is out of bounds, derivation fails, or verification fails
      */
     verify_signature_with_xpub(input_index: number, xpub: WasmBIP32): boolean;
-    /**
-     * Get the transaction version
-     */
     version(): number;
     /**
      * Get the Zcash version group ID (returns None for non-Zcash PSBTs)
@@ -1311,7 +1283,7 @@ export class WrapMiniscript {
 export class WrapPsbt {
     free(): void;
     [Symbol.dispose](): void;
-    addInput(txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number | null): number;
+    add_input(txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number | null): number;
     /**
      * Add an input to the PSBT
      *
@@ -1325,8 +1297,8 @@ export class WrapPsbt {
      * # Returns
      * The index of the newly added input
      */
-    addInputAtIndex(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number | null): number;
-    addOutput(script: Uint8Array, value: bigint): number;
+    add_input_at_index(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number | null): number;
+    add_output(script: Uint8Array, value: bigint): number;
     /**
      * Add an output to the PSBT
      *
@@ -1337,7 +1309,7 @@ export class WrapPsbt {
      * # Returns
      * The index of the newly added output
      */
-    addOutputAtIndex(index: number, script: Uint8Array, value: bigint): number;
+    add_output_at_index(index: number, script: Uint8Array, value: bigint): number;
     clone(): WrapPsbt;
     static deserialize(psbt: Uint8Array): WrapPsbt;
     /**
@@ -1350,57 +1322,23 @@ export class WrapPsbt {
      * - `Ok(WasmTransaction)` containing the extracted transaction
      * - `Err(WasmUtxoError)` if the PSBT is not fully finalized or extraction fails
      */
-    extractTransaction(): WasmTransaction;
-    finalize(): void;
-    /**
-     * Get global xpubs from the PSBT as an array of WasmBIP32 instances.
-     */
-    getGlobalXpubs(): any;
-    /**
-     * Get all PSBT inputs as an array of PsbtInputData
-     *
-     * Returns an array with witness_utxo, bip32_derivation, and tap_bip32_derivation
-     * for each input. This is useful for introspecting the PSBT structure.
-     */
-    getInputs(): any;
-    /**
-     * Get all PSBT outputs as an array of PsbtOutputData
-     *
-     * Returns an array with script, value, bip32_derivation, and tap_bip32_derivation
-     * for each output. This is useful for introspecting the PSBT structure.
-     */
-    getOutputs(): any;
-    /**
-     * Get all PSBT outputs with resolved address strings.
-     *
-     * Like `getOutputs()` but each element also includes an `address` field
-     * derived from the output script using the given coin name (e.g. "btc", "tbtc").
-     */
-    getOutputsWithAddress(coin: string): any;
-    /**
-     * Get partial signatures for an input
-     * Returns array of { pubkey: Uint8Array, signature: Uint8Array }
-     */
-    getPartialSignatures(input_index: number): any;
+    extract_transaction(): WasmTransaction;
+    finalize_mut(): void;
+    get_global_xpubs(): any;
+    get_inputs(): any;
+    get_outputs(): any;
+    get_outputs_with_address(coin: string): any;
+    get_partial_signatures(input_index: number): any;
     /**
      * Get the unsigned transaction bytes
      *
      * # Returns
      * The serialized unsigned transaction
      */
-    getUnsignedTx(): Uint8Array;
-    /**
-     * Check if an input has any partial signatures
-     */
-    hasPartialSignatures(input_index: number): boolean;
-    /**
-     * Get the number of inputs in the PSBT
-     */
-    inputCount(): number;
-    /**
-     * Get the transaction lock time
-     */
-    lockTime(): number;
+    get_unsigned_tx(): Uint8Array;
+    has_partial_signatures(input_index: number): boolean;
+    input_count(): number;
+    lock_time(): number;
     /**
      * Create an empty PSBT
      *
@@ -1409,12 +1347,9 @@ export class WrapPsbt {
      * * `lock_time` - Transaction lock time (default: 0)
      */
     constructor(version?: number | null, lock_time?: number | null);
-    /**
-     * Get the number of outputs in the PSBT
-     */
-    outputCount(): number;
-    removeInput(index: number): void;
-    removeOutput(index: number): void;
+    output_count(): number;
+    remove_input(index: number): void;
+    remove_output(index: number): void;
     serialize(): Uint8Array;
     /**
      * Sign all inputs with a WasmBIP32 key
@@ -1428,7 +1363,7 @@ export class WrapPsbt {
      * # Returns
      * A SigningKeysMap converted to JsValue (object mapping input indices to signing keys)
      */
-    signAll(key: WasmBIP32): any;
+    sign_all(key: WasmBIP32): any;
     /**
      * Sign all inputs with a WasmECPair key
      *
@@ -1441,23 +1376,13 @@ export class WrapPsbt {
      * # Returns
      * A SigningKeysMap converted to JsValue (object mapping input indices to signing keys)
      */
-    signAllWithEcpair(key: WasmECPair): any;
-    signWithPrv(prv: Uint8Array): any;
-    signWithXprv(xprv: string): any;
-    /**
-     * Get the unsigned transaction ID as a hex string
-     */
-    unsignedTxId(): string;
-    updateInputWithDescriptor(input_index: number, descriptor: WrapDescriptor): void;
-    updateOutputWithDescriptor(output_index: number, descriptor: WrapDescriptor): void;
-    /**
-     * Validate a signature at a specific input against a pubkey
-     * Returns true if the signature is valid
-     *
-     * This method handles both ECDSA (legacy/SegWit) and Schnorr (Taproot) signatures.
-     * The pubkey should be provided as bytes (33 bytes for compressed ECDSA, 32 bytes for x-only Schnorr).
-     */
-    validateSignatureAtInput(input_index: number, pubkey: Uint8Array): boolean;
+    sign_all_with_ecpair(key: WasmECPair): any;
+    sign_with_prv(prv: Uint8Array): any;
+    sign_with_xprv(xprv: string): any;
+    unsigned_tx_id(): string;
+    update_input_with_descriptor(input_index: number, descriptor: WrapDescriptor): void;
+    update_output_with_descriptor(output_index: number, descriptor: WrapDescriptor): void;
+    validate_signature_at_input(input_index: number, pubkey: Uint8Array): boolean;
     /**
      * Verify a signature at a specific input using a WasmBIP32 key
      *
@@ -1474,10 +1399,7 @@ export class WrapPsbt {
      * # Returns
      * `true` if a valid signature exists for the key, `false` otherwise
      */
-    verifySignatureWithKey(input_index: number, key: WasmBIP32): boolean;
-    /**
-     * Get the transaction version
-     */
+    verify_signature_with_key(input_index: number, key: WasmBIP32): boolean;
     version(): number;
 }