@bitgo/wasm-utxo 2.1.0 → 3.1.0

package/dist/cjs/js/bip322/index.d.ts

@@ -106,6 +106,11 @@ export type VerifyBip322TxInputParams = VerifyBip322InputParams & {
  * ```
  */
 export declare function addBip322Input(psbt: BitGoPsbt, params: AddBip322InputParams): number;
+/**
+ * Get the BIP322 message stored at a PSBT input index.
+ * Returns null if no message is stored.
+ */
+export declare function getBip322Message(psbt: BitGoPsbt, inputIndex: number): string | null;
 /**
  * Verify a single input of a BIP-0322 transaction proof
  *

package/dist/cjs/js/bip322/index.js

@@ -36,6 +36,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addBip322Input = addBip322Input;
+exports.getBip322Message = getBip322Message;
 exports.verifyBip322TxInput = verifyBip322TxInput;
 exports.verifyBip322PsbtInput = verifyBip322PsbtInput;
 exports.verifyBip322PsbtInputWithPubkeys = verifyBip322PsbtInputWithPubkeys;
@@ -75,6 +76,13 @@ function addBip322Input(psbt, params) {
     const keys = RootWalletKeys_js_1.RootWalletKeys.from(params.rootWalletKeys);
     return wasm_utxo_js_1.Bip322Namespace.add_bip322_input(psbt.wasm, params.message, params.scriptId.chain, params.scriptId.index, keys.wasm, params.signPath?.signer, params.signPath?.cosigner, params.tag);
 }
+/**
+ * Get the BIP322 message stored at a PSBT input index.
+ * Returns null if no message is stored.
+ */
+function getBip322Message(psbt, inputIndex) {
+    return wasm_utxo_js_1.Bip322Namespace.get_bip322_message(psbt.wasm, inputIndex) ?? null;
+}
 /**
  * Verify a single input of a BIP-0322 transaction proof
  *

package/dist/cjs/js/coinName.d.ts

@@ -4,3 +4,6 @@ export declare function getMainnet(name: CoinName): CoinName;
 export declare function isMainnet(name: CoinName): boolean;
 export declare function isTestnet(name: CoinName): boolean;
 export declare function isCoinName(v: string): v is CoinName;
+import type { UtxolibName } from "./utxolibCompat.js";
+/** Convert a CoinName or UtxolibName to CoinName */
+export declare function toCoinName(name: CoinName | UtxolibName): CoinName;

package/dist/cjs/js/coinName.js

@@ -5,6 +5,7 @@ exports.getMainnet = getMainnet;
 exports.isMainnet = isMainnet;
 exports.isTestnet = isTestnet;
 exports.isCoinName = isCoinName;
+exports.toCoinName = toCoinName;
 // BitGo coin names (from Network::from_coin_name in src/networks.rs)
 exports.coinNames = [
     "btc",
@@ -65,3 +66,51 @@ function isTestnet(name) {
 function isCoinName(v) {
     return exports.coinNames.includes(v);
 }
+/** Convert a CoinName or UtxolibName to CoinName */
+function toCoinName(name) {
+    switch (name) {
+        case "bitcoin":
+            return "btc";
+        case "testnet":
+            return "tbtc";
+        case "bitcoinTestnet4":
+            return "tbtc4";
+        case "bitcoinPublicSignet":
+            return "tbtcsig";
+        case "bitcoinBitGoSignet":
+            return "tbtcbgsig";
+        case "bitcoincash":
+            return "bch";
+        case "bitcoincashTestnet":
+            return "tbch";
+        case "ecash":
+            return "bcha";
+        case "ecashTest":
+            return "tbcha";
+        case "bitcoingold":
+            return "btg";
+        case "bitcoingoldTestnet":
+            return "tbtg";
+        case "bitcoinsv":
+            return "bsv";
+        case "bitcoinsvTestnet":
+            return "tbsv";
+        case "dashTest":
+            return "tdash";
+        case "dogecoin":
+            return "doge";
+        case "dogecoinTest":
+            return "tdoge";
+        case "litecoin":
+            return "ltc";
+        case "litecoinTest":
+            return "tltc";
+        case "zcash":
+            return "zec";
+        case "zcashTest":
+            return "tzec";
+        default:
+            // CoinName values pass through (including "dash" which is both CoinName and UtxolibName)
+            return name;
+    }
+}

package/dist/cjs/js/descriptorWallet/Psbt.d.ts

@@ -0,0 +1,49 @@
+import { WrapPsbt as WasmPsbt, type WasmBIP32, type WasmECPair, type WrapDescriptor, type PsbtInputData, type PsbtOutputData, type PsbtOutputDataWithAddress } from "../wasm/wasm_utxo.js";
+import type { IPsbt } from "../psbt.js";
+import type { CoinName } from "../coinName.js";
+import type { BIP32 } from "../bip32.js";
+import { Transaction } from "../transaction.js";
+export type SignPsbtResult = {
+    [inputIndex: number]: [pubkey: string][];
+};
+export declare class Psbt implements IPsbt {
+    private _wasm;
+    constructor(versionOrWasm?: number | WasmPsbt, lockTime?: number);
+    /** @internal Access the underlying WASM instance */
+    get wasm(): WasmPsbt;
+    static create(version?: number, lockTime?: number): Psbt;
+    static deserialize(bytes: Uint8Array): Psbt;
+    serialize(): Uint8Array;
+    clone(): Psbt;
+    inputCount(): number;
+    outputCount(): number;
+    version(): number;
+    lockTime(): number;
+    unsignedTxId(): string;
+    getInputs(): PsbtInputData[];
+    getOutputs(): PsbtOutputData[];
+    getGlobalXpubs(): BIP32[];
+    getOutputsWithAddress(coin: CoinName): PsbtOutputDataWithAddress[];
+    addInputAtIndex(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number): number;
+    addInput(txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number): number;
+    addOutputAtIndex(index: number, script: Uint8Array, value: bigint): number;
+    addOutput(script: Uint8Array, value: bigint): number;
+    removeInput(index: number): void;
+    removeOutput(index: number): void;
+    updateInputWithDescriptor(inputIndex: number, descriptor: WrapDescriptor): void;
+    updateOutputWithDescriptor(outputIndex: number, descriptor: WrapDescriptor): void;
+    signWithXprv(xprv: string): SignPsbtResult;
+    signWithPrv(prv: Uint8Array): SignPsbtResult;
+    signAll(key: WasmBIP32): SignPsbtResult;
+    signAllWithEcpair(key: WasmECPair): SignPsbtResult;
+    getPartialSignatures(inputIndex: number): Array<{
+        pubkey: Uint8Array;
+        signature: Uint8Array;
+    }>;
+    hasPartialSignatures(inputIndex: number): boolean;
+    validateSignatureAtInput(inputIndex: number, pubkey: Uint8Array): boolean;
+    verifySignatureWithKey(inputIndex: number, key: WasmBIP32): boolean;
+    getUnsignedTx(): Uint8Array;
+    finalize(): void;
+    extractTransaction(): Transaction;
+}

package/dist/cjs/js/descriptorWallet/Psbt.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Psbt = void 0;
+const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
+const transaction_js_1 = require("../transaction.js");
+class Psbt {
+    _wasm;
+    constructor(versionOrWasm, lockTime) {
+        if (versionOrWasm instanceof wasm_utxo_js_1.WrapPsbt) {
+            this._wasm = versionOrWasm;
+        }
+        else {
+            this._wasm = new wasm_utxo_js_1.WrapPsbt(versionOrWasm, lockTime);
+        }
+    }
+    /** @internal Access the underlying WASM instance */
+    get wasm() {
+        return this._wasm;
+    }
+    // -- Static / Factory --
+    static create(version, lockTime) {
+        return new Psbt(new wasm_utxo_js_1.WrapPsbt(version, lockTime));
+    }
+    static deserialize(bytes) {
+        return new Psbt(wasm_utxo_js_1.WrapPsbt.deserialize(bytes));
+    }
+    // -- Serialization --
+    serialize() {
+        return this._wasm.serialize();
+    }
+    clone() {
+        return new Psbt(this._wasm.clone());
+    }
+    // -- IPsbt: introspection --
+    inputCount() {
+        return this._wasm.input_count();
+    }
+    outputCount() {
+        return this._wasm.output_count();
+    }
+    version() {
+        return this._wasm.version();
+    }
+    lockTime() {
+        return this._wasm.lock_time();
+    }
+    unsignedTxId() {
+        return this._wasm.unsigned_tx_id();
+    }
+    getInputs() {
+        return this._wasm.get_inputs();
+    }
+    getOutputs() {
+        return this._wasm.get_outputs();
+    }
+    getGlobalXpubs() {
+        return this._wasm.get_global_xpubs();
+    }
+    getOutputsWithAddress(coin) {
+        return this._wasm.get_outputs_with_address(coin);
+    }
+    // -- IPsbt: mutation --
+    addInputAtIndex(index, txid, vout, value, script, sequence) {
+        return this._wasm.add_input_at_index(index, txid, vout, value, script, sequence);
+    }
+    addInput(txid, vout, value, script, sequence) {
+        return this._wasm.add_input(txid, vout, value, script, sequence);
+    }
+    addOutputAtIndex(index, script, value) {
+        return this._wasm.add_output_at_index(index, script, value);
+    }
+    addOutput(script, value) {
+        return this._wasm.add_output(script, value);
+    }
+    removeInput(index) {
+        this._wasm.remove_input(index);
+    }
+    removeOutput(index) {
+        this._wasm.remove_output(index);
+    }
+    // -- Descriptor updates --
+    updateInputWithDescriptor(inputIndex, descriptor) {
+        this._wasm.update_input_with_descriptor(inputIndex, descriptor);
+    }
+    updateOutputWithDescriptor(outputIndex, descriptor) {
+        this._wasm.update_output_with_descriptor(outputIndex, descriptor);
+    }
+    // -- Signing --
+    signWithXprv(xprv) {
+        return this._wasm.sign_with_xprv(xprv);
+    }
+    signWithPrv(prv) {
+        return this._wasm.sign_with_prv(prv);
+    }
+    signAll(key) {
+        return this._wasm.sign_all(key);
+    }
+    signAllWithEcpair(key) {
+        return this._wasm.sign_all_with_ecpair(key);
+    }
+    // -- Signature introspection --
+    getPartialSignatures(inputIndex) {
+        return this._wasm.get_partial_signatures(inputIndex);
+    }
+    hasPartialSignatures(inputIndex) {
+        return this._wasm.has_partial_signatures(inputIndex);
+    }
+    // -- Validation --
+    validateSignatureAtInput(inputIndex, pubkey) {
+        return this._wasm.validate_signature_at_input(inputIndex, pubkey);
+    }
+    verifySignatureWithKey(inputIndex, key) {
+        return this._wasm.verify_signature_with_key(inputIndex, key);
+    }
+    // -- Transaction extraction --
+    getUnsignedTx() {
+        return this._wasm.get_unsigned_tx();
+    }
+    finalize() {
+        this._wasm.finalize_mut();
+    }
+    extractTransaction() {
+        return transaction_js_1.Transaction.fromWasm(this._wasm.extract_transaction());
+    }
+}
+exports.Psbt = Psbt;

package/dist/cjs/js/descriptorWallet/index.d.ts

@@ -40,4 +40,5 @@ export * from "./DescriptorOutput.js";
 export * from "./address.js";
 export * from "./VirtualSize.js";
 export * from "./psbt/index.js";
+export { Psbt, type SignPsbtResult } from "./Psbt.js";
 export * from "./parse/PatternMatcher.js";

package/dist/cjs/js/descriptorWallet/index.js

@@ -49,6 +49,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Psbt = void 0;
 // Core types and utilities
 __exportStar(require("./Output.js"), exports);
 __exportStar(require("./DescriptorMap.js"), exports);
@@ -58,5 +59,8 @@ __exportStar(require("./address.js"), exports);
 __exportStar(require("./VirtualSize.js"), exports);
 // PSBT utilities
 __exportStar(require("./psbt/index.js"), exports);
+// PSBT wrapper
+var Psbt_js_1 = require("./Psbt.js");
+Object.defineProperty(exports, "Psbt", { enumerable: true, get: function () { return Psbt_js_1.Psbt; } });
 // Pattern matching
 __exportStar(require("./parse/PatternMatcher.js"), exports);

package/dist/cjs/js/index.d.ts

@@ -17,9 +17,6 @@ export type { AddressFormat } from "./address.js";
 export type { TapLeafScript, PreparedInscriptionRevealData } from "./inscriptions.js";
 export type DescriptorPkType = "derivable" | "definite" | "string";
 export type ScriptContext = "tap" | "segwitv0" | "legacy";
-export type SignPsbtResult = {
-    [inputIndex: number]: [pubkey: string][];
-};
 declare module "./wasm/wasm_utxo.js" {
     interface WrapDescriptor {
         /** These are not the same types of nodes as in the ast module */
@@ -64,36 +61,9 @@ declare module "./wasm/wasm_utxo.js" {
     interface PsbtOutputDataWithAddress extends PsbtOutputData {
         address: string;
     }
-    interface WrapPsbt {
-        signWithXprv(this: WrapPsbt, xprv: string): SignPsbtResult;
-        signWithPrv(this: WrapPsbt, prv: Uint8Array): SignPsbtResult;
-        signAll(this: WrapPsbt, key: WasmBIP32): SignPsbtResult;
-        signAllWithEcpair(this: WrapPsbt, key: WasmECPair): SignPsbtResult;
-        inputCount(): number;
-        outputCount(): number;
-        getInputs(): PsbtInputData[];
-        getOutputs(): PsbtOutputData[];
-        getOutputsWithAddress(coin: import("./coinName.js").CoinName): PsbtOutputDataWithAddress[];
-        getGlobalXpubs(): WasmBIP32[];
-        getPartialSignatures(inputIndex: number): Array<{
-            pubkey: Uint8Array;
-            signature: Uint8Array;
-        }>;
-        hasPartialSignatures(inputIndex: number): boolean;
-        validateSignatureAtInput(inputIndex: number, pubkey: Uint8Array): boolean;
-        verifySignatureWithKey(inputIndex: number, key: WasmBIP32): boolean;
-        extractTransaction(): WasmTransaction;
-        addInputAtIndex(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number): number;
-        addOutputAtIndex(index: number, script: Uint8Array, value: bigint): number;
-        removeInput(index: number): void;
-        removeOutput(index: number): void;
-        unsignedTxId(): string;
-        lockTime(): number;
-        version(): number;
-    }
 }
 export { WrapDescriptor as Descriptor } from "./wasm/wasm_utxo.js";
 export { WrapMiniscript as Miniscript } from "./wasm/wasm_utxo.js";
-export { WrapPsbt as Psbt } from "./wasm/wasm_utxo.js";
+export { Psbt } from "./descriptorWallet/Psbt.js";
 export { DashTransaction, Transaction, ZcashTransaction } from "./transaction.js";
 export { hasPsbtMagic, type IPsbt, type IPsbtWithAddress } from "./psbt.js";

package/dist/cjs/js/index.js

@@ -66,8 +66,8 @@ var wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
 Object.defineProperty(exports, "Descriptor", { enumerable: true, get: function () { return wasm_utxo_js_1.WrapDescriptor; } });
 var wasm_utxo_js_2 = require("./wasm/wasm_utxo.js");
 Object.defineProperty(exports, "Miniscript", { enumerable: true, get: function () { return wasm_utxo_js_2.WrapMiniscript; } });
-var wasm_utxo_js_3 = require("./wasm/wasm_utxo.js");
-Object.defineProperty(exports, "Psbt", { enumerable: true, get: function () { return wasm_utxo_js_3.WrapPsbt; } });
+var Psbt_js_1 = require("./descriptorWallet/Psbt.js");
+Object.defineProperty(exports, "Psbt", { enumerable: true, get: function () { return Psbt_js_1.Psbt; } });
 var transaction_js_1 = require("./transaction.js");
 Object.defineProperty(exports, "DashTransaction", { enumerable: true, get: function () { return transaction_js_1.DashTransaction; } });
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_js_1.Transaction; } });

package/dist/cjs/js/testutils/AcidTest.d.ts

@@ -94,7 +94,7 @@ export { inputScriptTypes, outputScriptTypes };
  * - psbt-lite: Only witness_utxo (no non_witness_utxo)
  */
 export declare class AcidTest {
-    readonly network: CoinName;
+    readonly coin: CoinName;
     readonly signStage: SignStage;
     readonly txFormat: TxFormat;
     readonly rootWalletKeys: RootWalletKeys;
@@ -104,11 +104,11 @@ export declare class AcidTest {
     private readonly userXprv;
     private readonly backupXprv;
     private readonly bitgoXprv;
-    constructor(network: CoinName, signStage: SignStage, txFormat: TxFormat, rootWalletKeys: RootWalletKeys, otherWalletKeys: RootWalletKeys, inputs: Input[], outputs: Output[], xprvTriple: Triple<BIP32>);
+    constructor(coin: CoinName, signStage: SignStage, txFormat: TxFormat, rootWalletKeys: RootWalletKeys, otherWalletKeys: RootWalletKeys, inputs: Input[], outputs: Output[], xprvTriple: Triple<BIP32>);
     /**
      * Create an AcidTest with specific configuration
      */
-    static withConfig(network: CoinName, signStage: SignStage, txFormat: TxFormat, suiteConfig?: SuiteConfig): AcidTest;
+    static withConfig(coin: CoinName, signStage: SignStage, txFormat: TxFormat, suiteConfig?: SuiteConfig): AcidTest;
     /**
      * Get a human-readable name for this test configuration
      */

package/dist/cjs/js/testutils/AcidTest.js

@@ -4,6 +4,7 @@ exports.AcidTest = exports.outputScriptTypes = exports.inputScriptTypes = export
 const BitGoPsbt_js_1 = require("../fixedScriptWallet/BitGoPsbt.js");
 const ZcashBitGoPsbt_js_1 = require("../fixedScriptWallet/ZcashBitGoPsbt.js");
 const ecpair_js_1 = require("../ecpair.js");
+const transaction_js_1 = require("../transaction.js");
 const index_js_1 = require("../fixedScriptWallet/index.js");
 Object.defineProperty(exports, "inputScriptTypes", { enumerable: true, get: function () { return index_js_1.inputScriptTypes; } });
 Object.defineProperty(exports, "outputScriptTypes", { enumerable: true, get: function () { return index_js_1.outputScriptTypes; } });
@@ -11,6 +12,21 @@ const coinName_js_1 = require("../coinName.js");
 const keys_js_1 = require("./keys.js");
 exports.signStages = ["unsigned", "halfsigned", "fullsigned"];
 exports.txFormats = ["psbt", "psbt-lite"];
+/** 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).
  *
@@ -33,7 +49,7 @@ exports.txFormats = ["psbt", "psbt-lite"];
  * - psbt-lite: Only witness_utxo (no non_witness_utxo)
  */
 class AcidTest {
-    network;
+    coin;
     signStage;
     txFormat;
     rootWalletKeys;
@@ -44,8 +60,8 @@ 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;
@@ -59,7 +75,7 @@ class AcidTest {
     /**
      * Create an AcidTest with specific configuration
      */
-    static withConfig(network, signStage, txFormat, suiteConfig = {}) {
+    static withConfig(coin, signStage, txFormat, suiteConfig = {}) {
         const rootWalletKeys = (0, keys_js_1.getDefaultWalletKeys)();
         const otherWalletKeys = (0, keys_js_1.getWalletKeysForSeed)("too many secrets");
         // Filter inputs based on network support
@@ -70,9 +86,9 @@ class AcidTest {
                 return true;
             // Map input script types to output script types for support check
             if (scriptType === "p2trMusig2KeyPath" || scriptType === "p2trMusig2ScriptPath") {
-                return (0, index_js_1.supportsScriptType)(network, "p2trMusig2");
+                return (0, index_js_1.supportsScriptType)(coin, "p2trMusig2");
             }
-            return (0, index_js_1.supportsScriptType)(network, scriptType);
+            return (0, index_js_1.supportsScriptType)(coin, scriptType);
         })
             .filter((scriptType) => (suiteConfig.includeP2trMusig2ScriptPath ?? false) ||
             scriptType !== "p2trMusig2ScriptPath")
@@ -82,7 +98,7 @@ class AcidTest {
         }));
         // Filter outputs based on network support
         const outputs = index_js_1.outputScriptTypes
-            .filter((scriptType) => (0, index_js_1.supportsScriptType)(network, scriptType))
+            .filter((scriptType) => (0, index_js_1.supportsScriptType)(coin, scriptType))
             .map((scriptType, index) => ({
             scriptType,
             value: BigInt(900 + index * 100), // Deterministic amounts
@@ -95,13 +111,13 @@ class AcidTest {
         outputs.push({ opReturn: "setec astronomy", value: BigInt(0) });
         // Get private keys for signing
         const xprvTriple = (0, keys_js_1.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)
@@ -114,58 +130,55 @@ 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_js_1.ZcashBitGoPsbt.createEmptyWithConsensusBranchId(this.network, this.rootWalletKeys, {
-                version: 2,
-                lockTime: 0,
-                consensusBranchId: 0xc2d6d0b4, // NU5
+            ? ZcashBitGoPsbt_js_1.ZcashBitGoPsbt.createEmpty(this.coin, this.rootWalletKeys, {
+                // Sapling activation height: mainnet=419200, testnet=280000
+                blockHeight: this.coin === "zec" ? 419200 : 280000,
             })
-            : BitGoPsbt_js_1.BitGoPsbt.createEmpty(this.network, this.rootWalletKeys, {
+            : BitGoPsbt_js_1.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_js_1.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: index_js_1.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 ?? index_js_1.ChainCode.scriptType((0, index_js_1.assertChainCode)(scriptId.chain));
-            if (scriptType === "p2shP2pk") {
-                // Add replay protection input
-                const replayKey = this.getReplayProtectionKey();
-                // Convert BIP32 to ECPair using public key
-                const ecpair = ecpair_js_1.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 = (0, index_js_1.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_js_1.ECPair.fromPublicKey(this.getReplayProtectionKey().publicKey);
+                const script = (0, index_js_1.p2shP2pkOutputScript)(ecpair.publicKey);
+                psbt.addReplayProtectionInput({ ...outpoint, prevTx: buildPrevTx(index, script, input.value) }, ecpair);
+                return;
             }
+            const scriptId = {
+                chain: index_js_1.ChainCode.value(inputScriptTypeToOutputScriptType(scriptType), "external"),
+                index: input.index ?? index,
+            };
+            const signPath = scriptType === "p2trMusig2ScriptPath"
+                ? { signer: "user", cosigner: "backup" }
+                : { signer: "user", cosigner: "bitgo" };
+            const script = (0, index_js_1.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) => {
@@ -196,7 +209,7 @@ class AcidTest {
                         chain: scriptId.chain,
                         index: output.index ?? 1000 + index,
                     };
-                    const script = (0, index_js_1.outputScript)(this.rootWalletKeys, externalScriptId.chain, externalScriptId.index, this.network);
+                    const script = (0, index_js_1.outputScript)(this.rootWalletKeys, externalScriptId.chain, externalScriptId.index, this.coin);
                     psbt.addOutput(script, output.value);
                 }
                 else {
@@ -227,36 +240,22 @@ 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_js_1.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_js_1.BitGoPsbt.fromBytes(bytes, this.network);
-                    psbt2.generateMusig2Nonces(backupKey);
-                    psbt.combineMusig2Nonces(psbt2);
-                }
-                else {
-                    const psbt2 = BitGoPsbt_js_1.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)
@@ -299,7 +298,7 @@ class AcidTest {
      */
     static forAllNetworksSignStagesTxFormats(suiteConfig = {}) {
         return coinName_js_1.coinNames
-            .filter((network) => (0, coinName_js_1.isMainnet)(network) && network !== "bsv") // Exclude bitcoinsv
+            .filter((network) => (0, coinName_js_1.isMainnet)(network) && network !== "bsv")
             .flatMap((network) => exports.signStages.flatMap((signStage) => exports.txFormats.map((txFormat) => AcidTest.withConfig(network, signStage, txFormat, suiteConfig))));
     }
 }