@provablehq/wasm 0.10.3 → 0.10.5-rc.1

package/dist/testnet/index.js

@@ -471,16 +471,16 @@ function getArrayJsValueFromWasm0(ptr, len) {
     }
     return result;
 }
-function __wasm_bindgen_func_elem_8534(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_8534(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_8577(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_8577(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_7173(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_7173(arg0, arg1);
+function __wasm_bindgen_func_elem_7220(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_7220(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_7446(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_7446(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_7492(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_7492(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
@@ -2223,6 +2223,48 @@ class Boolean {
 }
 if (Symbol.dispose) Boolean.prototype[Symbol.dispose] = Boolean.prototype.free;
 
+const CallbackQueryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_callbackquery_free(ptr >>> 0, 1));
+/**
+ * A query implementation that delegates state fetching to JS callback functions.
+ *
+ * Instead of making direct HTTP calls via reqwest, each QueryTrait method
+ * calls a JS function that returns a Promise. The JS side handles the actual
+ * network request through the configured transport.
+ */
+class CallbackQuery {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CallbackQueryFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_callbackquery_free(ptr, 0);
+    }
+    /**
+     * Create a new CallbackQuery with JS callback functions.
+     *
+     * @param {Function} get_state_root A function that returns Promise<string> (the state root)
+     * @param {Function} get_state_paths A function that takes string[] (commitments) and returns Promise<string[]> (state paths)
+     * @param {Function} get_block_height A function that returns Promise<number> (the block height)
+     * @param {Function} get_state_root
+     * @param {Function} get_state_paths
+     * @param {Function} get_block_height
+     */
+    constructor(get_state_root, get_state_paths, get_block_height) {
+        const ret = wasm.callbackquery_new(addHeapObject(get_state_root), addHeapObject(get_state_paths), addHeapObject(get_block_height));
+        this.__wbg_ptr = ret >>> 0;
+        CallbackQueryFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) CallbackQuery.prototype[Symbol.dispose] = CallbackQuery.prototype.free;
+
 const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr >>> 0, 1));
@@ -9870,6 +9912,16 @@ class Program {
         const ret = wasm.program_getImports(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * Get the checksum of the program.
+     *
+     * @returns {Uint8Array} The checksum of the program as a 32-byte Uint8Array
+     * @returns {Uint8Array}
+     */
+    toChecksum() {
+        const ret = wasm.program_toChecksum(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get a the list of a program's mappings and the names/types of their keys and values.
      *
@@ -10357,10 +10409,10 @@ class ProgramManager {
      * @param {VerifyingKey | null} [join_verifying_key]
      * @param {ProvingKey | null} [fee_proving_key]
      * @param {VerifyingKey | null} [fee_verifying_key]
-     * @param {OfflineQuery | null} [offline_query]
+     * @param {QueryOption | null} [query]
      * @returns {Promise<Transaction>}
      */
-    static buildJoinTransaction(private_key, record_1, record_2, priority_fee_credits, fee_record, url, join_proving_key, join_verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
+    static buildJoinTransaction(private_key, record_1, record_2, priority_fee_credits, fee_record, url, join_proving_key, join_verifying_key, fee_proving_key, fee_verifying_key, query) {
         _assertClass(private_key, PrivateKey);
         _assertClass(record_1, RecordPlaintext);
         var ptr0 = record_1.__destroy_into_raw();
@@ -10394,9 +10446,9 @@ class ProgramManager {
             ptr7 = fee_verifying_key.__destroy_into_raw();
         }
         let ptr8 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr8 = offline_query.__destroy_into_raw();
+        if (!isLikeNone(query)) {
+            _assertClass(query, QueryOption);
+            ptr8 = query.__destroy_into_raw();
         }
         const ret = wasm.programmanager_buildJoinTransaction(private_key.__wbg_ptr, ptr0, ptr1, priority_fee_credits, ptr2, ptr3, len3, ptr4, ptr5, ptr6, ptr7, ptr8);
         return takeObject(ret);
@@ -10418,10 +10470,10 @@ class ProgramManager {
      * @param {string | null} [url]
      * @param {ProvingKey | null} [split_proving_key]
      * @param {VerifyingKey | null} [split_verifying_key]
-     * @param {OfflineQuery | null} [offline_query]
+     * @param {QueryOption | null} [query]
      * @returns {Promise<Transaction>}
      */
-    static buildSplitTransaction(private_key, split_amount, amount_record, url, split_proving_key, split_verifying_key, offline_query) {
+    static buildSplitTransaction(private_key, split_amount, amount_record, url, split_proving_key, split_verifying_key, query) {
         _assertClass(private_key, PrivateKey);
         _assertClass(amount_record, RecordPlaintext);
         var ptr0 = amount_record.__destroy_into_raw();
@@ -10438,9 +10490,9 @@ class ProgramManager {
             ptr3 = split_verifying_key.__destroy_into_raw();
         }
         let ptr4 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr4 = offline_query.__destroy_into_raw();
+        if (!isLikeNone(query)) {
+            _assertClass(query, QueryOption);
+            ptr4 = query.__destroy_into_raw();
         }
         const ret = wasm.programmanager_buildSplitTransaction(private_key.__wbg_ptr, split_amount, ptr0, ptr1, len1, ptr2, ptr3, ptr4);
         return takeObject(ret);
@@ -10793,10 +10845,10 @@ class ProgramManager {
      * @param {VerifyingKey | null} [fee_verifying_key]
      * @param {object | null} [imports]
      * @param {string | null} [url]
-     * @param {OfflineQuery | null} [offline_query]
+     * @param {QueryOption | null} [query]
      * @returns {Promise<Transaction>}
      */
-    static executeAuthorization(authorization, fee_authorization, program, proving_key, verifying_key, fee_proving_key, fee_verifying_key, imports, url, offline_query) {
+    static executeAuthorization(authorization, fee_authorization, program, proving_key, verifying_key, fee_proving_key, fee_verifying_key, imports, url, query) {
         _assertClass(authorization, Authorization);
         var ptr0 = authorization.__destroy_into_raw();
         let ptr1 = 0;
@@ -10829,9 +10881,9 @@ class ProgramManager {
         var ptr7 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         var len7 = WASM_VECTOR_LEN;
         let ptr8 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr8 = offline_query.__destroy_into_raw();
+        if (!isLikeNone(query)) {
+            _assertClass(query, QueryOption);
+            ptr8 = query.__destroy_into_raw();
         }
         const ret = wasm.programmanager_executeAuthorization(ptr0, ptr1, ptr2, len2, ptr3, ptr4, ptr5, ptr6, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr7, len7, ptr8);
         return takeObject(ret);
@@ -10902,11 +10954,11 @@ class ProgramManager {
      * @param {ProvingKey | null} [proving_key]
      * @param {VerifyingKey | null} [verifying_key]
      * @param {string | null} [url]
-     * @param {OfflineQuery | null} [offline_query]
+     * @param {QueryOption | null} [query]
      * @param {number | null} [edition]
      * @returns {Promise<ExecutionResponse>}
      */
-    static executeFunctionOffline(private_key, program, _function, inputs, prove_execution, cache, imports, proving_key, verifying_key, url, offline_query, edition) {
+    static executeFunctionOffline(private_key, program, _function, inputs, prove_execution, cache, imports, proving_key, verifying_key, url, query, edition) {
         _assertClass(private_key, PrivateKey);
         const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
@@ -10925,13 +10977,60 @@ class ProgramManager {
         var ptr4 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         var len4 = WASM_VECTOR_LEN;
         let ptr5 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr5 = offline_query.__destroy_into_raw();
+        if (!isLikeNone(query)) {
+            _assertClass(query, QueryOption);
+            ptr5 = query.__destroy_into_raw();
         }
         const ret = wasm.programmanager_executeFunctionOffline(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), prove_execution, cache, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr2, ptr3, ptr4, len4, ptr5, isLikeNone(edition) ? 0xFFFFFF : edition);
         return takeObject(ret);
     }
+    /**
+     * Compute the query requirements for a function execution without making
+     * any network calls. Returns the commitments that need state paths and
+     * whether the function has dynamic record inputs.
+     *
+     * This enables the JS layer to pre-fetch state data via its configured
+     * transport and construct an OfflineQuery, so that the subsequent WASM
+     * execution call never makes its own network requests.
+     *
+     * @param {string} program The source code of the program
+     * @param {string} function_name The name of the function to execute
+     * @param {Array} inputs The inputs to the function
+     * @param {PrivateKey} private_key The private key (used to derive the view key for commitment computation)
+     * @param {RecordPlaintext | undefined} fee_record Optional fee record to include in commitment computation
+     * @returns {Object} An object with { commitments: string[], hasDynamicInputs: boolean }
+     * @param {string} program
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {PrivateKey} private_key
+     * @param {RecordPlaintext | null} [fee_record]
+     * @returns {any}
+     */
+    static computeQueryRequirements(program, function_name, inputs, private_key, fee_record) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(function_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            _assertClass(private_key, PrivateKey);
+            let ptr2 = 0;
+            if (!isLikeNone(fee_record)) {
+                _assertClass(fee_record, RecordPlaintext);
+                ptr2 = fee_record.__destroy_into_raw();
+            }
+            wasm.programmanager_computeQueryRequirements(retptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), private_key.__wbg_ptr, ptr2);
+            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);
+        }
+    }
     /**
      * Estimate Fee for an Authorization.
      *
@@ -11004,11 +11103,11 @@ class ProgramManager {
      * @param {VerifyingKey | null} [verifying_key]
      * @param {ProvingKey | null} [fee_proving_key]
      * @param {VerifyingKey | null} [fee_verifying_key]
-     * @param {OfflineQuery | null} [offline_query]
+     * @param {QueryOption | null} [query]
      * @param {number | null} [edition]
      * @returns {Promise<Transaction>}
      */
-    static buildExecutionTransaction(private_key, program, _function, inputs, priority_fee_credits, fee_record, url, imports, proving_key, verifying_key, fee_proving_key, fee_verifying_key, offline_query, edition) {
+    static buildExecutionTransaction(private_key, program, _function, inputs, priority_fee_credits, fee_record, url, imports, proving_key, verifying_key, fee_proving_key, fee_verifying_key, query, edition) {
         _assertClass(private_key, PrivateKey);
         const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
@@ -11042,9 +11141,9 @@ class ProgramManager {
             ptr7 = fee_verifying_key.__destroy_into_raw();
         }
         let ptr8 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr8 = offline_query.__destroy_into_raw();
+        if (!isLikeNone(query)) {
+            _assertClass(query, QueryOption);
+            ptr8 = query.__destroy_into_raw();
         }
         const ret = wasm.programmanager_buildExecutionTransaction(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), priority_fee_credits, ptr2, ptr3, len3, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr4, ptr5, ptr6, ptr7, ptr8, isLikeNone(edition) ? 0xFFFFFF : edition);
         return takeObject(ret);
@@ -11077,10 +11176,10 @@ class ProgramManager {
      * @param {VerifyingKey | null} [transfer_verifying_key]
      * @param {ProvingKey | null} [fee_proving_key]
      * @param {VerifyingKey | null} [fee_verifying_key]
-     * @param {OfflineQuery | null} [offline_query]
+     * @param {QueryOption | null} [query]
      * @returns {Promise<Transaction>}
      */
-    static buildTransferTransaction(private_key, amount_credits, recipient, transfer_type, amount_record, priority_fee_credits, fee_record, url, transfer_proving_key, transfer_verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
+    static buildTransferTransaction(private_key, amount_credits, recipient, transfer_type, amount_record, priority_fee_credits, fee_record, url, transfer_proving_key, transfer_verifying_key, fee_proving_key, fee_verifying_key, query) {
         _assertClass(private_key, PrivateKey);
         const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
@@ -11119,9 +11218,9 @@ class ProgramManager {
             ptr8 = fee_verifying_key.__destroy_into_raw();
         }
         let ptr9 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr9 = offline_query.__destroy_into_raw();
+        if (!isLikeNone(query)) {
+            _assertClass(query, QueryOption);
+            ptr9 = query.__destroy_into_raw();
         }
         const ret = wasm.programmanager_buildTransferTransaction(private_key.__wbg_ptr, amount_credits, ptr0, len0, ptr1, len1, ptr2, priority_fee_credits, ptr3, ptr4, len4, ptr5, ptr6, ptr7, ptr8, ptr9);
         return takeObject(ret);
@@ -11903,6 +12002,63 @@ class ProvingRequest {
 }
 if (Symbol.dispose) ProvingRequest.prototype[Symbol.dispose] = ProvingRequest.prototype.free;
 
+const QueryOptionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_queryoption_free(ptr >>> 0, 1));
+/**
+ * A unified query type that wraps either an OfflineQuery (pre-fetched state)
+ * or a CallbackQuery (on-demand JS transport delegation).
+ *
+ * Construct from JavaScript using the static factory methods:
+ * - `QueryOption.offlineQuery(offlineQuery)` for pre-fetched state
+ * - `QueryOption.callbackQuery(callbackQuery)` for on-demand JS callbacks
+ */
+class QueryOption {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(QueryOption.prototype);
+        obj.__wbg_ptr = ptr;
+        QueryOptionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QueryOptionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_queryoption_free(ptr, 0);
+    }
+    /**
+     * Create a QueryOption from an OfflineQuery.
+     * @param {OfflineQuery} query
+     * @returns {QueryOption}
+     */
+    static offlineQuery(query) {
+        _assertClass(query, OfflineQuery);
+        var ptr0 = query.__destroy_into_raw();
+        const ret = wasm.queryoption_offlineQuery(ptr0);
+        return QueryOption.__wrap(ret);
+    }
+    /**
+     * Create a QueryOption from a CallbackQuery.
+     * @param {CallbackQuery} query
+     * @returns {QueryOption}
+     */
+    static callbackQuery(query) {
+        _assertClass(query, CallbackQuery);
+        var ptr0 = query.__destroy_into_raw();
+        const ret = wasm.queryoption_callbackQuery(ptr0);
+        return QueryOption.__wrap(ret);
+    }
+}
+if (Symbol.dispose) QueryOption.prototype[Symbol.dispose] = QueryOption.prototype.free;
+
 const RecordCiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_recordciphertext_free(ptr >>> 0, 1));
@@ -18159,6 +18315,12 @@ function __wbg_get_imports(memory) {
         const ret = __wbg_init.__wbindgen_wasm_module;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
     imports.wbg.__wbg___wbindgen_rethrow_ea38273dafc473e6 = function(arg0) {
         throw takeObject(arg0);
     };
@@ -18186,6 +18348,10 @@ function __wbg_get_imports(memory) {
     imports.wbg.__wbg_append_b577eb3a177bc0fa = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
         getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
     }, arguments) };
+    imports.wbg.__wbg_apply_04097a755e1e4a1e = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).apply(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_arrayBuffer_b375eccb84b4ddf3 = function() { return handleError(function (arg0) {
         const ret = getObject(arg0).arrayBuffer();
         return addHeapObject(ret);
@@ -18292,6 +18458,16 @@ function __wbg_get_imports(memory) {
         const ret = getObject(arg0).headers;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_instanceof_Promise_001fdd42afa1b7ef = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Promise;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_instanceof_Response_f4f3e87e07f3135c = function(arg0) {
         let result;
         try {
@@ -18336,7 +18512,7 @@ function __wbg_get_imports(memory) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_0b9e82a3d425c505 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_22dee88c33d8b7ed = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
@@ -18358,7 +18534,7 @@ function __wbg_get_imports(memory) {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_7446(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_7492(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -18545,7 +18721,7 @@ function __wbg_get_imports(memory) {
         const ret = Signature.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_fd8a412decad8341 = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_33cc8ce5f9639974 = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -18635,11 +18811,6 @@ function __wbg_get_imports(memory) {
         const ret = Atomics.waitAsync(getObject(arg0), arg1 >>> 0, arg2);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_0eb37dec5f5def71 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 358, function: Function { arguments: [], shim_idx: 465, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7172, __wasm_bindgen_func_elem_7173);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
@@ -18650,19 +18821,19 @@ function __wbg_get_imports(memory) {
         const ret = (BigInt.asUintN(64, arg0) | (arg1 << BigInt(64)));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_32a97a33ade320ff = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 359, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 360, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7219, __wasm_bindgen_func_elem_8577);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_4a64cbb5b17898c9 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 358, function: Function { arguments: [Externref], shim_idx: 359, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7172, __wasm_bindgen_func_elem_8534);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_65bbaf572cb463ed = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 358, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 359, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7172, __wasm_bindgen_func_elem_8534);
+    imports.wbg.__wbindgen_cast_54fdaf61e7a5e679 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 359, function: Function { arguments: [], shim_idx: 465, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7219, __wasm_bindgen_func_elem_7220);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
@@ -18680,6 +18851,11 @@ function __wbg_get_imports(memory) {
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_e424aac48c10ba33 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 359, function: Function { arguments: [Externref], shim_idx: 360, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7219, __wasm_bindgen_func_elem_8577);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_e7b45dd881f38ce3 = function(arg0, arg1) {
         // Cast intrinsic for `U128 -> Externref`.
         const ret = (BigInt.asUintN(64, arg0) | (BigInt.asUintN(64, arg1) << BigInt(64)));
@@ -18783,5 +18959,5 @@ async function initThreadPool(threads) {
     await initThreadPool$1(new URL("worker.js", import.meta.url), threads);
 }
 
-export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Boolean, Ciphertext, ComputeKey, DynamicRecord, EncryptionToolkit, Execution, ExecutionRequest, ExecutionResponse, Field, GraphKey, Group, I128, I16, I32, I64, I8, KeyPair, Metadata, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, Proof, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, U128, U16, U32, U64, U8, Value, VerifyingKey, ViewKey, getOrInitConsensusVersionTestHeights, initSync, initThreadPool, runRayonThread, snarkVerify, snarkVerifyBatch, stringToField, verifyFunctionExecution };
+export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Boolean, CallbackQuery, Ciphertext, ComputeKey, DynamicRecord, EncryptionToolkit, Execution, ExecutionRequest, ExecutionResponse, Field, GraphKey, Group, I128, I16, I32, I64, I8, KeyPair, Metadata, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, Proof, ProvingKey, ProvingRequest, QueryOption, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, U128, U16, U32, U64, U8, Value, VerifyingKey, ViewKey, getOrInitConsensusVersionTestHeights, initSync, initThreadPool, runRayonThread, snarkVerify, snarkVerifyBatch, stringToField, verifyFunctionExecution };
 //# sourceMappingURL=index.js.map