@bitgo/wasm-utxo 1.28.0 → 1.29.0

package/dist/cjs/js/fixedScriptWallet/chains.d.ts

@@ -5,6 +5,11 @@ export declare const chainCodes: readonly [0, 1, 10, 11, 20, 21, 30, 31, 40, 41]
 export type ChainCode = (typeof chainCodes)[number];
 /** Whether a chain is for receiving (external) or change (internal) addresses */
 export type Scope = "internal" | "external";
+/**
+ * Assert that a number is a valid chain code.
+ * @throws Error if the number is not a valid chain code
+ */
+export declare function assertChainCode(n: number): ChainCode;
 /**
  * ChainCode namespace with utility functions for working with chain codes.
  */

package/dist/cjs/js/fixedScriptWallet/chains.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChainCode = exports.chainCodes = void 0;
+exports.assertChainCode = assertChainCode;
 /**
  * Chain code utilities for BitGo fixed-script wallets.
  *
@@ -14,10 +15,13 @@ exports.chainCodes = [0, 1, 10, 11, 20, 21, 30, 31, 40, 41];
 const chainCodeSet = new Set(exports.chainCodes);
 const chainToMeta = new Map();
 const scriptTypeToChain = new Map();
-// Initialize from WASM (called once at load time)
+/**
+ * Assert that a number is a valid chain code.
+ * @throws Error if the number is not a valid chain code
+ */
 function assertChainCode(n) {
     if (!chainCodeSet.has(n)) {
-        throw new Error(`Invalid chain code from WASM: ${n}`);
+        throw new Error(`Invalid chain code: ${n}`);
     }
     return n;
 }

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

@@ -3,8 +3,8 @@ export { RootWalletKeys, type WalletKeysArg, type IWalletKeys } from "./RootWall
 export { ReplayProtection, type ReplayProtectionArg } from "./ReplayProtection.js";
 export { outputScript, address } from "./address.js";
 export { Dimensions } from "./Dimensions.js";
-export { type OutputScriptType, type InputScriptType, type ScriptType } from "./scriptType.js";
-export { ChainCode, chainCodes, type Scope } from "./chains.js";
+export { outputScriptTypes, inputScriptTypes, type OutputScriptType, type InputScriptType, type ScriptType, } from "./scriptType.js";
+export { ChainCode, chainCodes, assertChainCode, type Scope } from "./chains.js";
 export { BitGoPsbt, type NetworkName, type ScriptId, type ParsedInput, type ParsedOutput, type ParsedTransaction, type SignPath, type CreateEmptyOptions, type AddInputOptions, type AddOutputOptions, type AddWalletInputOptions, type AddWalletOutputOptions, } from "./BitGoPsbt.js";
 export { ZcashBitGoPsbt, type ZcashNetworkName, type CreateEmptyZcashOptions, } from "./ZcashBitGoPsbt.js";
 import type { ScriptType } from "./scriptType.js";
@@ -34,3 +34,20 @@ import type { ScriptType } from "./scriptType.js";
  * ```
  */
 export declare function supportsScriptType(coin: CoinName, scriptType: ScriptType): boolean;
+/**
+ * Create an OP_RETURN output script with optional data
+ *
+ * @param data - Optional data bytes to include in the OP_RETURN script
+ * @returns The OP_RETURN script as a Uint8Array
+ *
+ * @example
+ * ```typescript
+ * // Empty OP_RETURN
+ * const script = createOpReturnScript();
+ *
+ * // OP_RETURN with data
+ * const data = new Uint8Array([1, 2, 3, 4]);
+ * const script = createOpReturnScript(data);
+ * ```
+ */
+export declare function createOpReturnScript(data?: Uint8Array): Uint8Array;

package/dist/cjs/js/fixedScriptWallet/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZcashBitGoPsbt = exports.BitGoPsbt = exports.chainCodes = exports.ChainCode = exports.Dimensions = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
+exports.ZcashBitGoPsbt = exports.BitGoPsbt = exports.assertChainCode = exports.chainCodes = exports.ChainCode = exports.inputScriptTypes = exports.outputScriptTypes = exports.Dimensions = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
 exports.supportsScriptType = supportsScriptType;
+exports.createOpReturnScript = createOpReturnScript;
 const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
 var RootWalletKeys_js_1 = require("./RootWalletKeys.js");
 Object.defineProperty(exports, "RootWalletKeys", { enumerable: true, get: function () { return RootWalletKeys_js_1.RootWalletKeys; } });
@@ -12,9 +13,13 @@ Object.defineProperty(exports, "outputScript", { enumerable: true, get: function
 Object.defineProperty(exports, "address", { enumerable: true, get: function () { return address_js_1.address; } });
 var Dimensions_js_1 = require("./Dimensions.js");
 Object.defineProperty(exports, "Dimensions", { enumerable: true, get: function () { return Dimensions_js_1.Dimensions; } });
+var scriptType_js_1 = require("./scriptType.js");
+Object.defineProperty(exports, "outputScriptTypes", { enumerable: true, get: function () { return scriptType_js_1.outputScriptTypes; } });
+Object.defineProperty(exports, "inputScriptTypes", { enumerable: true, get: function () { return scriptType_js_1.inputScriptTypes; } });
 var chains_js_1 = require("./chains.js");
 Object.defineProperty(exports, "ChainCode", { enumerable: true, get: function () { return chains_js_1.ChainCode; } });
 Object.defineProperty(exports, "chainCodes", { enumerable: true, get: function () { return chains_js_1.chainCodes; } });
+Object.defineProperty(exports, "assertChainCode", { enumerable: true, get: function () { return chains_js_1.assertChainCode; } });
 // Bitcoin-like PSBT (for all non-Zcash networks)
 var BitGoPsbt_js_1 = require("./BitGoPsbt.js");
 Object.defineProperty(exports, "BitGoPsbt", { enumerable: true, get: function () { return BitGoPsbt_js_1.BitGoPsbt; } });
@@ -49,3 +54,22 @@ Object.defineProperty(exports, "ZcashBitGoPsbt", { enumerable: true, get: functi
 function supportsScriptType(coin, scriptType) {
     return wasm_utxo_js_1.FixedScriptWalletNamespace.supports_script_type(coin, scriptType);
 }
+/**
+ * Create an OP_RETURN output script with optional data
+ *
+ * @param data - Optional data bytes to include in the OP_RETURN script
+ * @returns The OP_RETURN script as a Uint8Array
+ *
+ * @example
+ * ```typescript
+ * // Empty OP_RETURN
+ * const script = createOpReturnScript();
+ *
+ * // OP_RETURN with data
+ * const data = new Uint8Array([1, 2, 3, 4]);
+ * const script = createOpReturnScript(data);
+ * ```
+ */
+function createOpReturnScript(data) {
+    return wasm_utxo_js_1.FixedScriptWalletNamespace.create_op_return_script(data);
+}

package/dist/cjs/js/fixedScriptWallet/scriptType.d.ts

@@ -1,16 +1,26 @@
 /**
- * Fixed-script wallet output script types (2-of-3 multisig)
+ * All output script types for fixed-script wallets (2-of-3 multisig)
  *
- * This type represents the abstract script type, independent of chain (external/internal).
+ * This represents the abstract script type, independent of chain (external/internal).
  * Use this for checking network support or when you need the script type without derivation info.
  */
-export type OutputScriptType = "p2sh" | "p2shP2wsh" | "p2wsh" | "p2tr" | "p2trLegacy" | "p2trMusig2";
+export declare const outputScriptTypes: readonly ["p2sh", "p2shP2wsh", "p2wsh", "p2trLegacy", "p2trMusig2"];
 /**
- * Input script types for fixed-script wallets
+ * Output script type for fixed-script wallets
+ *
+ * Note: "p2tr" is an alias for "p2trLegacy" for backward compatibility.
+ */
+export type OutputScriptType = (typeof outputScriptTypes)[number] | "p2tr";
+/**
+ * All input script types for fixed-script wallets
  *
  * These are more specific than output types and include single-sig and taproot variants.
  */
-export type InputScriptType = "p2shP2pk" | "p2sh" | "p2shP2wsh" | "p2wsh" | "p2trLegacy" | "p2trMusig2ScriptPath" | "p2trMusig2KeyPath";
+export declare const inputScriptTypes: readonly ["p2shP2pk", "p2sh", "p2shP2wsh", "p2wsh", "p2trLegacy", "p2trMusig2ScriptPath", "p2trMusig2KeyPath"];
+/**
+ * Input script type for fixed-script wallets
+ */
+export type InputScriptType = (typeof inputScriptTypes)[number];
 /**
  * Union of all script types that can be checked for network support
  */

package/dist/cjs/js/fixedScriptWallet/scriptType.js

@@ -1,2 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputScriptTypes = exports.outputScriptTypes = void 0;
+/**
+ * All output script types for fixed-script wallets (2-of-3 multisig)
+ *
+ * This represents the abstract script type, independent of chain (external/internal).
+ * Use this for checking network support or when you need the script type without derivation info.
+ */
+exports.outputScriptTypes = [
+    "p2sh",
+    "p2shP2wsh",
+    "p2wsh",
+    "p2trLegacy",
+    "p2trMusig2",
+];
+/**
+ * All input script types for fixed-script wallets
+ *
+ * These are more specific than output types and include single-sig and taproot variants.
+ */
+exports.inputScriptTypes = [
+    "p2shP2pk",
+    "p2sh",
+    "p2shP2wsh",
+    "p2wsh",
+    "p2trLegacy",
+    "p2trMusig2ScriptPath",
+    "p2trMusig2KeyPath",
+];

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

@@ -0,0 +1,132 @@
+import { BitGoPsbt } from "../fixedScriptWallet/BitGoPsbt.js";
+import { RootWalletKeys } from "../fixedScriptWallet/RootWalletKeys.js";
+import { BIP32 } from "../bip32.js";
+import { inputScriptTypes, outputScriptTypes, type InputScriptType, type OutputScriptType, type ScriptId } from "../fixedScriptWallet/index.js";
+import type { CoinName } from "../coinName.js";
+import type { Triple } from "../triple.js";
+export declare const signStages: readonly ["unsigned", "halfsigned", "fullsigned"];
+export type SignStage = (typeof signStages)[number];
+export declare const txFormats: readonly ["psbt", "psbt-lite"];
+export type TxFormat = (typeof txFormats)[number];
+/**
+ * Utility type to make union variants mutually exclusive.
+ * For each variant T in the union, adds `?: never` for all keys from other variants.
+ */
+type Exclusive<T, U = T> = T extends unknown ? T & Partial<Record<Exclude<U extends unknown ? keyof U : never, keyof T>, never>> : never;
+/** Base input fields */
+type InputBase = {
+    value: bigint;
+    /** Wallet keys to use. Defaults to root wallet keys */
+    walletKeys?: RootWalletKeys;
+};
+/** Input variant types */
+type InputVariant = {
+    scriptType: InputScriptType;
+    index?: number;
+} | {
+    scriptId: ScriptId;
+};
+/**
+ * Input configuration for AcidTest PSBT
+ *
+ * Either specify `scriptType` (chain derived from type, index defaults to position)
+ * or specify `scriptId` (explicit chain + index).
+ */
+export type Input = InputBase & Exclusive<InputVariant>;
+/** Base output fields */
+type OutputBase = {
+    value: bigint;
+    /** Wallet keys to use. Defaults to root wallet keys. null = external output (no bip32 derivation) */
+    walletKeys?: RootWalletKeys | null;
+};
+/** Output variant types */
+type OutputVariant = {
+    scriptType: OutputScriptType;
+    index?: number;
+} | {
+    scriptId: ScriptId;
+} | {
+    opReturn: string;
+} | {
+    address: string;
+} | {
+    script: Uint8Array;
+};
+/**
+ * Output configuration for AcidTest PSBT
+ *
+ * Specify one of:
+ * - `scriptType` (chain derived from type, index defaults to position)
+ * - `scriptId` (explicit chain + index)
+ * - `opReturn` for OP_RETURN data output
+ * - `address` for address-based output
+ * - `script` for raw script output
+ */
+export type Output = OutputBase & Exclusive<OutputVariant>;
+type SuiteConfig = {
+    /**
+     * By default, we exclude p2trMusig2ScriptPath from the inputs since
+     * it uses user + backup keys (not typical 2-of-3 with user + bitgo).
+     * Set to true to include this input type.
+     */
+    includeP2trMusig2ScriptPath?: boolean;
+};
+export { inputScriptTypes, outputScriptTypes };
+/**
+ * Creates a valid PSBT with as many features as possible (kitchen sink).
+ *
+ * - Inputs:
+ *   - All wallet script types supported by the network
+ *   - A p2shP2pk input (for replay protection)
+ * - Outputs:
+ *   - All wallet script types supported by the network
+ *   - A p2sh output with derivation info of a different wallet
+ *   - A p2sh output with no derivation info (external output)
+ *   - An OP_RETURN output
+ *
+ * Signature stages:
+ * - unsigned: No signatures
+ * - halfsigned: One signature per input (user key)
+ * - fullsigned: Two signatures per input (user + bitgo)
+ *
+ * Transaction formats:
+ * - psbt: Full PSBT with non_witness_utxo
+ * - psbt-lite: Only witness_utxo (no non_witness_utxo)
+ */
+export declare class AcidTest {
+    readonly network: CoinName;
+    readonly signStage: SignStage;
+    readonly txFormat: TxFormat;
+    readonly rootWalletKeys: RootWalletKeys;
+    readonly otherWalletKeys: RootWalletKeys;
+    readonly inputs: Input[];
+    readonly outputs: Output[];
+    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>);
+    /**
+     * Create an AcidTest with specific configuration
+     */
+    static withConfig(network: CoinName, signStage: SignStage, txFormat: TxFormat, suiteConfig?: SuiteConfig): AcidTest;
+    /**
+     * Get a human-readable name for this test configuration
+     */
+    get name(): string;
+    /**
+     * Get the BIP32 user key for replay protection (p2shP2pk)
+     */
+    getReplayProtectionKey(): BIP32;
+    /**
+     * Create the actual PSBT with all inputs and outputs
+     */
+    createPsbt(): BitGoPsbt;
+    /**
+     * Sign the PSBT according to the sign stage
+     */
+    private signPsbt;
+    /**
+     * Generate test suite for all networks, sign stages, and tx formats
+     */
+    static forAllNetworksSignStagesTxFormats(suiteConfig?: SuiteConfig): AcidTest[];
+}

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

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcidTest = exports.outputScriptTypes = exports.inputScriptTypes = exports.txFormats = exports.signStages = void 0;
+const BitGoPsbt_js_1 = require("../fixedScriptWallet/BitGoPsbt.js");
+const ZcashBitGoPsbt_js_1 = require("../fixedScriptWallet/ZcashBitGoPsbt.js");
+const ecpair_js_1 = require("../ecpair.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; } });
+const coinName_js_1 = require("../coinName.js");
+const keys_js_1 = require("./keys.js");
+exports.signStages = ["unsigned", "halfsigned", "fullsigned"];
+exports.txFormats = ["psbt", "psbt-lite"];
+/**
+ * Creates a valid PSBT with as many features as possible (kitchen sink).
+ *
+ * - Inputs:
+ *   - All wallet script types supported by the network
+ *   - A p2shP2pk input (for replay protection)
+ * - Outputs:
+ *   - All wallet script types supported by the network
+ *   - A p2sh output with derivation info of a different wallet
+ *   - A p2sh output with no derivation info (external output)
+ *   - An OP_RETURN output
+ *
+ * Signature stages:
+ * - unsigned: No signatures
+ * - halfsigned: One signature per input (user key)
+ * - fullsigned: Two signatures per input (user + bitgo)
+ *
+ * Transaction formats:
+ * - psbt: Full PSBT with non_witness_utxo
+ * - psbt-lite: Only witness_utxo (no non_witness_utxo)
+ */
+class AcidTest {
+    network;
+    signStage;
+    txFormat;
+    rootWalletKeys;
+    otherWalletKeys;
+    inputs;
+    outputs;
+    // Store private keys for signing
+    userXprv;
+    backupXprv;
+    bitgoXprv;
+    constructor(network, signStage, txFormat, rootWalletKeys, otherWalletKeys, inputs, outputs, xprvTriple) {
+        this.network = network;
+        this.signStage = signStage;
+        this.txFormat = txFormat;
+        this.rootWalletKeys = rootWalletKeys;
+        this.otherWalletKeys = otherWalletKeys;
+        this.inputs = inputs;
+        this.outputs = outputs;
+        this.userXprv = xprvTriple[0];
+        this.backupXprv = xprvTriple[1];
+        this.bitgoXprv = xprvTriple[2];
+    }
+    /**
+     * Create an AcidTest with specific configuration
+     */
+    static withConfig(network, 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
+        const inputs = index_js_1.inputScriptTypes
+            .filter((scriptType) => {
+            // p2shP2pk is always supported (single-sig replay protection)
+            if (scriptType === "p2shP2pk")
+                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)(network, scriptType);
+        })
+            .filter((scriptType) => (suiteConfig.includeP2trMusig2ScriptPath ?? false) ||
+            scriptType !== "p2trMusig2ScriptPath")
+            .map((scriptType, index) => ({
+            scriptType,
+            value: BigInt(10000 + index * 10000), // Deterministic amounts
+        }));
+        // Filter outputs based on network support
+        const outputs = index_js_1.outputScriptTypes
+            .filter((scriptType) => (0, index_js_1.supportsScriptType)(network, scriptType))
+            .map((scriptType, index) => ({
+            scriptType,
+            value: BigInt(900 + index * 100), // Deterministic amounts
+        }));
+        // Test other wallet output (with derivation info)
+        outputs.push({ scriptType: "p2sh", value: BigInt(800), walletKeys: otherWalletKeys });
+        // Test non-wallet output (no derivation info)
+        outputs.push({ scriptType: "p2sh", value: BigInt(700), walletKeys: null });
+        // Test OP_RETURN output
+        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);
+    }
+    /**
+     * Get a human-readable name for this test configuration
+     */
+    get name() {
+        return `${this.network} ${this.signStage} ${this.txFormat}`;
+    }
+    /**
+     * Get the BIP32 user key for replay protection (p2shP2pk)
+     */
+    getReplayProtectionKey() {
+        return this.rootWalletKeys.userKey();
+    }
+    /**
+     * Create the actual PSBT with all inputs and outputs
+     */
+    createPsbt() {
+        // Use ZcashBitGoPsbt for Zcash networks
+        const isZcash = this.network === "zec" || this.network === "tzec";
+        const psbt = isZcash
+            ? ZcashBitGoPsbt_js_1.ZcashBitGoPsbt.createEmptyWithConsensusBranchId(this.network, this.rootWalletKeys, {
+                version: 2,
+                lockTime: 0,
+                consensusBranchId: 0xc2d6d0b4, // NU5
+            })
+            : BitGoPsbt_js_1.BitGoPsbt.createEmpty(this.network, this.rootWalletKeys, {
+                version: 2,
+                lockTime: 0,
+            });
+        // 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);
+            }
+            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,
+                });
+            }
+        });
+        // Add outputs
+        this.outputs.forEach((output, index) => {
+            if (output.opReturn !== undefined) {
+                // OP_RETURN output
+                const data = new TextEncoder().encode(output.opReturn);
+                const script = (0, index_js_1.createOpReturnScript)(data);
+                psbt.addOutput(script, output.value);
+            }
+            else if (output.address !== undefined) {
+                // Address-based output
+                psbt.addOutput(output.address, output.value);
+            }
+            else if (output.script !== undefined) {
+                // Raw script output
+                psbt.addOutput(output.script, output.value);
+            }
+            else {
+                // Wallet output: resolve scriptId from scriptType or explicit scriptId
+                const scriptId = output.scriptId ?? {
+                    chain: output.scriptType ? index_js_1.ChainCode.value(output.scriptType, "external") : 0,
+                    index: output.index ?? index,
+                };
+                if (output.walletKeys === null) {
+                    // External output (no wallet keys, no bip32 derivation)
+                    // Use high index for external outputs if not specified
+                    const externalScriptId = output.scriptId ?? {
+                        chain: scriptId.chain,
+                        index: output.index ?? 1000 + index,
+                    };
+                    const script = (0, index_js_1.outputScript)(this.rootWalletKeys, externalScriptId.chain, externalScriptId.index, this.network);
+                    psbt.addOutput(script, output.value);
+                }
+                else {
+                    // Wallet output (with or without different wallet keys)
+                    const walletKeys = output.walletKeys ?? this.rootWalletKeys;
+                    psbt.addWalletOutput(walletKeys, {
+                        chain: scriptId.chain,
+                        index: scriptId.index,
+                        value: output.value,
+                    });
+                }
+            }
+        });
+        // Apply signing based on stage
+        if (this.signStage !== "unsigned") {
+            this.signPsbt(psbt);
+        }
+        return psbt;
+    }
+    /**
+     * Sign the PSBT according to the sign stage
+     */
+    signPsbt(psbt) {
+        // Use private keys stored in constructor
+        const userKey = this.userXprv;
+        const backupKey = this.backupXprv;
+        const bitgoKey = this.bitgoXprv;
+        // 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) {
+                throw new Error("Zcash does not support MuSig2/Taproot inputs");
+            }
+            // Generate nonces with user 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);
+                }
+            }
+        }
+        // Sign all wallet inputs with user key (bulk - more efficient)
+        psbt.sign(userKey);
+        // Sign replay protection inputs with raw private key
+        const hasReplayProtection = this.inputs.some((input) => input.scriptType === "p2shP2pk");
+        if (hasReplayProtection) {
+            if (!userKey.privateKey) {
+                throw new Error("User key must have private key for signing replay protection inputs");
+            }
+            psbt.sign(userKey.privateKey);
+        }
+        // For fullsigned, sign with cosigner
+        if (this.signStage === "fullsigned") {
+            const hasScriptPath = this.inputs.some((input) => input.scriptType === "p2trMusig2ScriptPath");
+            if (hasScriptPath) {
+                // Mixed case: script path uses backup, others use bitgo
+                // Need per-input signing (slow) to handle different cosigners
+                this.inputs.forEach((input, index) => {
+                    if (input.scriptType === "p2shP2pk") {
+                        // Replay protection is single-sig, already fully signed
+                        return;
+                    }
+                    if (input.scriptType === "p2trMusig2ScriptPath") {
+                        psbt.signInput(index, backupKey);
+                    }
+                    else {
+                        psbt.signInput(index, bitgoKey);
+                    }
+                });
+            }
+            else {
+                // No script path - can use bulk signing with bitgo (fast)
+                psbt.sign(bitgoKey);
+            }
+        }
+    }
+    /**
+     * Generate test suite for all networks, sign stages, and tx formats
+     */
+    static forAllNetworksSignStagesTxFormats(suiteConfig = {}) {
+        return coinName_js_1.coinNames
+            .filter((network) => (0, coinName_js_1.isMainnet)(network) && network !== "bsv") // Exclude bitcoinsv
+            .flatMap((network) => exports.signStages.flatMap((signStage) => exports.txFormats.map((txFormat) => AcidTest.withConfig(network, signStage, txFormat, suiteConfig))));
+    }
+}
+exports.AcidTest = AcidTest;

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

@@ -0,0 +1,2 @@
+export * from "./keys.js";
+export * from "./AcidTest.js";

package/dist/cjs/js/testutils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./keys.js"), exports);
+__exportStar(require("./AcidTest.js"), exports);