@bitgo/wasm-utxo 1.6.0 → 1.7.0

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

@@ -133,6 +133,12 @@ function takeObject(idx) {
     return ret;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -140,10 +146,22 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
+let stack_pointer = 128;
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = 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')
@@ -301,31 +319,122 @@ class BitGoPsbt {
             wasm.__wbindgen_export_3(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Extract the final transaction from a finalized PSBT
+     *
+     * This method should be called after all inputs have been finalized.
+     * It extracts the fully signed transaction.
+     *
+     * # Returns
+     * - `Ok(Vec<u8>)` containing the serialized transaction bytes
+     * - `Err(WasmUtxoError)` if the PSBT is not fully finalized or extraction fails
+     * @returns {Uint8Array}
+     */
+    extract_transaction() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_extract_transaction(retptr, this.__wbg_ptr);
+            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 v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Finalize all inputs in the PSBT
+     *
+     * This method attempts to finalize all inputs in the PSBT, computing the final
+     * scriptSig and witness data for each input.
+     *
+     * # Returns
+     * - `Ok(())` if all inputs were successfully finalized
+     * - `Err(WasmUtxoError)` if any input failed to finalize
+     */
+    finalize_all_inputs() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_finalize_all_inputs(retptr, this.__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);
+        }
+    }
+    /**
+     * Verify if a valid signature exists for a given ECPair key at the specified input index
+     *
+     * This method verifies the signature directly with the provided ECPair's public key. It supports:
+     * - ECDSA signatures (for legacy/SegWit inputs)
+     * - Schnorr signatures (for Taproot script path inputs)
+     *
+     * Note: This method does NOT support MuSig2 inputs, as MuSig2 requires derivation from xpubs.
+     * Use `verify_signature_with_xpub` for MuSig2 inputs.
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to check
+     * - `ecpair`: The ECPair key (uses the public key for verification)
+     *
+     * # Returns
+     * - `Ok(true)` if a valid signature exists for the public key
+     * - `Ok(false)` if no signature exists for the public key
+     * - `Err(WasmUtxoError)` if the input index is out of bounds or verification fails
+     * @param {number} input_index
+     * @param {WasmECPair} ecpair
+     * @returns {boolean}
+     */
+    verify_signature_with_pub(input_index, ecpair) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            wasm.bitgopsbt_verify_signature_with_pub(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);
+            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 if a valid signature exists for a given xpub at the specified input index
      *
      * This method derives the public key from the xpub using the derivation path found in the
-     * PSBT input, then verifies the signature. It supports both ECDSA signatures (for legacy/SegWit
-     * inputs) and Schnorr signatures (for Taproot script path inputs).
+     * PSBT input, then verifies the signature. It supports:
+     * - ECDSA signatures (for legacy/SegWit inputs)
+     * - Schnorr signatures (for Taproot script path inputs)
+     * - MuSig2 partial signatures (for Taproot keypath MuSig2 inputs)
      *
      * # Arguments
      * - `input_index`: The index of the input to check
-     * - `xpub_str`: The extended public key as a base58-encoded string
+     * - `xpub`: The extended public key as a WasmBIP32 instance
      *
      * # Returns
      * - `Ok(true)` if a valid signature exists for the derived public key
      * - `Ok(false)` if no signature exists for the derived public key
-     * - `Err(WasmUtxoError)` if the input index is out of bounds, xpub is invalid, derivation fails, or verification fails
+     * - `Err(WasmUtxoError)` if the input index is out of bounds, derivation fails, or verification fails
      * @param {number} input_index
-     * @param {string} xpub_str
+     * @param {WasmBIP32} xpub
      * @returns {boolean}
      */
-    verify_signature(input_index, xpub_str) {
+    verify_signature_with_xpub(input_index, xpub) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(xpub_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.bitgopsbt_verify_signature(retptr, this.__wbg_ptr, input_index, ptr0, len0);
+            _assertClass(xpub, WasmBIP32);
+            wasm.bitgopsbt_verify_signature_with_xpub(retptr, this.__wbg_ptr, input_index, xpub.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -338,341 +447,1137 @@ class BitGoPsbt {
         }
     }
     /**
-     * Extract the final transaction from a finalized PSBT
+     * Parse outputs with wallet keys to identify which outputs belong to a wallet
      *
-     * This method should be called after all inputs have been finalized.
-     * It extracts the fully signed transaction.
+     * Note: This method does NOT validate wallet inputs. It only parses outputs.
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @returns {any}
+     */
+    parse_outputs_with_wallet_keys(wallet_keys) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            wasm.bitgopsbt_parse_outputs_with_wallet_keys(retptr, this.__wbg_ptr, wallet_keys.__wbg_ptr);
+            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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Parse transaction with wallet keys to identify wallet inputs/outputs
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {WasmReplayProtection} replay_protection
+     * @returns {any}
+     */
+    parse_transaction_with_wallet_keys(wallet_keys, replay_protection) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            _assertClass(replay_protection, WasmReplayProtection);
+            wasm.bitgopsbt_parse_transaction_with_wallet_keys(retptr, this.__wbg_ptr, wallet_keys.__wbg_ptr, replay_protection.__wbg_ptr);
+            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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify if a replay protection input has a valid signature
+     *
+     * This method checks if a given input is a replay protection input and cryptographically verifies
+     * the signature. Replay protection inputs (like P2shP2pk) don't use standard derivation paths,
+     * so this method verifies signatures without deriving from xpub.
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to check
+     * - `replay_protection`: Replay protection configuration (same format as parseTransactionWithWalletKeys)
+     *   Can be either `{ outputScripts: Buffer[] }` or `{ addresses: string[] }`
      *
      * # Returns
-     * - `Ok(Vec<u8>)` containing the serialized transaction bytes
-     * - `Err(WasmUtxoError)` if the PSBT is not fully finalized or extraction fails
+     * - `Ok(true)` if the input is a replay protection input and has a valid signature
+     * - `Ok(false)` if the input is a replay protection input but has no valid signature
+     * - `Err(WasmUtxoError)` if the input is not a replay protection input, index is out of bounds, or configuration is invalid
+     * @param {number} input_index
+     * @param {WasmReplayProtection} replay_protection
+     * @returns {boolean}
+     */
+    verify_replay_protection_signature(input_index, replay_protection) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(replay_protection, WasmReplayProtection);
+            wasm.bitgopsbt_verify_replay_protection_signature(retptr, this.__wbg_ptr, input_index, replay_protection.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Get the network of the PSBT
+     * @returns {string}
+     */
+    network() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_network(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Serialize the PSBT to bytes
+     *
+     * # Returns
+     * The serialized PSBT as a byte array
+     * @returns {Uint8Array}
+     */
+    serialize() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_serialize(retptr, this.__wbg_ptr);
+            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 v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BitGoPsbt.prototype[Symbol.dispose] = BitGoPsbt.prototype.free;
+
+exports.BitGoPsbt = BitGoPsbt;
+
+const FixedScriptWalletNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fixedscriptwalletnamespace_free(ptr >>> 0, 1));
+
+class FixedScriptWalletNamespace {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FixedScriptWalletNamespaceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fixedscriptwalletnamespace_free(ptr, 0);
+    }
+    /**
+     * @param {WasmRootWalletKeys} keys
+     * @param {number} chain
+     * @param {number} index
+     * @param {any} network
      * @returns {Uint8Array}
      */
-    extract_transaction() {
+    static output_script(keys, chain, index, network) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(keys, WasmRootWalletKeys);
+            wasm.fixedscriptwalletnamespace_output_script(retptr, keys.__wbg_ptr, chain, index, addHeapObject(network));
+            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 v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {WasmRootWalletKeys} keys
+     * @param {number} chain
+     * @param {number} index
+     * @param {any} network
+     * @param {string | null} [address_format]
+     * @returns {string}
+     */
+    static address(keys, chain, index, network, address_format) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(keys, WasmRootWalletKeys);
+            var ptr0 = isLikeNone(address_format) ? 0 : passStringToWasm0(address_format, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.fixedscriptwalletnamespace_address(retptr, keys.__wbg_ptr, chain, index, addHeapObject(network), 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);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred3_0, deferred3_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) FixedScriptWalletNamespace.prototype[Symbol.dispose] = FixedScriptWalletNamespace.prototype.free;
+
+exports.FixedScriptWalletNamespace = FixedScriptWalletNamespace;
+
+const UtxolibCompatNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_utxolibcompatnamespace_free(ptr >>> 0, 1));
+
+class UtxolibCompatNamespace {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        UtxolibCompatNamespaceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_utxolibcompatnamespace_free(ptr, 0);
+    }
+    /**
+     * Convert address string to output script
+     *
+     * # Arguments
+     * * `address` - The address string
+     * * `network` - The UtxolibNetwork object from JavaScript
+     * * `format` - Optional address format (currently unused for decoding as all formats are accepted)
+     * @param {string} address
+     * @param {any} network
+     * @param {string | null} [format]
+     * @returns {Uint8Array}
+     */
+    static to_output_script(address, network, format) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(format) ? 0 : passStringToWasm0(format, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.utxolibcompatnamespace_to_output_script(retptr, ptr0, len0, addHeapObject(network), 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 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Convert output script to address string
+     *
+     * # Arguments
+     * * `script` - The output script as a byte array
+     * * `network` - The UtxolibNetwork object from JavaScript
+     * * `format` - Optional address format: "default" or "cashaddr" (only applicable for Bitcoin Cash and eCash)
+     * @param {Uint8Array} script
+     * @param {any} network
+     * @param {string | null} [format]
+     * @returns {string}
+     */
+    static from_output_script(script, network, format) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(format) ? 0 : passStringToWasm0(format, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.utxolibcompatnamespace_from_output_script(retptr, ptr0, len0, addHeapObject(network), 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);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred4_0, deferred4_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) UtxolibCompatNamespace.prototype[Symbol.dispose] = UtxolibCompatNamespace.prototype.free;
+
+exports.UtxolibCompatNamespace = UtxolibCompatNamespace;
+
+const WasmBIP32Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmbip32_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for BIP32 extended keys (Xpub/Xpriv)
+ * Implements the BIP32Interface TypeScript interface
+ */
+class WasmBIP32 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmBIP32.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmBIP32Finalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmBIP32Finalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmbip32_free(ptr, 0);
+    }
+    /**
+     * Get the chain code as a Uint8Array
+     * @returns {Uint8Array}
+     */
+    get chain_code() {
+        const ret = wasm.wasmbip32_chain_code(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the identifier as a Uint8Array
+     * @returns {Uint8Array}
+     */
+    get identifier() {
+        const ret = wasm.wasmbip32_identifier(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the public key as a Uint8Array
+     * @returns {Uint8Array}
+     */
+    get public_key() {
+        const ret = wasm.wasmbip32_public_key(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Derive a key using a derivation path (e.g., "0/1/2" or "m/0/1/2")
+     * @param {string} path
+     * @returns {WasmBIP32}
+     */
+    derive_path(path) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmbip32_derive_path(retptr, this.__wbg_ptr, 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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the fingerprint as a Uint8Array
+     * @returns {Uint8Array}
+     */
+    get fingerprint() {
+        const ret = wasm.wasmbip32_fingerprint(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create a BIP32 key from a base58 string (xpub/xprv/tpub/tprv)
+     * @param {string} base58_str
+     * @returns {WasmBIP32}
+     */
+    static from_base58(base58_str) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(base58_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmbip32_from_base58(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Check if this is a neutered (public) key
+     * @returns {boolean}
+     */
+    is_neutered() {
+        const ret = wasm.wasmbip32_is_neutered(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the private key as a Uint8Array (if available)
+     * @returns {Uint8Array | undefined}
+     */
+    get private_key() {
+        const ret = wasm.wasmbip32_private_key(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Derive a hardened child key (only works for private keys)
+     * @param {number} index
+     * @returns {WasmBIP32}
+     */
+    derive_hardened(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmbip32_derive_hardened(retptr, this.__wbg_ptr, index);
+            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 WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the parent fingerprint
+     * @returns {number}
+     */
+    get parent_fingerprint() {
+        const ret = wasm.wasmbip32_parent_fingerprint(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a BIP32 key from a BIP32Interface JavaScript object properties
+     * Expects an object with: network.bip32.public, depth, parentFingerprint,
+     * index, chainCode, and publicKey properties
+     * @param {any} bip32_key
+     * @returns {WasmBIP32}
+     */
+    static from_bip32_interface(bip32_key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmbip32_from_bip32_interface(retptr, addBorrowedObject(bip32_key));
+            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 WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Create a BIP32 key from BIP32 properties
+     * Extracts properties from a JavaScript object and constructs an xpub
+     * @param {any} bip32_key
+     * @returns {WasmBIP32}
+     */
+    static from_bip32_properties(bip32_key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmbip32_from_bip32_interface(retptr, addBorrowedObject(bip32_key));
+            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 WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Get the depth
+     * @returns {number}
+     */
+    get depth() {
+        const ret = wasm.wasmbip32_depth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the child index
+     * @returns {number}
+     */
+    get index() {
+        const ret = wasm.wasmbip32_index(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Derive a normal (non-hardened) child key
+     * @param {number} index
+     * @returns {WasmBIP32}
+     */
+    derive(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmbip32_derive(retptr, this.__wbg_ptr, index);
+            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 WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the WIF encoding of the private key
+     * @returns {string}
+     */
+    to_wif() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmbip32_to_wif(retptr, this.__wbg_ptr);
+            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);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Get the neutered (public) version of this key
+     * @returns {WasmBIP32}
+     */
+    neutered() {
+        const ret = wasm.wasmbip32_neutered(this.__wbg_ptr);
+        return WasmBIP32.__wrap(ret);
+    }
+    /**
+     * Create a BIP32 master key from a seed
+     * @param {Uint8Array} seed
+     * @param {string | null} [network]
+     * @returns {WasmBIP32}
+     */
+    static from_seed(seed, network) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(network) ? 0 : passStringToWasm0(network, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.wasmbip32_from_seed(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 WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Create a BIP32 key from an xprv string (base58-encoded)
+     * @param {string} xprv_str
+     * @returns {WasmBIP32}
+     */
+    static from_xprv(xprv_str) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(xprv_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmbip32_from_xprv(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Create a BIP32 key from an xpub string (base58-encoded)
+     * @param {string} xpub_str
+     * @returns {WasmBIP32}
+     */
+    static from_xpub(xpub_str) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(xpub_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmbip32_from_xpub(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return WasmBIP32.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serialize to base58 string
+     * @returns {string}
+     */
+    to_base58() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmbip32_to_base58(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmBIP32.prototype[Symbol.dispose] = WasmBIP32.prototype.free;
+
+exports.WasmBIP32 = WasmBIP32;
+
+const WasmECPairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmecpair_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for elliptic curve key pairs (always uses compressed keys)
+ */
+class WasmECPair {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmECPair.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmECPairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmECPairFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmecpair_free(ptr, 0);
+    }
+    /**
+     * Get the compressed public key as a Uint8Array (always 33 bytes)
+     * @returns {Uint8Array}
+     */
+    get public_key() {
+        const ret = wasm.wasmecpair_public_key(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the private key as a Uint8Array (if available)
+     * @returns {Uint8Array | undefined}
+     */
+    get private_key() {
+        const ret = wasm.wasmecpair_private_key(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Convert to mainnet WIF string
+     * @returns {string}
+     */
+    to_wif_mainnet() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmecpair_to_wif_mainnet(retptr, this.__wbg_ptr);
+            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);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Convert to testnet WIF string
+     * @returns {string}
+     */
+    to_wif_testnet() {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.bitgopsbt_extract_transaction(retptr, this.__wbg_ptr);
+            wasm.wasmecpair_to_wif_testnet(retptr, this.__wbg_ptr);
             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);
+            var ptr1 = r0;
+            var len1 = r1;
             if (r3) {
+                ptr1 = 0; len1 = 0;
                 throw takeObject(r2);
             }
-            var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
-            return v1;
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred2_0, deferred2_1, 1);
         }
     }
     /**
-     * Finalize all inputs in the PSBT
-     *
-     * This method attempts to finalize all inputs in the PSBT, computing the final
-     * scriptSig and witness data for each input.
-     *
-     * # Returns
-     * - `Ok(())` if all inputs were successfully finalized
-     * - `Err(WasmUtxoError)` if any input failed to finalize
+     * Create an ECPair from a public key (always uses compressed keys)
+     * @param {Uint8Array} public_key
+     * @returns {WasmECPair}
      */
-    finalize_all_inputs() {
+    static from_public_key(public_key) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.bitgopsbt_finalize_all_inputs(retptr, this.__wbg_ptr);
+            const ptr0 = passArray8ToWasm0(public_key, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmecpair_from_public_key(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return WasmECPair.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Parse outputs with wallet keys to identify which outputs belong to a wallet
-     *
-     * Note: This method does NOT validate wallet inputs. It only parses outputs.
-     * @param {any} wallet_keys
-     * @returns {any}
+     * Create an ECPair from a private key (always uses compressed keys)
+     * @param {Uint8Array} private_key
+     * @returns {WasmECPair}
      */
-    parse_outputs_with_wallet_keys(wallet_keys) {
+    static from_private_key(private_key) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.bitgopsbt_parse_outputs_with_wallet_keys(retptr, this.__wbg_ptr, addHeapObject(wallet_keys));
+            const ptr0 = passArray8ToWasm0(private_key, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmecpair_from_private_key(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);
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
+            return WasmECPair.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Parse transaction with wallet keys to identify wallet inputs/outputs
-     * @param {any} wallet_keys
-     * @param {any} replay_protection
-     * @returns {any}
+     * Create an ECPair from a mainnet WIF string
+     * @param {string} wif_string
+     * @returns {WasmECPair}
      */
-    parse_transaction_with_wallet_keys(wallet_keys, replay_protection) {
+    static from_wif_mainnet(wif_string) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.bitgopsbt_parse_transaction_with_wallet_keys(retptr, this.__wbg_ptr, addHeapObject(wallet_keys), addHeapObject(replay_protection));
+            const ptr0 = passStringToWasm0(wif_string, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmecpair_from_wif_mainnet(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);
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
+            return WasmECPair.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Verify if a replay protection input has a valid signature
-     *
-     * This method checks if a given input is a replay protection input and cryptographically verifies
-     * the signature. Replay protection inputs (like P2shP2pk) don't use standard derivation paths,
-     * so this method verifies signatures without deriving from xpub.
-     *
-     * # Arguments
-     * - `input_index`: The index of the input to check
-     * - `replay_protection`: Replay protection configuration (same format as parseTransactionWithWalletKeys)
-     *   Can be either `{ outputScripts: Buffer[] }` or `{ addresses: string[] }`
-     *
-     * # Returns
-     * - `Ok(true)` if the input is a replay protection input and has a valid signature
-     * - `Ok(false)` if the input is a replay protection input but has no valid signature
-     * - `Err(WasmUtxoError)` if the input is not a replay protection input, index is out of bounds, or configuration is invalid
-     * @param {number} input_index
-     * @param {any} replay_protection
-     * @returns {boolean}
+     * Create an ECPair from a testnet WIF string
+     * @param {string} wif_string
+     * @returns {WasmECPair}
      */
-    verify_replay_protection_signature(input_index, replay_protection) {
+    static from_wif_testnet(wif_string) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.bitgopsbt_verify_replay_protection_signature(retptr, this.__wbg_ptr, input_index, addHeapObject(replay_protection));
+            const ptr0 = passStringToWasm0(wif_string, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmecpair_from_wif_testnet(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);
             if (r2) {
                 throw takeObject(r1);
             }
-            return r0 !== 0;
+            return WasmECPair.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Serialize the PSBT to bytes
-     *
-     * # Returns
-     * The serialized PSBT as a byte array
-     * @returns {Uint8Array}
+     * Convert to WIF string (mainnet)
+     * @returns {string}
      */
-    serialize() {
+    to_wif() {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.bitgopsbt_serialize(retptr, this.__wbg_ptr);
+            wasm.wasmecpair_to_wif(retptr, this.__wbg_ptr);
             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);
+            var ptr1 = r0;
+            var len1 = r1;
             if (r3) {
+                ptr1 = 0; len1 = 0;
                 throw takeObject(r2);
             }
-            var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
-            return v1;
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Create an ECPair from a WIF string (auto-detects network)
+     * @param {string} wif_string
+     * @returns {WasmECPair}
+     */
+    static from_wif(wif_string) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(wif_string, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmecpair_from_wif(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return WasmECPair.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
 }
-if (Symbol.dispose) BitGoPsbt.prototype[Symbol.dispose] = BitGoPsbt.prototype.free;
+if (Symbol.dispose) WasmECPair.prototype[Symbol.dispose] = WasmECPair.prototype.free;
 
-exports.BitGoPsbt = BitGoPsbt;
+exports.WasmECPair = WasmECPair;
 
-const FixedScriptWalletNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmReplayProtectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_fixedscriptwalletnamespace_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmreplayprotection_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for ReplayProtection
+ */
+class WasmReplayProtection {
 
-class FixedScriptWalletNamespace {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmReplayProtection.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmReplayProtectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FixedScriptWalletNamespaceFinalization.unregister(this);
+        WasmReplayProtectionFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_fixedscriptwalletnamespace_free(ptr, 0);
+        wasm.__wbg_wasmreplayprotection_free(ptr, 0);
     }
     /**
-     * @param {any} keys
-     * @param {number} chain
-     * @param {number} index
-     * @param {any} network
-     * @returns {Uint8Array}
+     * Create from addresses (requires network for decoding)
+     * @param {any[]} addresses
+     * @param {string} network
+     * @returns {WasmReplayProtection}
      */
-    static output_script(keys, chain, index, network) {
+    static from_addresses(addresses, network) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.fixedscriptwalletnamespace_output_script(retptr, addHeapObject(keys), chain, index, addHeapObject(network));
+            const ptr0 = passArrayJsValueToWasm0(addresses, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(network, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.wasmreplayprotection_from_addresses(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);
-            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-            if (r3) {
-                throw takeObject(r2);
+            if (r2) {
+                throw takeObject(r1);
             }
-            var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
-            return v1;
+            return WasmReplayProtection.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * @param {any} keys
-     * @param {number} chain
-     * @param {number} index
-     * @param {any} network
-     * @param {string | null} [address_format]
-     * @returns {string}
+     * Create from public keys (derives P2SH-P2PK output scripts)
+     * @param {Uint8Array[]} public_keys
+     * @returns {WasmReplayProtection}
      */
-    static address(keys, chain, index, network, address_format) {
-        let deferred3_0;
-        let deferred3_1;
+    static from_public_keys(public_keys) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            var ptr0 = isLikeNone(address_format) ? 0 : passStringToWasm0(address_format, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
-            var len0 = WASM_VECTOR_LEN;
-            wasm.fixedscriptwalletnamespace_address(retptr, addHeapObject(keys), chain, index, addHeapObject(network), ptr0, len0);
+            const ptr0 = passArrayJsValueToWasm0(public_keys, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmreplayprotection_from_public_keys(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);
-            var ptr2 = r0;
-            var len2 = r1;
-            if (r3) {
-                ptr2 = 0; len2 = 0;
-                throw takeObject(r2);
+            if (r2) {
+                throw takeObject(r1);
             }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
+            return WasmReplayProtection.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_3(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * Create from output scripts directly
+     * @param {Uint8Array[]} output_scripts
+     * @returns {WasmReplayProtection}
+     */
+    static from_output_scripts(output_scripts) {
+        const ptr0 = passArrayJsValueToWasm0(output_scripts, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmreplayprotection_from_output_scripts(ptr0, len0);
+        return WasmReplayProtection.__wrap(ret);
+    }
 }
-if (Symbol.dispose) FixedScriptWalletNamespace.prototype[Symbol.dispose] = FixedScriptWalletNamespace.prototype.free;
+if (Symbol.dispose) WasmReplayProtection.prototype[Symbol.dispose] = WasmReplayProtection.prototype.free;
 
-exports.FixedScriptWalletNamespace = FixedScriptWalletNamespace;
+exports.WasmReplayProtection = WasmReplayProtection;
 
-const UtxolibCompatNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmRootWalletKeysFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_utxolibcompatnamespace_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrootwalletkeys_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for RootWalletKeys
+ * Represents a set of three extended public keys with their derivation prefixes
+ */
+class WasmRootWalletKeys {
 
-class UtxolibCompatNamespace {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmRootWalletKeys.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRootWalletKeysFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        UtxolibCompatNamespaceFinalization.unregister(this);
+        WasmRootWalletKeysFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_utxolibcompatnamespace_free(ptr, 0);
+        wasm.__wbg_wasmrootwalletkeys_free(ptr, 0);
     }
     /**
-     * Convert address string to output script
+     * Get the backup key (second xpub)
+     * @returns {WasmBIP32}
+     */
+    backup_key() {
+        const ret = wasm.wasmrootwalletkeys_backup_key(this.__wbg_ptr);
+        return WasmBIP32.__wrap(ret);
+    }
+    /**
+     * Create a RootWalletKeys from three BIP32 keys with custom derivation prefixes
      *
      * # Arguments
-     * * `address` - The address string
-     * * `network` - The UtxolibNetwork object from JavaScript
-     * * `format` - Optional address format (currently unused for decoding as all formats are accepted)
-     * @param {string} address
-     * @param {any} network
-     * @param {string | null} [format]
-     * @returns {Uint8Array}
+     * - `user`: User key (first xpub)
+     * - `backup`: Backup key (second xpub)
+     * - `bitgo`: BitGo key (third xpub)
+     * - `user_derivation`: Derivation path for user key (e.g., "m/0/0")
+     * - `backup_derivation`: Derivation path for backup key (e.g., "m/0/0")
+     * - `bitgo_derivation`: Derivation path for bitgo key (e.g., "m/0/0")
+     * @param {WasmBIP32} user
+     * @param {WasmBIP32} backup
+     * @param {WasmBIP32} bitgo
+     * @param {string} user_derivation
+     * @param {string} backup_derivation
+     * @param {string} bitgo_derivation
+     * @returns {WasmRootWalletKeys}
      */
-    static to_output_script(address, network, format) {
+    static with_derivation_prefixes(user, backup, bitgo, user_derivation, backup_derivation, bitgo_derivation) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            _assertClass(user, WasmBIP32);
+            _assertClass(backup, WasmBIP32);
+            _assertClass(bitgo, WasmBIP32);
+            const ptr0 = passStringToWasm0(user_derivation, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
             const len0 = WASM_VECTOR_LEN;
-            var ptr1 = isLikeNone(format) ? 0 : passStringToWasm0(format, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
-            var len1 = WASM_VECTOR_LEN;
-            wasm.utxolibcompatnamespace_to_output_script(retptr, ptr0, len0, addHeapObject(network), ptr1, len1);
+            const ptr1 = passStringToWasm0(backup_derivation, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(bitgo_derivation, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.wasmrootwalletkeys_with_derivation_prefixes(retptr, user.__wbg_ptr, backup.__wbg_ptr, bitgo.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             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);
+            if (r2) {
+                throw takeObject(r1);
             }
-            var v3 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
-            return v3;
+            return WasmRootWalletKeys.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Convert output script to address string
+     * Create a RootWalletKeys from three BIP32 keys
+     * Uses default derivation prefix of m/0/0 for all three keys
      *
      * # Arguments
-     * * `script` - The output script as a byte array
-     * * `network` - The UtxolibNetwork object from JavaScript
-     * * `format` - Optional address format: "default" or "cashaddr" (only applicable for Bitcoin Cash and eCash)
-     * @param {Uint8Array} script
-     * @param {any} network
-     * @param {string | null} [format]
-     * @returns {string}
+     * - `user`: User key (first xpub)
+     * - `backup`: Backup key (second xpub)
+     * - `bitgo`: BitGo key (third xpub)
+     * @param {WasmBIP32} user
+     * @param {WasmBIP32} backup
+     * @param {WasmBIP32} bitgo
      */
-    static from_output_script(script, network, format) {
-        let deferred4_0;
-        let deferred4_1;
+    constructor(user, backup, bitgo) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export_1);
-            const len0 = WASM_VECTOR_LEN;
-            var ptr1 = isLikeNone(format) ? 0 : passStringToWasm0(format, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
-            var len1 = WASM_VECTOR_LEN;
-            wasm.utxolibcompatnamespace_from_output_script(retptr, ptr0, len0, addHeapObject(network), ptr1, len1);
+            _assertClass(user, WasmBIP32);
+            _assertClass(backup, WasmBIP32);
+            _assertClass(bitgo, WasmBIP32);
+            wasm.wasmrootwalletkeys_new(retptr, user.__wbg_ptr, backup.__wbg_ptr, bitgo.__wbg_ptr);
             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);
-            var ptr3 = r0;
-            var len3 = r1;
-            if (r3) {
-                ptr3 = 0; len3 = 0;
-                throw takeObject(r2);
+            if (r2) {
+                throw takeObject(r1);
             }
-            deferred4_0 = ptr3;
-            deferred4_1 = len3;
-            return getStringFromWasm0(ptr3, len3);
+            this.__wbg_ptr = r0 >>> 0;
+            WasmRootWalletKeysFinalization.register(this, this.__wbg_ptr, this);
+            return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_3(deferred4_0, deferred4_1, 1);
         }
     }
+    /**
+     * Get the user key (first xpub)
+     * @returns {WasmBIP32}
+     */
+    user_key() {
+        const ret = wasm.wasmrootwalletkeys_user_key(this.__wbg_ptr);
+        return WasmBIP32.__wrap(ret);
+    }
+    /**
+     * Get the bitgo key (third xpub)
+     * @returns {WasmBIP32}
+     */
+    bitgo_key() {
+        const ret = wasm.wasmrootwalletkeys_bitgo_key(this.__wbg_ptr);
+        return WasmBIP32.__wrap(ret);
+    }
 }
-if (Symbol.dispose) UtxolibCompatNamespace.prototype[Symbol.dispose] = UtxolibCompatNamespace.prototype.free;
+if (Symbol.dispose) WasmRootWalletKeys.prototype[Symbol.dispose] = WasmRootWalletKeys.prototype.free;
 
-exports.UtxolibCompatNamespace = UtxolibCompatNamespace;
+exports.WasmRootWalletKeys = WasmRootWalletKeys;
 
 const WrapDescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1291,47 +2196,11 @@ exports.__wbg_Error_e17e777aac105295 = function(arg0, arg1) {
     return addHeapObject(ret);
 };
 
-exports.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
-    const ret = getObject(arg0).call(getObject(arg1));
-    return addHeapObject(ret);
-}, arguments) };
-
-exports.__wbg_from_88bc52ce20ba6318 = function(arg0) {
-    const ret = Array.from(getObject(arg0));
-    return addHeapObject(ret);
-};
-
-exports.__wbg_get_0da715ceaecea5c8 = function(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
-    return addHeapObject(ret);
-};
-
 exports.__wbg_get_458e874b43b18b25 = function() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(getObject(arg0), getObject(arg1));
     return addHeapObject(ret);
 }, arguments) };
 
-exports.__wbg_instanceof_Uint8Array_9a8378d955933db7 = function(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof Uint8Array;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-};
-
-exports.__wbg_isArray_030cce220591fb41 = function(arg0) {
-    const ret = Array.isArray(getObject(arg0));
-    return ret;
-};
-
-exports.__wbg_length_186546c51cd61acd = function(arg0) {
-    const ret = getObject(arg0).length;
-    return ret;
-};
-
 exports.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
     const ret = getObject(arg0).length;
     return ret;
@@ -1376,22 +2245,11 @@ exports.__wbg_set_453345bcda80b89a = function() { return handleError(function (a
     return ret;
 }, arguments) };
 
-exports.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
-    const ret = typeof(getObject(arg0)) === 'function';
-    return ret;
-};
-
 exports.__wbg_wbindgenisnull_f3037694abe4d97a = function(arg0) {
     const ret = getObject(arg0) === null;
     return ret;
 };
 
-exports.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
-    const val = getObject(arg0);
-    const ret = typeof(val) === 'object' && val !== null;
-    return ret;
-};
-
 exports.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
     const ret = getObject(arg0) === undefined;
     return ret;