@bitgo/wasm-utxo 1.28.0 → 1.29.0

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

@@ -0,0 +1,76 @@
+import { BIP32 } from "../bip32.js";
+import { RootWalletKeys } from "../fixedScriptWallet/RootWalletKeys.js";
+import type { Triple } from "../triple.js";
+/**
+ * Generate a deterministic BIP32 key from a seed string.
+ * Uses SHA256 hash of the seed to create the key, matching utxo-lib's implementation.
+ *
+ * @param seed - Seed string for deterministic key generation
+ * @returns BIP32 key derived from the seed
+ *
+ * @example
+ * ```typescript
+ * const key = getKey("user");
+ * const xpub = key.neutered().toBase58();
+ * ```
+ */
+export declare function getKey(seed: string): BIP32;
+/**
+ * Generate a triple of BIP32 keys for a 2-of-3 multisig wallet.
+ * Keys are generated deterministically from the seed string with suffixes .0, .1, .2
+ * for user, backup, and bitgo keys respectively.
+ *
+ * @param seed - Base seed string for key generation
+ * @returns Triple of BIP32 keys [user, backup, bitgo]
+ *
+ * @example
+ * ```typescript
+ * const keys = getKeyTriple("default");
+ * const [user, backup, bitgo] = keys;
+ * ```
+ */
+export declare function getKeyTriple(seed: string): Triple<BIP32>;
+/**
+ * Create RootWalletKeys from a seed string.
+ * Uses standard derivation prefixes ["m/0/0", "m/0/0", "m/0/0"].
+ *
+ * @param seed - Seed string for key generation
+ * @returns RootWalletKeys instance
+ *
+ * @example
+ * ```typescript
+ * const walletKeys = getWalletKeysForSeed("default");
+ * ```
+ */
+export declare function getWalletKeysForSeed(seed: string): RootWalletKeys;
+/**
+ * Get the default wallet keys for testing.
+ * Equivalent to getWalletKeysForSeed("default").
+ *
+ * @returns RootWalletKeys instance with default seed
+ *
+ * @example
+ * ```typescript
+ * const walletKeys = getDefaultWalletKeys();
+ * ```
+ */
+export declare function getDefaultWalletKeys(): RootWalletKeys;
+/**
+ * Get the key name (user, backup, or bitgo) for a given key in a triple.
+ *
+ * @param triple - Triple of BIP32 keys
+ * @param key - Key to find in the triple
+ * @returns "user", "backup", "bitgo", or undefined if not found
+ */
+export declare function getKeyName(triple: Triple<BIP32>, key: BIP32): "user" | "backup" | "bitgo" | undefined;
+/**
+ * Get the default cosigner for a given signer key.
+ * - If signer is user, returns bitgo
+ * - If signer is backup, returns bitgo
+ * - If signer is bitgo, returns user
+ *
+ * @param keyset - Triple of keys [user, backup, bitgo]
+ * @param signer - The signing key
+ * @returns The default cosigner key
+ */
+export declare function getDefaultCosigner<T>(keyset: Triple<T>, signer: T): T;

package/dist/cjs/js/testutils/keys.js

@@ -0,0 +1,154 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKey = getKey;
+exports.getKeyTriple = getKeyTriple;
+exports.getWalletKeysForSeed = getWalletKeysForSeed;
+exports.getDefaultWalletKeys = getDefaultWalletKeys;
+exports.getKeyName = getKeyName;
+exports.getDefaultCosigner = getDefaultCosigner;
+const crypto = __importStar(require("crypto"));
+const bip32_js_1 = require("../bip32.js");
+const RootWalletKeys_js_1 = require("../fixedScriptWallet/RootWalletKeys.js");
+/**
+ * Generate a deterministic BIP32 key from a seed string.
+ * Uses SHA256 hash of the seed to create the key, matching utxo-lib's implementation.
+ *
+ * @param seed - Seed string for deterministic key generation
+ * @returns BIP32 key derived from the seed
+ *
+ * @example
+ * ```typescript
+ * const key = getKey("user");
+ * const xpub = key.neutered().toBase58();
+ * ```
+ */
+function getKey(seed) {
+    return bip32_js_1.BIP32.fromSeed(crypto.createHash("sha256").update(seed).digest());
+}
+/**
+ * Generate a triple of BIP32 keys for a 2-of-3 multisig wallet.
+ * Keys are generated deterministically from the seed string with suffixes .0, .1, .2
+ * for user, backup, and bitgo keys respectively.
+ *
+ * @param seed - Base seed string for key generation
+ * @returns Triple of BIP32 keys [user, backup, bitgo]
+ *
+ * @example
+ * ```typescript
+ * const keys = getKeyTriple("default");
+ * const [user, backup, bitgo] = keys;
+ * ```
+ */
+function getKeyTriple(seed) {
+    return [getKey(seed + ".0"), getKey(seed + ".1"), getKey(seed + ".2")];
+}
+/**
+ * Create RootWalletKeys from a seed string.
+ * Uses standard derivation prefixes ["m/0/0", "m/0/0", "m/0/0"].
+ *
+ * @param seed - Seed string for key generation
+ * @returns RootWalletKeys instance
+ *
+ * @example
+ * ```typescript
+ * const walletKeys = getWalletKeysForSeed("default");
+ * ```
+ */
+function getWalletKeysForSeed(seed) {
+    const triple = getKeyTriple(seed);
+    return RootWalletKeys_js_1.RootWalletKeys.from({
+        triple,
+        derivationPrefixes: ["m/0/0", "m/0/0", "m/0/0"],
+    });
+}
+/**
+ * Get the default wallet keys for testing.
+ * Equivalent to getWalletKeysForSeed("default").
+ *
+ * @returns RootWalletKeys instance with default seed
+ *
+ * @example
+ * ```typescript
+ * const walletKeys = getDefaultWalletKeys();
+ * ```
+ */
+function getDefaultWalletKeys() {
+    return getWalletKeysForSeed("default");
+}
+/**
+ * Get the key name (user, backup, or bitgo) for a given key in a triple.
+ *
+ * @param triple - Triple of BIP32 keys
+ * @param key - Key to find in the triple
+ * @returns "user", "backup", "bitgo", or undefined if not found
+ */
+function getKeyName(triple, key) {
+    const index = triple.findIndex((k) => {
+        const kb58 = k.toBase58();
+        const keyb58 = key.toBase58();
+        return kb58 === keyb58;
+    });
+    if (index === 0)
+        return "user";
+    if (index === 1)
+        return "backup";
+    if (index === 2)
+        return "bitgo";
+    return undefined;
+}
+/**
+ * Get the default cosigner for a given signer key.
+ * - If signer is user, returns bitgo
+ * - If signer is backup, returns bitgo
+ * - If signer is bitgo, returns user
+ *
+ * @param keyset - Triple of keys [user, backup, bitgo]
+ * @param signer - The signing key
+ * @returns The default cosigner key
+ */
+function getDefaultCosigner(keyset, signer) {
+    const [user, backup, bitgo] = keyset;
+    if (signer === user) {
+        return bitgo;
+    }
+    if (signer === backup) {
+        return bitgo;
+    }
+    if (signer === bitgo) {
+        return user;
+    }
+    throw new Error("signer not in keyset");
+}

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

@@ -677,6 +677,16 @@ export class FixedScriptWalletNamespace {
    * - Dogecoin only supports legacy scripts (p2sh)
    */
   static supports_script_type(coin: string, script_type: string): boolean;
+  /**
+   * Create an OP_RETURN output script with optional data
+   *
+   * # Arguments
+   * * `data` - Optional data bytes to include in the OP_RETURN script
+   *
+   * # Returns
+   * The OP_RETURN script as bytes
+   */
+  static create_op_return_script(data?: Uint8Array | null): Uint8Array;
   static address_with_network_str(keys: WasmRootWalletKeys, chain: number, index: number, network: string, address_format?: string | null): string;
   static output_script_with_network_str(keys: WasmRootWalletKeys, chain: number, index: number, network: string): Uint8Array;
   static address(keys: WasmRootWalletKeys, chain: number, index: number, network: any, address_format?: string | null): string;

package/dist/cjs/js/wasm/wasm_utxo.js

@@ -1896,6 +1896,37 @@ class FixedScriptWalletNamespace {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Create an OP_RETURN output script with optional data
+     *
+     * # Arguments
+     * * `data` - Optional data bytes to include in the OP_RETURN script
+     *
+     * # Returns
+     * The OP_RETURN script as bytes
+     * @param {Uint8Array | null} [data]
+     * @returns {Uint8Array}
+     */
+    static create_op_return_script(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(data) ? 0 : passArray8ToWasm0(data, wasm.__wbindgen_export);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.fixedscriptwalletnamespace_create_op_return_script(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {WasmRootWalletKeys} keys
      * @param {number} chain

package/dist/cjs/js/wasm/wasm_utxo_bg.wasm.d.ts

@@ -100,6 +100,7 @@ export const bitgopsbt_version_group_id: (a: number) => number;
 export const fixedscriptwalletnamespace_address: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const fixedscriptwalletnamespace_address_with_network_str: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
 export const fixedscriptwalletnamespace_chain_code_table: () => number;
+export const fixedscriptwalletnamespace_create_op_return_script: (a: number, b: number, c: number) => void;
 export const fixedscriptwalletnamespace_output_script: (a: number, b: number, c: number, d: number, e: number) => void;
 export const fixedscriptwalletnamespace_output_script_with_network_str: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const fixedscriptwalletnamespace_supports_script_type: (a: number, b: number, c: number, d: number, e: number) => void;
@@ -154,8 +155,8 @@ export const wasmrootwalletkeys_new: (a: number, b: number, c: number, d: number
 export const wasmrootwalletkeys_user_key: (a: number) => number;
 export const wasmrootwalletkeys_with_derivation_prefixes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
 export const wasmbip32_from_bip32_properties: (a: number, b: number) => void;
-export const bitgopsbt_sign_all_with_xpriv: (a: number, b: number, c: number) => void;
 export const bitgopsbt_sign_replay_protection_inputs: (a: number, b: number, c: number) => void;
+export const bitgopsbt_sign_all_with_xpriv: (a: number, b: number, c: number) => void;
 export const bitgopsbt_sign_wallet_input: (a: number, b: number, c: number, d: number) => void;
 export const __wbg_wasmdashtransaction_free: (a: number, b: number) => void;
 export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;

package/dist/esm/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/esm/js/fixedScriptWallet/chains.js

@@ -11,10 +11,13 @@ export const chainCodes = [0, 1, 10, 11, 20, 21, 30, 31, 40, 41];
 const chainCodeSet = new Set(chainCodes);
 const chainToMeta = new Map();
 const scriptTypeToChain = new Map();
-// Initialize from WASM (called once at load time)
-function assertChainCode(n) {
+/**
+ * Assert that a number is a valid chain code.
+ * @throws Error if the number is not a valid chain code
+ */
+export 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/esm/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/esm/js/fixedScriptWallet/index.js

@@ -3,7 +3,8 @@ export { RootWalletKeys } from "./RootWalletKeys.js";
 export { ReplayProtection } from "./ReplayProtection.js";
 export { outputScript, address } from "./address.js";
 export { Dimensions } from "./Dimensions.js";
-export { ChainCode, chainCodes } from "./chains.js";
+export { outputScriptTypes, inputScriptTypes, } from "./scriptType.js";
+export { ChainCode, chainCodes, assertChainCode } from "./chains.js";
 // Bitcoin-like PSBT (for all non-Zcash networks)
 export { BitGoPsbt, } from "./BitGoPsbt.js";
 // Zcash-specific PSBT subclass
@@ -36,3 +37,22 @@ export { ZcashBitGoPsbt, } from "./ZcashBitGoPsbt.js";
 export function supportsScriptType(coin, scriptType) {
     return 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);
+ * ```
+ */
+export function createOpReturnScript(data) {
+    return FixedScriptWalletNamespace.create_op_return_script(data);
+}

package/dist/esm/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/esm/js/fixedScriptWallet/scriptType.js

@@ -1 +1,27 @@
-export {};
+/**
+ * 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.
+ */
+export const 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.
+ */
+export const inputScriptTypes = [
+    "p2shP2pk",
+    "p2sh",
+    "p2shP2wsh",
+    "p2wsh",
+    "p2trLegacy",
+    "p2trMusig2ScriptPath",
+    "p2trMusig2KeyPath",
+];

package/dist/esm/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[];
+}