@bitgo/wasm-utxo 1.27.0 → 1.29.0

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

@@ -138,3 +138,10 @@ export declare class BIP32 implements BIP32Interface {
      */
     get wasm(): WasmBIP32;
 }
+/**
+ * Type guard to check if a value is a BIP32Arg
+ *
+ * @param key - The value to check
+ * @returns true if the value is a BIP32Arg (string, BIP32, WasmBIP32, or BIP32Interface)
+ */
+export declare function isBIP32Arg(key: unknown): key is BIP32Arg;

package/dist/cjs/js/bip32.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BIP32 = void 0;
+exports.isBIP32Arg = isBIP32Arg;
 const wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
 /**
  * BIP32 wrapper class for extended key operations
@@ -175,3 +176,18 @@ class BIP32 {
     }
 }
 exports.BIP32 = BIP32;
+/**
+ * Type guard to check if a value is a BIP32Arg
+ *
+ * @param key - The value to check
+ * @returns true if the value is a BIP32Arg (string, BIP32, WasmBIP32, or BIP32Interface)
+ */
+function isBIP32Arg(key) {
+    return (typeof key === "string" ||
+        key instanceof BIP32 ||
+        key instanceof wasm_utxo_js_1.WasmBIP32 ||
+        (typeof key === "object" &&
+            key !== null &&
+            "derive" in key &&
+            typeof key.derive === "function"));
+}

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

@@ -371,16 +371,63 @@ export declare class BitGoPsbt {
      */
     verifySignature(inputIndex: number, key: BIP32Arg | ECPairArg): boolean;
     /**
-     * Sign a single input with a private key
+     * Sign all matching inputs with a private key.
+     *
+     * This method signs all inputs that match the provided key in a single efficient pass.
+     * It accepts either:
+     * - An xpriv (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32) for wallet inputs
+     * - A raw privkey (ECPairArg: Buffer, ECPair instance, or WasmECPair) for replay protection inputs
+     *
+     * **Note:** MuSig2 inputs are skipped by this method when using xpriv because they require
+     * FirstRound state. After calling this method, sign MuSig2 inputs individually using
+     * `signInput()` after calling `generateMusig2Nonces()`.
+     *
+     * @param key - Either an xpriv (BIP32Arg) or a raw privkey (ECPairArg)
+     * @returns Array of input indices that were signed
+     * @throws Error if signing fails
+     *
+     * @example
+     * ```typescript
+     * // Sign all wallet inputs with user's xpriv
+     * const signedIndices = psbt.sign(userXpriv);
+     * console.log(`Signed inputs: ${signedIndices.join(", ")}`);
+     *
+     * // Sign all replay protection inputs with raw privkey
+     * const rpSignedIndices = psbt.sign(replayProtectionPrivkey);
+     * ```
+     */
+    sign(key: BIP32Arg | ECPairArg): number[];
+    /**
+     * Sign a single input with a private key.
+     *
+     * @deprecated Use `sign(key)` to sign all matching inputs (more efficient), or use
+     * `signInput(inputIndex, key)` for explicit single-input signing.
+     *
+     * **Note:** This method is NOT more efficient than `sign(key)` for non-MuSig2 inputs.
+     * The underlying miniscript library signs all inputs regardless. This overload exists
+     * for backward compatibility only.
+     *
+     * @param inputIndex - The index of the input to sign (0-based)
+     * @param key - Either an xpriv (BIP32Arg) or a raw privkey (ECPairArg)
+     * @throws Error if signing fails, or if generateMusig2Nonces() was not called first for MuSig2 inputs
+     */
+    sign(inputIndex: number, key: BIP32Arg | ECPairArg): void;
+    /**
+     * Sign a single input with a private key.
      *
      * This method signs a specific input using the provided key. It accepts either:
-     * - An xpriv (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32) for wallet inputs - derives the key and signs
-     * - A raw privkey (ECPairArg: Buffer, ECPair instance, or WasmECPair) for replay protection inputs - signs directly
+     * - An xpriv (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32) for wallet inputs
+     * - A raw privkey (ECPairArg: Buffer, ECPair instance, or WasmECPair) for replay protection inputs
      *
-     * This method automatically detects and handles different input types:
-     * - For regular inputs: uses standard PSBT signing
-     * - For MuSig2 inputs: uses the FirstRound state stored by generateMusig2Nonces()
-     * - For replay protection inputs: signs with legacy P2SH sighash
+     * **Important:** This method is NOT faster than `sign(key)` for non-MuSig2 inputs.
+     * The underlying miniscript library signs all inputs regardless. This method uses a
+     * save/restore pattern to ensure only the target input receives the signature.
+     *
+     * Use this method only when you need precise control over which inputs are signed,
+     * for example:
+     * - Signing MuSig2 inputs (after calling generateMusig2Nonces())
+     * - Mixed transactions where different inputs need different keys
+     * - Testing or debugging signing behavior
      *
      * @param inputIndex - The index of the input to sign (0-based)
      * @param key - Either an xpriv (BIP32Arg) or a raw privkey (ECPairArg)
@@ -388,28 +435,15 @@ export declare class BitGoPsbt {
      *
      * @example
      * ```typescript
-     * // Parse transaction to identify input types
-     * const parsed = psbt.parseTransactionWithWalletKeys(walletKeys, replayProtection);
-     *
-     * // Sign regular wallet inputs with xpriv
-     * for (let i = 0; i < parsed.inputs.length; i++) {
-     *   const input = parsed.inputs[i];
-     *   if (input.scriptId !== null && input.scriptType !== "p2shP2pk") {
-     *     psbt.sign(i, userXpriv);
-     *   }
-     * }
+     * // Sign a specific MuSig2 input after nonce generation
+     * psbt.generateMusig2Nonces(userXpriv);
+     * psbt.signInput(musig2InputIndex, userXpriv);
      *
-     * // Sign replay protection inputs with raw privkey
-     * const userPrivkey = bip32.fromBase58(userXpriv).privateKey!;
-     * for (let i = 0; i < parsed.inputs.length; i++) {
-     *   const input = parsed.inputs[i];
-     *   if (input.scriptType === "p2shP2pk") {
-     *     psbt.sign(i, userPrivkey);
-     *   }
-     * }
+     * // Sign a specific replay protection input
+     * psbt.signInput(rpInputIndex, replayProtectionPrivkey);
      * ```
      */
-    sign(inputIndex: number, key: BIP32Arg | ECPairArg): void;
+    signInput(inputIndex: number, key: BIP32Arg | ECPairArg): void;
     /**
      * @deprecated - use verifySignature with the replay protection key instead
      *

package/dist/cjs/js/fixedScriptWallet/BitGoPsbt.js

@@ -306,17 +306,49 @@ class BitGoPsbt {
         const wasmECPair = ecpair_js_1.ECPair.from(key).wasm;
         return this._wasm.verify_signature_with_pub(inputIndex, wasmECPair);
     }
+    sign(inputIndexOrKey, key) {
+        // Detect which overload was called
+        if (typeof inputIndexOrKey === "number") {
+            // Called as sign(inputIndex, key) - deprecated single-input signing
+            if (key === undefined) {
+                throw new Error("Key is required when signing a single input");
+            }
+            this.signInput(inputIndexOrKey, key);
+            return;
+        }
+        // Called as sign(key) - sign all matching inputs
+        const keyArg = inputIndexOrKey;
+        if ((0, bip32_js_1.isBIP32Arg)(keyArg)) {
+            // It's a BIP32Arg - sign all wallet inputs (ECDSA + MuSig2)
+            const wasmKey = bip32_js_1.BIP32.from(keyArg);
+            // Sign all non-MuSig2 wallet inputs
+            const walletSigned = this._wasm.sign_all_wallet_inputs(wasmKey.wasm);
+            // Sign all MuSig2 keypath inputs (more efficient - reuses SighashCache)
+            const musig2Signed = this._wasm.sign_all_musig2_inputs(wasmKey.wasm);
+            return [...walletSigned, ...musig2Signed];
+        }
+        else {
+            // It's an ECPairArg - sign all replay protection inputs
+            const wasmKey = ecpair_js_1.ECPair.from(keyArg);
+            return this._wasm.sign_replay_protection_inputs(wasmKey.wasm);
+        }
+    }
     /**
-     * Sign a single input with a private key
+     * Sign a single input with a private key.
      *
      * This method signs a specific input using the provided key. It accepts either:
-     * - An xpriv (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32) for wallet inputs - derives the key and signs
-     * - A raw privkey (ECPairArg: Buffer, ECPair instance, or WasmECPair) for replay protection inputs - signs directly
+     * - An xpriv (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32) for wallet inputs
+     * - A raw privkey (ECPairArg: Buffer, ECPair instance, or WasmECPair) for replay protection inputs
+     *
+     * **Important:** This method is NOT faster than `sign(key)` for non-MuSig2 inputs.
+     * The underlying miniscript library signs all inputs regardless. This method uses a
+     * save/restore pattern to ensure only the target input receives the signature.
      *
-     * This method automatically detects and handles different input types:
-     * - For regular inputs: uses standard PSBT signing
-     * - For MuSig2 inputs: uses the FirstRound state stored by generateMusig2Nonces()
-     * - For replay protection inputs: signs with legacy P2SH sighash
+     * Use this method only when you need precise control over which inputs are signed,
+     * for example:
+     * - Signing MuSig2 inputs (after calling generateMusig2Nonces())
+     * - Mixed transactions where different inputs need different keys
+     * - Testing or debugging signing behavior
      *
      * @param inputIndex - The index of the input to sign (0-based)
      * @param key - Either an xpriv (BIP32Arg) or a raw privkey (ECPairArg)
@@ -324,42 +356,30 @@ class BitGoPsbt {
      *
      * @example
      * ```typescript
-     * // Parse transaction to identify input types
-     * const parsed = psbt.parseTransactionWithWalletKeys(walletKeys, replayProtection);
-     *
-     * // Sign regular wallet inputs with xpriv
-     * for (let i = 0; i < parsed.inputs.length; i++) {
-     *   const input = parsed.inputs[i];
-     *   if (input.scriptId !== null && input.scriptType !== "p2shP2pk") {
-     *     psbt.sign(i, userXpriv);
-     *   }
-     * }
+     * // Sign a specific MuSig2 input after nonce generation
+     * psbt.generateMusig2Nonces(userXpriv);
+     * psbt.signInput(musig2InputIndex, userXpriv);
      *
-     * // Sign replay protection inputs with raw privkey
-     * const userPrivkey = bip32.fromBase58(userXpriv).privateKey!;
-     * for (let i = 0; i < parsed.inputs.length; i++) {
-     *   const input = parsed.inputs[i];
-     *   if (input.scriptType === "p2shP2pk") {
-     *     psbt.sign(i, userPrivkey);
-     *   }
-     * }
+     * // Sign a specific replay protection input
+     * psbt.signInput(rpInputIndex, replayProtectionPrivkey);
      * ```
      */
-    sign(inputIndex, key) {
-        // Detect key type
-        // If string or has 'derive' method → BIP32Arg
-        // Otherwise → ECPairArg
-        if (typeof key === "string" ||
-            (typeof key === "object" &&
-                key !== null &&
-                "derive" in key &&
-                typeof key.derive === "function")) {
+    signInput(inputIndex, key) {
+        if ((0, bip32_js_1.isBIP32Arg)(key)) {
             // It's a BIP32Arg
             const wasmKey = bip32_js_1.BIP32.from(key);
-            this._wasm.sign_with_xpriv(inputIndex, wasmKey.wasm);
+            // Route to the appropriate method based on input type
+            if (this._wasm.is_musig2_input(inputIndex)) {
+                // MuSig2 keypath: true single-input signing (efficient)
+                this._wasm.sign_musig2_input(inputIndex, wasmKey.wasm);
+            }
+            else {
+                // ECDSA/Schnorr script path: save/restore pattern (not faster than bulk)
+                this._wasm.sign_wallet_input(inputIndex, wasmKey.wasm);
+            }
         }
         else {
-            // It's an ECPairArg
+            // It's an ECPairArg - for replay protection inputs
             const wasmKey = ecpair_js_1.ECPair.from(key);
             this._wasm.sign_with_privkey(inputIndex, wasmKey.wasm);
         }

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[];
+}