@bitgo/wasm-utxo 5.2.0 → 5.4.0

package/README.md

@@ -7,6 +7,7 @@ that help verify and co-sign transactions built by the BitGo Wallet Platform API
 
 ## Documentation
 
+- **[`../../CONVENTIONS.md`](../../CONVENTIONS.md)** - Repository-wide API and structured-error conventions
 - **[`src/wasm-bindgen.md`](src/wasm-bindgen.md)** - Guide for creating WASM bindings using the namespace pattern
 - **[`js/README.md`](js/README.md)** - TypeScript wrapper layer architecture and best practices
 - **[`cli/README.md`](cli/README.md)** - Command-line interface for address and PSBT operations

package/dist/cjs/js/fixedScriptWallet/ZcashIronwoodBitGoPsbt.d.ts

@@ -249,6 +249,31 @@ export declare class ZcashIronwoodBitGoPsbt extends ZcashBitGoPsbt {
      * {@link sign} (all matching inputs) instead.
      */
     sign(inputIndex: number, key: BIP32Arg | ECPairArg): void;
+    /**
+     * Check whether transparent input `inputIndex` carries a valid signature by `key`, over the
+     * ZIP-244 transparent sighash — the digest v6 (Ironwood) keys actually sign (see
+     * {@link transparentSighash}). The inherited `BitGoPsbt.verifySignature` digests ZIP-243
+     * (Sapling) instead, so it would report `false` for a valid v6 signature; this override routes
+     * to the v6 sighash path instead.
+     *
+     * Mirrors the inherited signature: an xpub (BIP32Arg) resolves to a public key via the input's
+     * `bip32_derivation`; a raw key (ECPairArg) verifies with its public key directly.
+     *
+     * @param inputIndex - 0-based transparent input index
+     * @param key - the signing key: an xpub (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32)
+     *   or an ECPairArg (Uint8Array, ECPair instance, or WasmECPair)
+     * @returns true if a valid signature by the key's public key exists for the input's
+     *   ZIP-244 transparent sighash
+     * @throws Error if the input index is out of range, the key cannot be parsed, or the v6
+     *   sighash cannot be computed (e.g. the Ironwood PCZT has not been added yet)
+     *
+     * @example
+     * ```typescript
+     * // Verify the user's signature over the v6 transparent sighash
+     * const hasUserSig = psbt.verifySignature(0, userXpub);
+     * ```
+     */
+    verifySignature(inputIndex: number, key: BIP32Arg | ECPairArg): boolean;
     /**
      * Transaction Extractor role: given the external prover's `proof` bytes, finalize the
      * transparent inputs, apply the shielded binding signature, and return the broadcast-ready v6

package/dist/cjs/js/fixedScriptWallet/ZcashIronwoodBitGoPsbt.js

@@ -4,6 +4,7 @@ exports.ZcashIronwoodBitGoPsbt = void 0;
 exports.zip302NoMemo = zip302NoMemo;
 const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
 const bip32_js_1 = require("../bip32.js");
+const ecpair_js_1 = require("../ecpair.js");
 const RootWalletKeys_js_1 = require("./RootWalletKeys.js");
 const ZcashBitGoPsbt_js_1 = require("./ZcashBitGoPsbt.js");
 /**
@@ -242,6 +243,38 @@ class ZcashIronwoodBitGoPsbt extends ZcashBitGoPsbt_js_1.ZcashBitGoPsbt {
         const keys = RootWalletKeys_js_1.RootWalletKeys.from(keyOrRootWalletKeys);
         return Array.from(this.wasm.sign_ironwood_v6(wasmKey, keys.wasm), Number);
     }
+    /**
+     * Check whether transparent input `inputIndex` carries a valid signature by `key`, over the
+     * ZIP-244 transparent sighash — the digest v6 (Ironwood) keys actually sign (see
+     * {@link transparentSighash}). The inherited `BitGoPsbt.verifySignature` digests ZIP-243
+     * (Sapling) instead, so it would report `false` for a valid v6 signature; this override routes
+     * to the v6 sighash path instead.
+     *
+     * Mirrors the inherited signature: an xpub (BIP32Arg) resolves to a public key via the input's
+     * `bip32_derivation`; a raw key (ECPairArg) verifies with its public key directly.
+     *
+     * @param inputIndex - 0-based transparent input index
+     * @param key - the signing key: an xpub (BIP32Arg: base58 string, BIP32 instance, or WasmBIP32)
+     *   or an ECPairArg (Uint8Array, ECPair instance, or WasmECPair)
+     * @returns true if a valid signature by the key's public key exists for the input's
+     *   ZIP-244 transparent sighash
+     * @throws Error if the input index is out of range, the key cannot be parsed, or the v6
+     *   sighash cannot be computed (e.g. the Ironwood PCZT has not been added yet)
+     *
+     * @example
+     * ```typescript
+     * // Verify the user's signature over the v6 transparent sighash
+     * const hasUserSig = psbt.verifySignature(0, userXpub);
+     * ```
+     */
+    verifySignature(inputIndex, key) {
+        if ((0, bip32_js_1.isBIP32Arg)(key)) {
+            return this.wasm.verify_ironwood_v6_signature_with_xpub(inputIndex, bip32_js_1.BIP32.from(key).wasm);
+        }
+        // Otherwise it's an ECPairArg (Uint8Array, ECPair, or WasmECPair)
+        const wasmECPair = ecpair_js_1.ECPair.from(key).wasm;
+        return this.wasm.verify_ironwood_v6_signature_with_pub(inputIndex, wasmECPair);
+    }
     /**
      * Transaction Extractor role: given the external prover's `proof` bytes, finalize the
      * transparent inputs, apply the shielded binding signature, and return the broadcast-ready v6

package/dist/cjs/js/fixedScriptWallet/ZcashIronwoodWitness.d.ts

@@ -1,4 +1,20 @@
 import { IronwoodWitness as WasmIronwoodWitness } from "../wasm/wasm_utxo.js";
+/**
+ * A node of a pruned Orchard note-commitment (sub)tree, for {@link ZcashIronwoodWitness.buildFromShard}'s
+ * `shard`/`cap` inputs. Mirrors a real pruned tree store's shape (e.g. a `shardtree::ShardTree`):
+ * most leaves are never individually retained, only enough annotated hashes to reproduce a witness.
+ */
+export type ShardTreeNode = {
+    type: "Nil";
+} | {
+    type: "Leaf";
+    hash: Uint8Array;
+} | {
+    type: "Parent";
+    hash?: Uint8Array;
+    left: ShardTreeNode;
+    right: ShardTreeNode;
+};
 /**
  * A validated Merkle witness for an Ironwood/Orchard note commitment.
  *
@@ -19,6 +35,19 @@ export declare class ZcashIronwoodWitness {
      *   recompute to `anchor`
      */
     static build(cmx: Uint8Array, position: number, authPath: Uint8Array[], anchor: Uint8Array): ZcashIronwoodWitness;
+    /**
+     * Build and validate a Merkle witness from a pruned shard + cap, instead of a
+     * caller-precomputed 32-entry path.
+     *
+     * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+     * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is
+     * the pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is
+     * the total number of leaves committed to the tree as of `anchor` — positions beyond it are
+     * treated as canonically empty.
+     * @throws Under the same conditions as {@link build}, plus if `shard`/`cap` don't have enough
+     *   detail to witness `position` as of `leafCount`
+     */
+    static buildFromShard(position: number, shardHeight: number, leafCount: bigint, cmx: Uint8Array, shard: ShardTreeNode, cap: ShardTreeNode, anchor: Uint8Array): ZcashIronwoodWitness;
     /** The leaf's position in the note commitment tree. */
     get position(): number;
     /**

package/dist/cjs/js/fixedScriptWallet/ZcashIronwoodWitness.js

@@ -26,6 +26,21 @@ class ZcashIronwoodWitness {
     static build(cmx, position, authPath, anchor) {
         return new ZcashIronwoodWitness((0, wasm_utxo_js_1.ironwood_build_witness)(cmx, position, authPath, anchor));
     }
+    /**
+     * Build and validate a Merkle witness from a pruned shard + cap, instead of a
+     * caller-precomputed 32-entry path.
+     *
+     * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+     * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is
+     * the pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is
+     * the total number of leaves committed to the tree as of `anchor` — positions beyond it are
+     * treated as canonically empty.
+     * @throws Under the same conditions as {@link build}, plus if `shard`/`cap` don't have enough
+     *   detail to witness `position` as of `leafCount`
+     */
+    static buildFromShard(position, shardHeight, leafCount, cmx, shard, cap, anchor) {
+        return new ZcashIronwoodWitness((0, wasm_utxo_js_1.ironwood_build_witness_from_shard)(position, shardHeight, leafCount, cmx, shard, cap, anchor));
+    }
     /** The leaf's position in the note commitment tree. */
     get position() {
         return this._wasm.position;

package/dist/cjs/js/fixedScriptWallet/index.d.ts

@@ -14,6 +14,7 @@ export { ZcashIronwoodBitGoPsbt, zip302NoMemo, type CreateEmptyIronwoodOptions,
 export { ZcashUnifiedAddress } from "./ZcashUnifiedAddress.js";
 export { ZcashV6Transaction } from "./ZcashV6Transaction.js";
 export { ZcashIronwoodWitness } from "./ZcashIronwoodWitness.js";
+export type { ShardTreeNode } from "./ZcashIronwoodWitness.js";
 import type { ScriptType } from "./scriptType.js";
 /**
  * Check if a network supports a given fixed-script wallet script type

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

@@ -813,6 +813,22 @@ export class BitGoPsbt {
      */
     transparent_output_unified_address(index: number): string | undefined;
     unsigned_tx_id(): string;
+    /**
+     * Verify if a valid signature exists for a given ECPair key at the specified input index,
+     * computed over the ZIP-244 v6 (Ironwood) transparent sighash — the v6 (Ironwood)
+     * counterpart to `verify_signature_with_pub`, which digests ZIP-243 (Sapling) and would
+     * report `Ok(false)` for a valid v6 signature. Only v6 (Ironwood) Zcash PSBTs are
+     * supported.
+     */
+    verify_ironwood_v6_signature_with_pub(input_index: number, ecpair: WasmECPair): boolean;
+    /**
+     * Verify if a valid signature exists for an extended public key at the specified input
+     * index, computed over the ZIP-244 v6 (Ironwood) transparent sighash — the v6 (Ironwood)
+     * counterpart to `verify_signature_with_xpub`, which digests ZIP-243 (Sapling) and would
+     * report `Ok(false)` for a valid v6 signature. Only v6 (Ironwood) Zcash PSBTs are
+     * supported.
+     */
+    verify_ironwood_v6_signature_with_xpub(input_index: number, xpub: WasmBIP32): boolean;
     /**
      * Verify if a replay protection input has a valid signature
      *
@@ -1908,6 +1924,23 @@ export class ZcashV6Transaction {
  */
 export function ironwood_build_witness(cmx: Uint8Array, position: number, auth_path: Uint8Array[], anchor: Uint8Array): IronwoodWitness;
 
+/**
+ * Build and validate an Ironwood witness from a pruned shard + cap, instead of a
+ * caller-precomputed 32-entry path (see `ironwood_build_witness`).
+ *
+ * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+ * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is the
+ * pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is the
+ * total number of leaves committed to the tree as of `anchor` — positions beyond it are treated
+ * as canonically empty. `shard`/`cap` are plain JS objects (not JSON strings) shaped like:
+ * `{ type: "Nil" } | { type: "Leaf", hash: Uint8Array } | { type: "Parent", hash?: Uint8Array,
+ * left: ShardTreeNode, right: ShardTreeNode }`.
+ *
+ * Throws under the same conditions as `ironwood_build_witness`, plus if `shard`/`cap` don't have
+ * enough detail to witness `position` as of `leafCount`.
+ */
+export function ironwood_build_witness_from_shard(position: number, shard_height: number, leaf_count: bigint, cmx: Uint8Array, shard: any, cap: any, anchor: Uint8Array): IronwoodWitness;
+
 /**
  * Check if the inspect feature is enabled.
  *

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

@@ -2681,6 +2681,58 @@ class BitGoPsbt {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Verify if a valid signature exists for a given ECPair key at the specified input index,
+     * computed over the ZIP-244 v6 (Ironwood) transparent sighash — the v6 (Ironwood)
+     * counterpart to `verify_signature_with_pub`, which digests ZIP-243 (Sapling) and would
+     * report `Ok(false)` for a valid v6 signature. Only v6 (Ironwood) Zcash PSBTs are
+     * supported.
+     * @param {number} input_index
+     * @param {WasmECPair} ecpair
+     * @returns {boolean}
+     */
+    verify_ironwood_v6_signature_with_pub(input_index, ecpair) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            wasm.bitgopsbt_verify_ironwood_v6_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 an extended public key at the specified input
+     * index, computed over the ZIP-244 v6 (Ironwood) transparent sighash — the v6 (Ironwood)
+     * counterpart to `verify_signature_with_xpub`, which digests ZIP-243 (Sapling) and would
+     * report `Ok(false)` for a valid v6 signature. Only v6 (Ironwood) Zcash PSBTs are
+     * supported.
+     * @param {number} input_index
+     * @param {WasmBIP32} xpub
+     * @returns {boolean}
+     */
+    verify_ironwood_v6_signature_with_xpub(input_index, xpub) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpub, WasmBIP32);
+            wasm.bitgopsbt_verify_ironwood_v6_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);
+        }
+    }
     /**
      * Verify if a replay protection input has a valid signature
      *
@@ -7217,6 +7269,50 @@ function ironwood_build_witness(cmx, position, auth_path, anchor) {
 }
 exports.ironwood_build_witness = ironwood_build_witness;
 
+/**
+ * Build and validate an Ironwood witness from a pruned shard + cap, instead of a
+ * caller-precomputed 32-entry path (see `ironwood_build_witness`).
+ *
+ * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+ * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is the
+ * pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is the
+ * total number of leaves committed to the tree as of `anchor` — positions beyond it are treated
+ * as canonically empty. `shard`/`cap` are plain JS objects (not JSON strings) shaped like:
+ * `{ type: "Nil" } | { type: "Leaf", hash: Uint8Array } | { type: "Parent", hash?: Uint8Array,
+ * left: ShardTreeNode, right: ShardTreeNode }`.
+ *
+ * Throws under the same conditions as `ironwood_build_witness`, plus if `shard`/`cap` don't have
+ * enough detail to witness `position` as of `leafCount`.
+ * @param {number} position
+ * @param {number} shard_height
+ * @param {bigint} leaf_count
+ * @param {Uint8Array} cmx
+ * @param {any} shard
+ * @param {any} cap
+ * @param {Uint8Array} anchor
+ * @returns {IronwoodWitness}
+ */
+function ironwood_build_witness_from_shard(position, shard_height, leaf_count, cmx, shard, cap, anchor) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(cmx, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(anchor, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ironwood_build_witness_from_shard(retptr, position, shard_height, leaf_count, ptr0, len0, addHeapObject(shard), addHeapObject(cap), 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 IronwoodWitness.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.ironwood_build_witness_from_shard = ironwood_build_witness_from_shard;
+
 /**
  * Check if the inspect feature is enabled.
  *
@@ -7550,6 +7646,13 @@ function __wbg_get_imports() {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         },
+        __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+            const ret = String(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
             const v = getObject(arg1);
             const ret = typeof(v) === 'bigint' ? v : undefined;
@@ -7568,6 +7671,10 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
+            const ret = getObject(arg0) in getObject(arg1);
+            return ret;
+        },
         __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'bigint';
             return ret;
@@ -7597,6 +7704,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0) === getObject(arg1);
             return ret;
         },
+        __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
+            const ret = getObject(arg0) == getObject(arg1);
+            return ret;
+        },
         __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
             const obj = getObject(arg1);
             const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -7626,6 +7737,14 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).crypto;
             return addHeapObject(ret);
         },
+        __wbg_done_57b39ecd9addfe81: function(arg0) {
+            const ret = getObject(arg0).done;
+            return ret;
+        },
+        __wbg_entries_58c7934c745daac7: function(arg0) {
+            const ret = Object.entries(getObject(arg0));
+            return addHeapObject(ret);
+        },
         __wbg_for_c3adefd268cb6f1c: function(arg0, arg1) {
             const ret = Symbol.for(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -7645,6 +7764,48 @@ function __wbg_get_imports() {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_53af74335dec57f4: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_d314bb98fcf08331: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
+            const ret = Number.isSafeInteger(getObject(arg0));
+            return ret;
+        },
+        __wbg_iterator_6ff6560ca1568e55: function() {
+            const ret = Symbol.iterator;
+            return addHeapObject(ret);
+        },
         __wbg_length_32ed9a279acd054c: function(arg0) {
             const ret = getObject(arg0).length;
             return ret;
@@ -7685,6 +7846,14 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(arg0 >>> 0);
             return addHeapObject(ret);
         },
+        __wbg_next_3482f54c49e8af19: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).next();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_next_418f80d8f5303233: function(arg0) {
+            const ret = getObject(arg0).next;
+            return addHeapObject(ret);
+        },
         __wbg_node_905d3e251edff8a2: function(arg0) {
             const ret = getObject(arg0).node;
             return addHeapObject(ret);
@@ -7731,6 +7900,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
             return addHeapObject(ret);
         },
+        __wbg_value_0546255b415e96c1: function(arg0) {
+            const ret = getObject(arg0).value;
+            return addHeapObject(ret);
+        },
         __wbg_versions_c01dfd4722a88165: function(arg0) {
             const ret = getObject(arg0).versions;
             return addHeapObject(ret);
@@ -7760,17 +7933,22 @@ function __wbg_get_imports() {
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000004: function(arg0) {
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return addHeapObject(ret);