@bitgo/wasm-utxo 1.6.0 → 1.8.0

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

@@ -64,6 +64,18 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
@@ -131,18 +143,6 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -150,12 +150,30 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function _assertClass(instance, klass) {
     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;
+}
+
 const AddressNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_addressnamespace_free(ptr >>> 0, 1));
@@ -310,37 +328,71 @@ export class BitGoPsbt {
         }
     }
     /**
-     * Verify if a valid signature exists for a given xpub at the specified input index
+     * Sign a single input with an extended private key (xpriv)
      *
-     * 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).
+     * This method signs a specific input using the provided xpriv. It accepts:
+     * - An xpriv (WasmBIP32) for wallet inputs - derives the key and signs
+     *
+     * This method automatically detects and handles different input types:
+     * - For regular inputs: uses standard PSBT signing
+     * - For MuSig2 inputs: uses the FirstRound state stored by generate_musig2_nonces()
+     * - For replay protection inputs: returns error (use sign_with_privkey instead)
      *
      * # Arguments
-     * - `input_index`: The index of the input to check
-     * - `xpub_str`: The extended public key as a base58-encoded string
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `xpriv`: The extended private 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
+     * - `Ok(())` if signing was successful
+     * - `Err(WasmUtxoError)` if signing fails
      * @param {number} input_index
-     * @param {string} xpub_str
-     * @returns {boolean}
+     * @param {WasmBIP32} xpriv
      */
-    verify_signature(input_index, xpub_str) {
+    sign_with_xpriv(input_index, xpriv) {
         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(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_with_xpriv(retptr, this.__wbg_ptr, input_index, xpriv.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign a single input with a raw private key
+     *
+     * This method signs a specific input using the provided ECPair. It accepts:
+     * - A raw privkey (WasmECPair) for replay protection inputs - signs directly
+     *
+     * This method automatically detects and handles different input types:
+     * - For replay protection inputs: signs with legacy P2SH sighash
+     * - For regular inputs: uses standard PSBT signing
+     * - For MuSig2 inputs: returns error (requires FirstRound, use sign_with_xpriv instead)
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `ecpair`: The ECPair containing the private key
+     *
+     * # Returns
+     * - `Ok(())` if signing was successful
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {number} input_index
+     * @param {WasmECPair} ecpair
+     */
+    sign_with_privkey(input_index, ecpair) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            wasm.bitgopsbt_sign_with_privkey(retptr, this.__wbg_ptr, input_index, ecpair.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
             }
-            return r0 !== 0;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -384,297 +436,1289 @@ export class BitGoPsbt {
      * - `Ok(())` if all inputs were successfully finalized
      * - `Err(WasmUtxoError)` if any input failed to finalize
      */
-    finalize_all_inputs() {
+    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);
+        }
+    }
+    /**
+     * Combine/merge data from another PSBT into this one
+     *
+     * This method copies MuSig2 nonces and signatures (proprietary key-value pairs) from the
+     * source PSBT to this PSBT. This is useful for merging PSBTs during the nonce exchange
+     * and signature collection phases.
+     *
+     * # Arguments
+     * * `source_psbt` - The source PSBT containing data to merge
+     *
+     * # Returns
+     * Ok(()) if data was successfully merged
+     *
+     * # Errors
+     * Returns error if networks don't match
+     * @param {BitGoPsbt} source_psbt
+     */
+    combine_musig2_nonces(source_psbt) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(source_psbt, BitGoPsbt);
+            wasm.bitgopsbt_combine_musig2_nonces(retptr, this.__wbg_ptr, source_psbt.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Generate and store MuSig2 nonces for all MuSig2 inputs
+     *
+     * This method generates nonces using the State-Machine API and stores them in the PSBT.
+     * The nonces are stored as proprietary fields in the PSBT and will be included when serialized.
+     * After ALL participants have generated their nonces, they can sign MuSig2 inputs using
+     * sign_with_xpriv().
+     *
+     * # Arguments
+     * * `xpriv` - The extended private key (xpriv) for signing
+     * * `session_id_bytes` - Optional 32-byte session ID for nonce generation. **Only allowed on testnets**.
+     *                        On mainnets, a secure random session ID is always generated automatically.
+     *                        Must be unique per signing session.
+     *
+     * # Returns
+     * Ok(()) if nonces were successfully generated and stored
+     *
+     * # Errors
+     * Returns error if:
+     * - Nonce generation fails
+     * - session_id length is invalid
+     * - Custom session_id is provided on a mainnet (security restriction)
+     *
+     * # Security
+     * The session_id MUST be cryptographically random and unique for each signing session.
+     * Never reuse a session_id with the same key! On mainnets, session_id is always randomly
+     * generated for security. Custom session_id is only allowed on testnets for testing purposes.
+     * @param {WasmBIP32} xpriv
+     * @param {Uint8Array | null} [session_id_bytes]
+     */
+    generate_musig2_nonces(xpriv, session_id_bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            var ptr0 = isLikeNone(session_id_bytes) ? 0 : passArray8ToWasm0(session_id_bytes, wasm.__wbindgen_export_1);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_generate_musig2_nonces(retptr, this.__wbg_ptr, xpriv.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify if a valid signature exists for a given ECPair key at the specified input index
+     *
+     * 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:
+     * - 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`: 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, derivation fails, or verification fails
+     * @param {number} input_index
+     * @param {WasmBIP32} xpub
+     * @returns {boolean}
+     */
+    verify_signature_with_xpub(input_index, xpub) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 !== 0;
+        } 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 {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(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;
+
+const FixedScriptWalletNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fixedscriptwalletnamespace_free(ptr >>> 0, 1));
+
+export 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}
+     */
+    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;
+
+const UtxolibCompatNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_utxolibcompatnamespace_free(ptr >>> 0, 1));
+
+export 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;
+
+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
+ */
+export 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;
+
+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)
+ */
+export 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.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);
+            }
+            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 public key (always uses compressed keys)
+     * @param {Uint8Array} public_key
+     * @returns {WasmECPair}
+     */
+    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;
 
-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
+ */
+export class WasmReplayProtection {
 
-export 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;
 
-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
+ */
+export class WasmRootWalletKeys {
 
-export 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;
 
 const WrapDescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1292,45 +2336,33 @@ export function __wbg_call_13410aac570ffff7() { return handleError(function (arg
     return addHeapObject(ret);
 }, arguments) };
 
-export function __wbg_from_88bc52ce20ba6318(arg0) {
-    const ret = Array.from(getObject(arg0));
+export function __wbg_call_a5400b25a865cfd8() { return handleError(function (arg0, arg1, arg2) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
     return addHeapObject(ret);
-};
+}, arguments) };
 
-export function __wbg_get_0da715ceaecea5c8(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
+export function __wbg_crypto_574e78ad8b13b65f(arg0) {
+    const ret = getObject(arg0).crypto;
     return addHeapObject(ret);
 };
 
+export function __wbg_getRandomValues_b8f5dbd5f3995a9e() { return handleError(function (arg0, arg1) {
+    getObject(arg0).getRandomValues(getObject(arg1));
+}, arguments) };
+
 export function __wbg_get_458e874b43b18b25() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(getObject(arg0), getObject(arg1));
     return addHeapObject(ret);
 }, arguments) };
 
-export function __wbg_instanceof_Uint8Array_9a8378d955933db7(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof Uint8Array;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-};
-
-export function __wbg_isArray_030cce220591fb41(arg0) {
-    const ret = Array.isArray(getObject(arg0));
-    return ret;
-};
-
-export function __wbg_length_186546c51cd61acd(arg0) {
+export function __wbg_length_6bb7e81f9d7713e4(arg0) {
     const ret = getObject(arg0).length;
     return ret;
 };
 
-export function __wbg_length_6bb7e81f9d7713e4(arg0) {
-    const ret = getObject(arg0).length;
-    return ret;
+export function __wbg_msCrypto_a61aeb35a24c1329(arg0) {
+    const ret = getObject(arg0).msCrypto;
+    return addHeapObject(ret);
 };
 
 export function __wbg_new_19c25a3f2fa63a02() {
@@ -1358,6 +2390,26 @@ export function __wbg_newfromslice_074c56947bd43469(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+export function __wbg_newnoargs_254190557c45b4ec(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_newwithlength_a167dcc7aaa3ba77(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_node_905d3e251edff8a2(arg0) {
+    const ret = getObject(arg0).node;
+    return addHeapObject(ret);
+};
+
+export function __wbg_process_dc0fbacc7c1c06f7(arg0) {
+    const ret = getObject(arg0).process;
+    return addHeapObject(ret);
+};
+
 export function __wbg_prototypesetcall_3d4a26c1ed734349(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 };
@@ -1367,11 +2419,50 @@ export function __wbg_push_330b2eb93e4e1212(arg0, arg1) {
     return ret;
 };
 
+export function __wbg_randomFillSync_ac0988aba3254290() { return handleError(function (arg0, arg1) {
+    getObject(arg0).randomFillSync(takeObject(arg1));
+}, arguments) };
+
+export function __wbg_require_60cc747a6bc5215a() { return handleError(function () {
+    const ret = module.require;
+    return addHeapObject(ret);
+}, arguments) };
+
 export function __wbg_set_453345bcda80b89a() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
     return ret;
 }, arguments) };
 
+export function __wbg_static_accessor_GLOBAL_8921f820c2ce3f12() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_GLOBAL_THIS_f0a4409105898184() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_SELF_995b214ae681ff99() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_WINDOW_cde3890479c675ea() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_subarray_70fd07feefe14294(arg0, arg1, arg2) {
+    const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_versions_c01dfd4722a88165(arg0) {
+    const ret = getObject(arg0).versions;
+    return addHeapObject(ret);
+};
+
 export function __wbg_wbindgenisfunction_8cee7dce3725ae74(arg0) {
     const ret = typeof(getObject(arg0)) === 'function';
     return ret;
@@ -1388,6 +2479,11 @@ export function __wbg_wbindgenisobject_307a53c6bd97fbf8(arg0) {
     return ret;
 };
 
+export function __wbg_wbindgenisstring_d4fa939789f003b0(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+};
+
 export function __wbg_wbindgenisundefined_c4b71d073b92f3c5(arg0) {
     const ret = getObject(arg0) === undefined;
     return ret;
@@ -1425,6 +2521,12 @@ export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
     return addHeapObject(ret);
 };
 
+export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
 export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;