@bitgo/wasm-utxo 1.7.0 → 1.8.0

package/dist/esm/js/wasm/wasm_utxo_bg.js

@@ -64,6 +64,18 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
@@ -131,16 +143,21 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
 }
 
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
 }
 
 function _assertClass(instance, klass) {
@@ -149,13 +166,6 @@ function _assertClass(instance, klass) {
     }
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 let stack_pointer = 128;
 
 function addBorrowedObject(obj) {
@@ -164,16 +174,6 @@ function addBorrowedObject(obj) {
     return stack_pointer;
 }
 
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    const mem = getDataViewMemory0();
-    for (let i = 0; i < array.length; i++) {
-        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-
 const AddressNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_addressnamespace_free(ptr >>> 0, 1));
@@ -327,6 +327,76 @@ export class BitGoPsbt {
             wasm.__wbindgen_export_3(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Sign a single input with an extended private key (xpriv)
+     *
+     * This method signs a specific input using the provided xpriv. It accepts:
+     * - An xpriv (WasmBIP32) for wallet inputs - derives the key and signs
+     *
+     * 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 generate_musig2_nonces()
+     * - For replay protection inputs: returns error (use sign_with_privkey instead)
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `xpriv`: The extended private key as a WasmBIP32 instance
+     *
+     * # Returns
+     * - `Ok(())` if signing was successful
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {number} input_index
+     * @param {WasmBIP32} xpriv
+     */
+    sign_with_xpriv(input_index, xpriv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_with_xpriv(retptr, this.__wbg_ptr, input_index, xpriv.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign a single input with a raw private key
+     *
+     * This method signs a specific input using the provided ECPair. It accepts:
+     * - A raw privkey (WasmECPair) for replay protection inputs - signs directly
+     *
+     * This method automatically detects and handles different input types:
+     * - For replay protection inputs: signs with legacy P2SH sighash
+     * - For regular inputs: uses standard PSBT signing
+     * - For MuSig2 inputs: returns error (requires FirstRound, use sign_with_xpriv instead)
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `ecpair`: The ECPair containing the private key
+     *
+     * # Returns
+     * - `Ok(())` if signing was successful
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {number} input_index
+     * @param {WasmECPair} ecpair
+     */
+    sign_with_privkey(input_index, ecpair) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            wasm.bitgopsbt_sign_with_privkey(retptr, this.__wbg_ptr, input_index, ecpair.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Extract the final transaction from a finalized PSBT
      *
@@ -379,6 +449,83 @@ export class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Combine/merge data from another PSBT into this one
+     *
+     * This method copies MuSig2 nonces and signatures (proprietary key-value pairs) from the
+     * source PSBT to this PSBT. This is useful for merging PSBTs during the nonce exchange
+     * and signature collection phases.
+     *
+     * # Arguments
+     * * `source_psbt` - The source PSBT containing data to merge
+     *
+     * # Returns
+     * Ok(()) if data was successfully merged
+     *
+     * # Errors
+     * Returns error if networks don't match
+     * @param {BitGoPsbt} source_psbt
+     */
+    combine_musig2_nonces(source_psbt) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(source_psbt, BitGoPsbt);
+            wasm.bitgopsbt_combine_musig2_nonces(retptr, this.__wbg_ptr, source_psbt.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Generate and store MuSig2 nonces for all MuSig2 inputs
+     *
+     * This method generates nonces using the State-Machine API and stores them in the PSBT.
+     * The nonces are stored as proprietary fields in the PSBT and will be included when serialized.
+     * After ALL participants have generated their nonces, they can sign MuSig2 inputs using
+     * sign_with_xpriv().
+     *
+     * # Arguments
+     * * `xpriv` - The extended private key (xpriv) for signing
+     * * `session_id_bytes` - Optional 32-byte session ID for nonce generation. **Only allowed on testnets**.
+     *                        On mainnets, a secure random session ID is always generated automatically.
+     *                        Must be unique per signing session.
+     *
+     * # Returns
+     * Ok(()) if nonces were successfully generated and stored
+     *
+     * # Errors
+     * Returns error if:
+     * - Nonce generation fails
+     * - session_id length is invalid
+     * - Custom session_id is provided on a mainnet (security restriction)
+     *
+     * # Security
+     * The session_id MUST be cryptographically random and unique for each signing session.
+     * Never reuse a session_id with the same key! On mainnets, session_id is always randomly
+     * generated for security. Custom session_id is only allowed on testnets for testing purposes.
+     * @param {WasmBIP32} xpriv
+     * @param {Uint8Array | null} [session_id_bytes]
+     */
+    generate_musig2_nonces(xpriv, session_id_bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            var ptr0 = isLikeNone(session_id_bytes) ? 0 : passArray8ToWasm0(session_id_bytes, wasm.__wbindgen_export_1);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_generate_musig2_nonces(retptr, this.__wbg_ptr, xpriv.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Verify if a valid signature exists for a given ECPair key at the specified input index
      *
@@ -2184,6 +2331,25 @@ export function __wbg_Error_e17e777aac105295(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+export function __wbg_call_13410aac570ffff7() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_call_a5400b25a865cfd8() { return handleError(function (arg0, arg1, arg2) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_crypto_574e78ad8b13b65f(arg0) {
+    const ret = getObject(arg0).crypto;
+    return addHeapObject(ret);
+};
+
+export function __wbg_getRandomValues_b8f5dbd5f3995a9e() { return handleError(function (arg0, arg1) {
+    getObject(arg0).getRandomValues(getObject(arg1));
+}, arguments) };
+
 export function __wbg_get_458e874b43b18b25() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(getObject(arg0), getObject(arg1));
     return addHeapObject(ret);
@@ -2194,6 +2360,11 @@ export function __wbg_length_6bb7e81f9d7713e4(arg0) {
     return ret;
 };
 
+export function __wbg_msCrypto_a61aeb35a24c1329(arg0) {
+    const ret = getObject(arg0).msCrypto;
+    return addHeapObject(ret);
+};
+
 export function __wbg_new_19c25a3f2fa63a02() {
     const ret = new Object();
     return addHeapObject(ret);
@@ -2219,6 +2390,26 @@ export function __wbg_newfromslice_074c56947bd43469(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+export function __wbg_newnoargs_254190557c45b4ec(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_newwithlength_a167dcc7aaa3ba77(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_node_905d3e251edff8a2(arg0) {
+    const ret = getObject(arg0).node;
+    return addHeapObject(ret);
+};
+
+export function __wbg_process_dc0fbacc7c1c06f7(arg0) {
+    const ret = getObject(arg0).process;
+    return addHeapObject(ret);
+};
+
 export function __wbg_prototypesetcall_3d4a26c1ed734349(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 };
@@ -2228,16 +2419,71 @@ export function __wbg_push_330b2eb93e4e1212(arg0, arg1) {
     return ret;
 };
 
+export function __wbg_randomFillSync_ac0988aba3254290() { return handleError(function (arg0, arg1) {
+    getObject(arg0).randomFillSync(takeObject(arg1));
+}, arguments) };
+
+export function __wbg_require_60cc747a6bc5215a() { return handleError(function () {
+    const ret = module.require;
+    return addHeapObject(ret);
+}, arguments) };
+
 export function __wbg_set_453345bcda80b89a() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
     return ret;
 }, arguments) };
 
+export function __wbg_static_accessor_GLOBAL_8921f820c2ce3f12() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_GLOBAL_THIS_f0a4409105898184() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_SELF_995b214ae681ff99() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_WINDOW_cde3890479c675ea() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_subarray_70fd07feefe14294(arg0, arg1, arg2) {
+    const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_versions_c01dfd4722a88165(arg0) {
+    const ret = getObject(arg0).versions;
+    return addHeapObject(ret);
+};
+
+export function __wbg_wbindgenisfunction_8cee7dce3725ae74(arg0) {
+    const ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+};
+
 export function __wbg_wbindgenisnull_f3037694abe4d97a(arg0) {
     const ret = getObject(arg0) === null;
     return ret;
 };
 
+export function __wbg_wbindgenisobject_307a53c6bd97fbf8(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+export function __wbg_wbindgenisstring_d4fa939789f003b0(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+};
+
 export function __wbg_wbindgenisundefined_c4b71d073b92f3c5(arg0) {
     const ret = getObject(arg0) === undefined;
     return ret;
@@ -2275,6 +2521,12 @@ export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
     return addHeapObject(ret);
 };
 
+export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
 export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;

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

@@ -2,11 +2,25 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
+export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;
+export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
+export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const utxolibcompatnamespace_to_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const wasmreplayprotection_from_addresses: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmreplayprotection_from_output_scripts: (a: number, b: number) => number;
+export const wasmreplayprotection_from_public_keys: (a: number, b: number, c: number) => void;
+export const wrapminiscript_encode: (a: number, b: number) => void;
+export const wrapminiscript_fromBitcoinScript: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrapminiscript_fromString: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrapminiscript_node: (a: number, b: number) => void;
+export const wrapminiscript_toAsmString: (a: number, b: number) => void;
+export const wrapminiscript_toString: (a: number, b: number) => void;
+export const __wbg_addressnamespace_free: (a: number, b: number) => void;
 export const __wbg_wasmbip32_free: (a: number, b: number) => void;
 export const __wbg_wasmecpair_free: (a: number, b: number) => void;
 export const __wbg_wasmrootwalletkeys_free: (a: number, b: number) => void;
-export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const utxolibcompatnamespace_to_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const addressnamespace_from_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const addressnamespace_to_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wasmbip32_chain_code: (a: number) => number;
 export const wasmbip32_depth: (a: number) => number;
 export const wasmbip32_derive: (a: number, b: number, c: number) => void;
@@ -43,20 +57,21 @@ 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 __wbg_addressnamespace_free: (a: number, b: number) => void;
 export const __wbg_bitgopsbt_free: (a: number, b: number) => void;
+export const __wbg_fixedscriptwalletnamespace_free: (a: number, b: number) => void;
 export const __wbg_wrapdescriptor_free: (a: number, b: number) => void;
-export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
 export const __wbg_wrappsbt_free: (a: number, b: number) => void;
-export const addressnamespace_from_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-export const addressnamespace_to_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number) => void;
+export const bitgopsbt_combine_musig2_nonces: (a: number, b: number, c: number) => void;
 export const bitgopsbt_extract_transaction: (a: number, b: number) => void;
 export const bitgopsbt_finalize_all_inputs: (a: number, b: number) => void;
 export const bitgopsbt_from_bytes: (a: number, b: number, c: number, d: number, e: number) => void;
+export const bitgopsbt_generate_musig2_nonces: (a: number, b: number, c: number, d: number, e: number) => void;
 export const bitgopsbt_network: (a: number, b: number) => void;
 export const bitgopsbt_parse_outputs_with_wallet_keys: (a: number, b: number, c: number) => void;
 export const bitgopsbt_parse_transaction_with_wallet_keys: (a: number, b: number, c: number, d: number) => void;
 export const bitgopsbt_serialize: (a: number, b: number) => void;
+export const bitgopsbt_sign_with_privkey: (a: number, b: number, c: number, d: number) => void;
+export const bitgopsbt_sign_with_xpriv: (a: number, b: number, c: number, d: number) => void;
 export const bitgopsbt_unsigned_txid: (a: number, b: number) => void;
 export const bitgopsbt_verify_replay_protection_signature: (a: number, b: number, c: number, d: number) => void;
 export const bitgopsbt_verify_signature_with_pub: (a: number, b: number, c: number, d: number) => void;
@@ -74,12 +89,6 @@ export const wrapdescriptor_node: (a: number, b: number) => void;
 export const wrapdescriptor_scriptPubkey: (a: number, b: number) => void;
 export const wrapdescriptor_toAsmString: (a: number, b: number) => void;
 export const wrapdescriptor_toString: (a: number, b: number) => void;
-export const wrapminiscript_encode: (a: number, b: number) => void;
-export const wrapminiscript_fromBitcoinScript: (a: number, b: number, c: number, d: number, e: number) => void;
-export const wrapminiscript_fromString: (a: number, b: number, c: number, d: number, e: number) => void;
-export const wrapminiscript_node: (a: number, b: number) => void;
-export const wrapminiscript_toAsmString: (a: number, b: number) => void;
-export const wrapminiscript_toString: (a: number, b: number) => void;
 export const wrappsbt_clone: (a: number) => number;
 export const wrappsbt_deserialize: (a: number, b: number, c: number) => void;
 export const wrappsbt_finalize: (a: number, b: number) => void;
@@ -88,11 +97,6 @@ export const wrappsbt_signWithPrv: (a: number, b: number, c: number, d: number)
 export const wrappsbt_signWithXprv: (a: number, b: number, c: number, d: number) => void;
 export const wrappsbt_updateInputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
 export const wrappsbt_updateOutputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
-export const __wbg_fixedscriptwalletnamespace_free: (a: number, b: number) => void;
-export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;
-export const wasmreplayprotection_from_addresses: (a: number, b: number, c: number, d: number, e: number) => void;
-export const wasmreplayprotection_from_output_scripts: (a: number, b: number) => number;
-export const wasmreplayprotection_from_public_keys: (a: number, b: number, c: number) => void;
 export const rustsecp256k1_v0_10_0_context_create: (a: number) => number;
 export const rustsecp256k1_v0_10_0_context_destroy: (a: number) => void;
 export const rustsecp256k1_v0_10_0_default_error_callback_fn: (a: number, b: number) => void;

package/dist/esm/test/fixedScript/fixtureUtil.d.ts

@@ -1,5 +1,6 @@
 import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
 import { ECPair } from "../../js/ecpair.js";
+import type { BitGoPsbt, NetworkName } from "../../js/fixedScriptWallet/index.js";
 export type SignatureState = "unsigned" | "halfsigned" | "fullsigned";
 export type Triple<T> = [T, T, T];
 export type Bip32Derivation = {
@@ -80,6 +81,13 @@ export type Fixture = {
  * Get PSBT buffer from a fixture
  */
 export declare function getPsbtBuffer(fixture: Fixture): Buffer;
+/**
+ * Get BitGoPsbt from a fixture
+ * @param fixture - The test fixture
+ * @param networkName - The network name for deserializing the PSBT
+ * @returns A BitGoPsbt instance
+ */
+export declare function getBitGoPsbt(fixture: Fixture, networkName: NetworkName): BitGoPsbt;
 /**
  * Load a PSBT fixture from JSON file
  */

package/dist/esm/test/fixedScript/fixtureUtil.js

@@ -6,6 +6,7 @@ import { dirname } from "node:path";
 import { BIP32 } from "../../js/bip32.js";
 import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
 import { ECPair } from "../../js/ecpair.js";
+import { fixedScriptWallet } from "../../js/index.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -14,6 +15,15 @@ const __dirname = dirname(__filename);
 export function getPsbtBuffer(fixture) {
     return Buffer.from(fixture.psbtBase64, "base64");
 }
+/**
+ * Get BitGoPsbt from a fixture
+ * @param fixture - The test fixture
+ * @param networkName - The network name for deserializing the PSBT
+ * @returns A BitGoPsbt instance
+ */
+export function getBitGoPsbt(fixture, networkName) {
+    return fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(fixture), networkName);
+}
 /**
  * Load a PSBT fixture from JSON file
  */

package/dist/esm/test/fixedScript/musig2Nonces.js

@@ -0,0 +1,77 @@
+import assert from "assert";
+import { BIP32 } from "../../js/bip32.js";
+import { loadPsbtFixture, getBitGoPsbt } from "./fixtureUtil.js";
+describe("MuSig2 nonce management", function () {
+    describe("Bitcoin mainnet", function () {
+        const networkName = "bitcoin";
+        let fixture;
+        let userKey;
+        let backupKey;
+        let bitgoKey;
+        before(function () {
+            fixture = loadPsbtFixture(networkName, "unsigned");
+            userKey = BIP32.fromBase58(fixture.walletKeys[0]);
+            backupKey = BIP32.fromBase58(fixture.walletKeys[1]);
+            bitgoKey = BIP32.fromBase58(fixture.walletKeys[2]);
+        });
+        it("should generate nonces for MuSig2 inputs with auto-generated session ID", function () {
+            const unsignedBitgoPsbt = getBitGoPsbt(fixture, networkName);
+            // Generate nonces with auto-generated session ID (no second parameter)
+            assert.doesNotThrow(() => {
+                unsignedBitgoPsbt.generateMusig2Nonces(userKey);
+            });
+            // Verify nonces were stored by serializing and deserializing
+            const serializedWithUserNonces = unsignedBitgoPsbt.serialize();
+            assert.ok(serializedWithUserNonces.length > getBitGoPsbt(fixture, networkName).serialize().length);
+            assert.doesNotThrow(() => {
+                unsignedBitgoPsbt.generateMusig2Nonces(bitgoKey);
+            });
+            const serializedWithBitgoNonces = unsignedBitgoPsbt.serialize();
+            assert.ok(serializedWithBitgoNonces.length > serializedWithUserNonces.length);
+            assert.throws(() => {
+                unsignedBitgoPsbt.generateMusig2Nonces(backupKey);
+            }, "Should throw error when generating nonces for backup key");
+        });
+        it("implements combineMusig2Nonces", function () {
+            const unsignedBitgoPsbtWithUserNonces = getBitGoPsbt(fixture, networkName);
+            unsignedBitgoPsbtWithUserNonces.generateMusig2Nonces(userKey);
+            const unsignedBitgoPsbtWithBitgoNonces = getBitGoPsbt(fixture, networkName);
+            unsignedBitgoPsbtWithBitgoNonces.generateMusig2Nonces(bitgoKey);
+            const unsignedBitgoPsbtWithBothNonces = getBitGoPsbt(fixture, networkName);
+            unsignedBitgoPsbtWithBothNonces.combineMusig2Nonces(unsignedBitgoPsbtWithUserNonces);
+            unsignedBitgoPsbtWithBothNonces.combineMusig2Nonces(unsignedBitgoPsbtWithBitgoNonces);
+            {
+                const psbt = getBitGoPsbt(fixture, networkName);
+                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithUserNonces);
+                assert.strictEqual(psbt.serialize().length, unsignedBitgoPsbtWithUserNonces.serialize().length);
+            }
+            {
+                const psbt = getBitGoPsbt(fixture, networkName);
+                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithBitgoNonces);
+                assert.strictEqual(psbt.serialize().length, unsignedBitgoPsbtWithBitgoNonces.serialize().length);
+            }
+            {
+                const psbt = getBitGoPsbt(fixture, networkName);
+                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithUserNonces);
+                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithBitgoNonces);
+                assert.strictEqual(psbt.serialize().length, unsignedBitgoPsbtWithBothNonces.serialize().length);
+            }
+        });
+        it("should reject invalid session ID length", function () {
+            const unsignedBitgoPsbt = getBitGoPsbt(fixture, networkName);
+            // Invalid session ID (wrong length)
+            const invalidSessionId = new Uint8Array(16); // Should be 32 bytes
+            assert.throws(() => {
+                unsignedBitgoPsbt.generateMusig2Nonces(userKey, invalidSessionId);
+            }, "Should throw error for invalid session ID length");
+        });
+        it("should reject custom session ID on mainnet (security)", function () {
+            const unsignedBitgoPsbt = getBitGoPsbt(fixture, "bitcoin");
+            // Custom session ID should be rejected on mainnet for security
+            const customSessionId = new Uint8Array(32).fill(1);
+            assert.throws(() => {
+                unsignedBitgoPsbt.generateMusig2Nonces(userKey, customSessionId);
+            }, /Custom session_id is only allowed on testnets/, "Should throw error when providing custom session_id on mainnet");
+        });
+    });
+});

package/dist/esm/test/fixedScript/signAndVerifySignature.d.ts

@@ -0,0 +1 @@
+export {};