@bitgo/wasm-utxo 1.7.0 → 1.9.0

package/dist/esm/js/fixedScriptWallet/BitGoPsbt.js

@@ -96,6 +96,64 @@ export class BitGoPsbt {
         const wasmECPair = ECPair.from(key).wasm;
         return this.wasm.verify_signature_with_pub(inputIndex, wasmECPair);
     }
+    /**
+     * Sign a single input with a private key
+     *
+     * This method signs a specific input using the provided key. It accepts either:
+     * - An xpriv (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32) for wallet inputs - derives the key and signs
+     * - A raw privkey (ECPairArg: Buffer, ECPair instance, or WasmECPair) for replay protection inputs - signs directly
+     *
+     * 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 generateMusig2Nonces()
+     * - For replay protection inputs: signs with legacy P2SH sighash
+     *
+     * @param inputIndex - The index of the input to sign (0-based)
+     * @param key - Either an xpriv (BIP32Arg) or a raw privkey (ECPairArg)
+     * @throws Error if signing fails, or if generateMusig2Nonces() was not called first for MuSig2 inputs
+     *
+     * @example
+     * ```typescript
+     * // Parse transaction to identify input types
+     * const parsed = psbt.parseTransactionWithWalletKeys(walletKeys, replayProtection);
+     *
+     * // Sign regular wallet inputs with xpriv
+     * for (let i = 0; i < parsed.inputs.length; i++) {
+     *   const input = parsed.inputs[i];
+     *   if (input.scriptId !== null && input.scriptType !== "p2shP2pk") {
+     *     psbt.sign(i, userXpriv);
+     *   }
+     * }
+     *
+     * // Sign replay protection inputs with raw privkey
+     * const userPrivkey = bip32.fromBase58(userXpriv).privateKey!;
+     * for (let i = 0; i < parsed.inputs.length; i++) {
+     *   const input = parsed.inputs[i];
+     *   if (input.scriptType === "p2shP2pk") {
+     *     psbt.sign(i, userPrivkey);
+     *   }
+     * }
+     * ```
+     */
+    sign(inputIndex, key) {
+        // Detect key type
+        // If string or has 'derive' method → BIP32Arg
+        // Otherwise → ECPairArg
+        if (typeof key === "string" ||
+            (typeof key === "object" &&
+                key !== null &&
+                "derive" in key &&
+                typeof key.derive === "function")) {
+            // It's a BIP32Arg
+            const wasmKey = BIP32.from(key);
+            this.wasm.sign_with_xpriv(inputIndex, wasmKey.wasm);
+        }
+        else {
+            // It's an ECPairArg
+            const wasmKey = ECPair.from(key);
+            this.wasm.sign_with_privkey(inputIndex, wasmKey.wasm);
+        }
+    }
     /**
      * @deprecated - use verifySignature with the replay protection key instead
      *
@@ -128,6 +186,70 @@ export class BitGoPsbt {
     serialize() {
         return this.wasm.serialize();
     }
+    /**
+     * 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, you can sign MuSig2 inputs using
+     * sign().
+     *
+     * @param key - The extended private key (xpriv) for signing. Can be a base58 string, BIP32 instance, or WasmBIP32
+     * @param sessionId - 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.
+     * @throws Error if nonce generation fails, sessionId length is invalid, or custom sessionId is
+     *         provided on a mainnet (security restriction)
+     *
+     * @security The sessionId MUST be cryptographically random and unique for each signing session.
+     * Never reuse a sessionId with the same key! On mainnets, sessionId is always randomly
+     * generated for security. Custom sessionId is only allowed on testnets for testing purposes.
+     *
+     * @example
+     * ```typescript
+     * // Phase 1: Both parties generate nonces (with auto-generated session ID)
+     * psbt.generateMusig2Nonces(userXpriv);
+     * // Nonces are stored in the PSBT
+     * // Send PSBT to counterparty
+     *
+     * // Phase 2: After receiving counterparty PSBT with their nonces
+     * const counterpartyPsbt = BitGoPsbt.fromBytes(counterpartyPsbtBytes, network);
+     * psbt.combineMusig2Nonces(counterpartyPsbt);
+     * // Sign MuSig2 key path inputs
+     * const parsed = psbt.parseTransactionWithWalletKeys(walletKeys, replayProtection);
+     * for (let i = 0; i < parsed.inputs.length; i++) {
+     *   if (parsed.inputs[i].scriptType === "p2trMusig2KeyPath") {
+     *     psbt.sign(i, userXpriv);
+     *   }
+     * }
+     * ```
+     */
+    generateMusig2Nonces(key, sessionId) {
+        const wasmKey = BIP32.from(key);
+        this.wasm.generate_musig2_nonces(wasmKey.wasm, sessionId);
+    }
+    /**
+     * 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.
+     *
+     * @param sourcePsbt - The source PSBT containing data to merge
+     * @throws Error if networks don't match
+     *
+     * @example
+     * ```typescript
+     * // After receiving counterparty's PSBT with their nonces
+     * const counterpartyPsbt = BitGoPsbt.fromBytes(counterpartyPsbtBytes, network);
+     * psbt.combineMusig2Nonces(counterpartyPsbt);
+     * // Now can sign with all nonces present
+     * psbt.sign(0, userXpriv);
+     * ```
+     */
+    combineMusig2Nonces(sourcePsbt) {
+        this.wasm.combine_musig2_nonces(sourcePsbt.wasm);
+    }
     /**
      * Finalize all inputs in the PSBT
      *

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

@@ -19,6 +19,46 @@ export class BitGoPsbt {
    * Get the unsigned transaction ID
    */
   unsigned_txid(): string;
+  /**
+   * Sign a single input with an extended private key (xpriv)
+   *
+   * This method signs a specific input using the provided xpriv. It accepts:
+   * - An xpriv (WasmBIP32) for wallet inputs - derives the key and signs
+   *
+   * This method automatically detects and handles different input types:
+   * - For regular inputs: uses standard PSBT signing
+   * - For MuSig2 inputs: uses the FirstRound state stored by generate_musig2_nonces()
+   * - For replay protection inputs: returns error (use sign_with_privkey instead)
+   *
+   * # Arguments
+   * - `input_index`: The index of the input to sign (0-based)
+   * - `xpriv`: The extended private key as a WasmBIP32 instance
+   *
+   * # Returns
+   * - `Ok(())` if signing was successful
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_with_xpriv(input_index: number, xpriv: WasmBIP32): void;
+  /**
+   * 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
+   */
+  sign_with_privkey(input_index: number, ecpair: WasmECPair): void;
   /**
    * Extract the final transaction from a finalized PSBT
    *
@@ -41,6 +81,52 @@ export class BitGoPsbt {
    * - `Err(WasmUtxoError)` if any input failed to finalize
    */
   finalize_all_inputs(): void;
+  /**
+   * 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
+   */
+  combine_musig2_nonces(source_psbt: BitGoPsbt): void;
+  /**
+   * 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.
+   */
+  generate_musig2_nonces(xpriv: WasmBIP32, session_id_bytes?: Uint8Array | null): void;
   /**
    * Verify if a valid signature exists for a given ECPair key at the specified input index
    *

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