@bitgo/wasm-utxo 1.20.0 → 1.22.0

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

@@ -9,6 +9,106 @@ export class AddressNamespace {
   static from_output_script_with_coin(script: Uint8Array, coin: string, format?: string | null): string;
 }
 
+export class Bip322Namespace {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Add a BIP-0322 message input to an existing BitGoPsbt
+   *
+   * If this is the first input, also adds the OP_RETURN output.
+   * The PSBT must have version 0 per BIP-0322 specification.
+   *
+   * # Arguments
+   * * `psbt` - The BitGoPsbt to add the input to
+   * * `message` - The message to sign
+   * * `chain` - The wallet chain (e.g., 10 for external, 20 for internal)
+   * * `index` - The address index
+   * * `wallet_keys` - The wallet's root keys
+   * * `signer` - Optional signer key name for taproot (e.g., "user", "backup", "bitgo")
+   * * `cosigner` - Optional cosigner key name for taproot
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * The index of the added input
+   */
+  static add_bip322_input(psbt: BitGoPsbt, message: string, chain: number, index: number, wallet_keys: WasmRootWalletKeys, signer?: string | null, cosigner?: string | null, tag?: string | null): number;
+  /**
+   * Verify a single input of a BIP-0322 transaction proof
+   *
+   * # Arguments
+   * * `tx` - The signed transaction
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `chain` - The wallet chain
+   * * `index` - The address index
+   * * `wallet_keys` - The wallet's root keys
+   * * `network` - Network name
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Throws
+   * Throws an error if verification fails
+   */
+  static verify_bip322_tx_input(tx: WasmTransaction, input_index: number, message: string, chain: number, index: number, wallet_keys: WasmRootWalletKeys, network: string, tag?: string | null): void;
+  /**
+   * Verify a single input of a BIP-0322 PSBT proof
+   *
+   * # Arguments
+   * * `psbt` - The signed BitGoPsbt
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `chain` - The wallet chain
+   * * `index` - The address index
+   * * `wallet_keys` - The wallet's root keys
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * An array of signer names ("user", "backup", "bitgo") that have valid signatures
+   *
+   * # Throws
+   * Throws an error if verification fails or no valid signatures found
+   */
+  static verify_bip322_psbt_input(psbt: BitGoPsbt, input_index: number, message: string, chain: number, index: number, wallet_keys: WasmRootWalletKeys, tag?: string | null): string[];
+  /**
+   * Verify a single input of a BIP-0322 transaction proof using pubkeys directly
+   *
+   * # Arguments
+   * * `tx` - The signed transaction
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+   * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+   * * `is_script_path` - For taproot types, whether script path was used
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * An array of pubkey indices (0, 1, 2) that have valid signatures
+   *
+   * # Throws
+   * Throws an error if verification fails
+   */
+  static verify_bip322_tx_input_with_pubkeys(tx: WasmTransaction, input_index: number, message: string, pubkeys: string[], script_type: string, is_script_path?: boolean | null, tag?: string | null): Uint32Array;
+  /**
+   * Verify a single input of a BIP-0322 PSBT proof using pubkeys directly
+   *
+   * # Arguments
+   * * `psbt` - The signed BitGoPsbt
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+   * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+   * * `is_script_path` - For taproot types, whether script path was used
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * An array of pubkey indices (0, 1, 2) that have valid signatures
+   *
+   * # Throws
+   * Throws an error if verification fails or no valid signatures found
+   */
+  static verify_bip322_psbt_input_with_pubkeys(psbt: BitGoPsbt, input_index: number, message: string, pubkeys: string[], script_type: string, is_script_path?: boolean | null, tag?: string | null): Uint32Array;
+}
+
 export class BitGoPsbt {
   private constructor();
   free(): void;
@@ -379,6 +479,22 @@ export class FixedScriptWalletNamespace {
   free(): void;
   [Symbol.dispose](): void;
   static output_script(keys: WasmRootWalletKeys, chain: number, index: number, network: any): Uint8Array;
+  /**
+   * Check if a network supports a given fixed-script wallet script type
+   *
+   * # Arguments
+   * * `coin` - Coin name (e.g., "btc", "ltc", "doge")
+   * * `script_type` - Script type name: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+   *
+   * # Returns
+   * `true` if the network supports the script type, `false` otherwise
+   *
+   * # Examples
+   * - Bitcoin supports all script types (p2sh, p2shP2wsh, p2wsh, p2tr, p2trMusig2)
+   * - Litecoin supports segwit but not taproot (p2sh, p2shP2wsh, p2wsh)
+   * - Dogecoin only supports legacy scripts (p2sh)
+   */
+  static supports_script_type(coin: string, script_type: string): boolean;
   static address(keys: WasmRootWalletKeys, chain: number, index: number, network: any, address_format?: string | null): string;
 }
 

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

@@ -29,6 +29,21 @@ function dropObject(idx) {
     heap_next = idx;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -47,6 +62,14 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -161,6 +184,10 @@ const AddressNamespaceFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_addressnamespace_free(ptr >>> 0, 1));
 
+const Bip322NamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bip322namespace_free(ptr >>> 0, 1));
+
 const BitGoPsbtFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bitgopsbt_free(ptr >>> 0, 1));
@@ -295,6 +322,278 @@ class AddressNamespace {
 if (Symbol.dispose) AddressNamespace.prototype[Symbol.dispose] = AddressNamespace.prototype.free;
 exports.AddressNamespace = AddressNamespace;
 
+/**
+ * Namespace for BIP-0322 functions
+ */
+class Bip322Namespace {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Bip322NamespaceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bip322namespace_free(ptr, 0);
+    }
+    /**
+     * Add a BIP-0322 message input to an existing BitGoPsbt
+     *
+     * If this is the first input, also adds the OP_RETURN output.
+     * The PSBT must have version 0 per BIP-0322 specification.
+     *
+     * # Arguments
+     * * `psbt` - The BitGoPsbt to add the input to
+     * * `message` - The message to sign
+     * * `chain` - The wallet chain (e.g., 10 for external, 20 for internal)
+     * * `index` - The address index
+     * * `wallet_keys` - The wallet's root keys
+     * * `signer` - Optional signer key name for taproot (e.g., "user", "backup", "bitgo")
+     * * `cosigner` - Optional cosigner key name for taproot
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * The index of the added input
+     * @param {BitGoPsbt} psbt
+     * @param {string} message
+     * @param {number} chain
+     * @param {number} index
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {string | null} [signer]
+     * @param {string | null} [cosigner]
+     * @param {string | null} [tag]
+     * @returns {number}
+     */
+    static add_bip322_input(psbt, message, chain, index, wallet_keys, signer, cosigner, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(psbt, BitGoPsbt);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            var ptr1 = isLikeNone(signer) ? 0 : passStringToWasm0(signer, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(cosigner) ? 0 : passStringToWasm0(cosigner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len3 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_add_bip322_input(retptr, psbt.__wbg_ptr, ptr0, len0, chain, index, wallet_keys.__wbg_ptr, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 >>> 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify a single input of a BIP-0322 transaction proof
+     *
+     * # Arguments
+     * * `tx` - The signed transaction
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `chain` - The wallet chain
+     * * `index` - The address index
+     * * `wallet_keys` - The wallet's root keys
+     * * `network` - Network name
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Throws
+     * Throws an error if verification fails
+     * @param {WasmTransaction} tx
+     * @param {number} input_index
+     * @param {string} message
+     * @param {number} chain
+     * @param {number} index
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {string} network
+     * @param {string | null} [tag]
+     */
+    static verify_bip322_tx_input(tx, input_index, message, chain, index, wallet_keys, network, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(tx, WasmTransaction);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            const ptr1 = passStringToWasm0(network, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_tx_input(retptr, tx.__wbg_ptr, input_index, ptr0, len0, chain, index, wallet_keys.__wbg_ptr, ptr1, len1, ptr2, len2);
+            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 a single input of a BIP-0322 PSBT proof
+     *
+     * # Arguments
+     * * `psbt` - The signed BitGoPsbt
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `chain` - The wallet chain
+     * * `index` - The address index
+     * * `wallet_keys` - The wallet's root keys
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * An array of signer names ("user", "backup", "bitgo") that have valid signatures
+     *
+     * # Throws
+     * Throws an error if verification fails or no valid signatures found
+     * @param {BitGoPsbt} psbt
+     * @param {number} input_index
+     * @param {string} message
+     * @param {number} chain
+     * @param {number} index
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {string | null} [tag]
+     * @returns {string[]}
+     */
+    static verify_bip322_psbt_input(psbt, input_index, message, chain, index, wallet_keys, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(psbt, BitGoPsbt);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            var ptr1 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_psbt_input(retptr, psbt.__wbg_ptr, input_index, ptr0, len0, chain, index, wallet_keys.__wbg_ptr, ptr1, len1);
+            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 v3 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify a single input of a BIP-0322 transaction proof using pubkeys directly
+     *
+     * # Arguments
+     * * `tx` - The signed transaction
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+     * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+     * * `is_script_path` - For taproot types, whether script path was used
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * An array of pubkey indices (0, 1, 2) that have valid signatures
+     *
+     * # Throws
+     * Throws an error if verification fails
+     * @param {WasmTransaction} tx
+     * @param {number} input_index
+     * @param {string} message
+     * @param {string[]} pubkeys
+     * @param {string} script_type
+     * @param {boolean | null} [is_script_path]
+     * @param {string | null} [tag]
+     * @returns {Uint32Array}
+     */
+    static verify_bip322_tx_input_with_pubkeys(tx, input_index, message, pubkeys, script_type, is_script_path, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(tx, WasmTransaction);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(pubkeys, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(script_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len3 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_tx_input_with_pubkeys(retptr, tx.__wbg_ptr, input_index, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(is_script_path) ? 0xFFFFFF : is_script_path ? 1 : 0, ptr3, len3);
+            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 v5 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v5;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify a single input of a BIP-0322 PSBT proof using pubkeys directly
+     *
+     * # Arguments
+     * * `psbt` - The signed BitGoPsbt
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+     * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+     * * `is_script_path` - For taproot types, whether script path was used
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * An array of pubkey indices (0, 1, 2) that have valid signatures
+     *
+     * # Throws
+     * Throws an error if verification fails or no valid signatures found
+     * @param {BitGoPsbt} psbt
+     * @param {number} input_index
+     * @param {string} message
+     * @param {string[]} pubkeys
+     * @param {string} script_type
+     * @param {boolean | null} [is_script_path]
+     * @param {string | null} [tag]
+     * @returns {Uint32Array}
+     */
+    static verify_bip322_psbt_input_with_pubkeys(psbt, input_index, message, pubkeys, script_type, is_script_path, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(psbt, BitGoPsbt);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(pubkeys, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(script_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len3 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_psbt_input_with_pubkeys(retptr, psbt.__wbg_ptr, input_index, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(is_script_path) ? 0xFFFFFF : is_script_path ? 1 : 0, ptr3, len3);
+            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 v5 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v5;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) Bip322Namespace.prototype[Symbol.dispose] = Bip322Namespace.prototype.free;
+exports.Bip322Namespace = Bip322Namespace;
+
 class BitGoPsbt {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -1220,6 +1519,43 @@ class FixedScriptWalletNamespace {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Check if a network supports a given fixed-script wallet script type
+     *
+     * # Arguments
+     * * `coin` - Coin name (e.g., "btc", "ltc", "doge")
+     * * `script_type` - Script type name: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+     *
+     * # Returns
+     * `true` if the network supports the script type, `false` otherwise
+     *
+     * # Examples
+     * - Bitcoin supports all script types (p2sh, p2shP2wsh, p2wsh, p2tr, p2trMusig2)
+     * - Litecoin supports segwit but not taproot (p2sh, p2shP2wsh, p2wsh)
+     * - Dogecoin only supports legacy scripts (p2sh)
+     * @param {string} coin
+     * @param {string} script_type
+     * @returns {boolean}
+     */
+    static supports_script_type(coin, script_type) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(coin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(script_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fixedscriptwalletnamespace_supports_script_type(retptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 !== 0;
+        } 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

@@ -1,21 +1,11 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
-export const __wbg_wasmdashtransaction_free: (a: number, b: number) => void;
-export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;
 export const __wbg_wasmtransaction_free: (a: number, b: number) => void;
 export const __wbg_wasmzcashtransaction_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 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 wasmdashtransaction_from_bytes: (a: number, b: number, c: number) => void;
-export const wasmdashtransaction_to_bytes: (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 wasmtransaction_from_bytes: (a: number, b: number, c: number) => void;
 export const wasmtransaction_get_vsize: (a: number) => number;
 export const wasmtransaction_to_bytes: (a: number, b: number) => void;
@@ -47,14 +37,23 @@ export const wrappsbt_signWithXprv: (a: number, b: number, c: number, d: number)
 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_addressnamespace_free: (a: number, b: number) => void;
+export const __wbg_bip322namespace_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_utxolibcompatnamespace_free: (a: number, b: number) => void;
 export const __wbg_wasmbip32_free: (a: number, b: number) => void;
+export const __wbg_wasmdashtransaction_free: (a: number, b: number) => void;
 export const __wbg_wasmdimensions_free: (a: number, b: number) => void;
 export const __wbg_wasmecpair_free: (a: number, b: number) => void;
+export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;
 export const __wbg_wasmrootwalletkeys_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 bip322namespace_add_bip322_input: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
+export const bip322namespace_verify_bip322_psbt_input: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+export const bip322namespace_verify_bip322_psbt_input_with_pubkeys: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+export const bip322namespace_verify_bip322_tx_input: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+export const bip322namespace_verify_bip322_tx_input_with_pubkeys: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
 export const bitgopsbt_add_input: (a: number, b: number, c: number, d: number, e: number, f: bigint, g: number, h: number, i: number, j: number, k: number) => void;
 export const bitgopsbt_add_output: (a: number, b: number, c: number, d: number, e: bigint) => void;
 export const bitgopsbt_add_output_with_address: (a: number, b: number, c: number, d: number, e: bigint) => void;
@@ -86,6 +85,9 @@ export const bitgopsbt_version: (a: number) => number;
 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_output_script: (a: number, b: number, c: number, d: number, e: number) => void;
+export const fixedscriptwalletnamespace_supports_script_type: (a: number, b: number, c: number, d: number, e: 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 wasmbip32_chain_code: (a: number) => number;
 export const wasmbip32_depth: (a: number) => number;
 export const wasmbip32_derive: (a: number, b: number, c: number) => void;
@@ -106,6 +108,8 @@ export const wasmbip32_private_key: (a: number) => number;
 export const wasmbip32_public_key: (a: number) => number;
 export const wasmbip32_to_base58: (a: number, b: number) => void;
 export const wasmbip32_to_wif: (a: number, b: number) => void;
+export const wasmdashtransaction_from_bytes: (a: number, b: number, c: number) => void;
+export const wasmdashtransaction_to_bytes: (a: number, b: number) => void;
 export const wasmdimensions_empty: () => number;
 export const wasmdimensions_from_input: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const wasmdimensions_from_input_script_type: (a: number, b: number, c: number) => void;
@@ -125,6 +129,9 @@ export const wasmecpair_public_key: (a: number) => number;
 export const wasmecpair_to_wif: (a: number, b: number) => void;
 export const wasmecpair_to_wif_mainnet: (a: number, b: number) => void;
 export const wasmecpair_to_wif_testnet: (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 wasmrootwalletkeys_backup_key: (a: number) => number;
 export const wasmrootwalletkeys_bitgo_key: (a: number) => number;
 export const wasmrootwalletkeys_new: (a: number, b: number, c: number, d: number) => void;