@provablehq/wasm 0.10.4 → 0.10.5

package/dist/testnet/worker.js

@@ -303,38 +303,6 @@ function addBorrowedObject(obj) {
     heap[--stack_pointer] = obj;
     return stack_pointer;
 }
-/**
- * Verify a batch SNARK proof against multiple verifying keys and their corresponding public inputs.
- *
- * This function verifies a batch proof produced by Aleo programs that may not be deployed on chain.
- * Each verifying key is paired with one or more sets of public inputs (instances).
- *
- * @param {Array<string>} verifying_keys Array of verifying key strings, one per circuit
- * @param {Array<Array<Array<string>>>} inputs 3D array of field element strings [circuit_idx][instance_idx][field_idx]
- * @param {Proof} proof The batch proof to verify
- * @returns {boolean} True if the batch proof is valid, false otherwise
- * @param {Array<any>} verifying_keys
- * @param {Array<any>} inputs
- * @param {Proof} proof
- * @returns {boolean}
- */
-function snarkVerifyBatch(verifying_keys, inputs, proof) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        _assertClass(proof, Proof);
-        wasm.snarkVerifyBatch(retptr, addHeapObject(verifying_keys), addHeapObject(inputs), proof.__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 an execution. Executions with multiple transitions must have the program source code and
  * verifying keys of imported functions supplied from outside to correctly verify. Also, this does
@@ -410,6 +378,38 @@ function snarkVerify(verifying_key, inputs, proof) {
     }
 }
 
+/**
+ * Verify a batch SNARK proof against multiple verifying keys and their corresponding public inputs.
+ *
+ * This function verifies a batch proof produced by Aleo programs that may not be deployed on chain.
+ * Each verifying key is paired with one or more sets of public inputs (instances).
+ *
+ * @param {Array<string>} verifying_keys Array of verifying key strings, one per circuit
+ * @param {Array<Array<Array<string>>>} inputs 3D array of field element strings [circuit_idx][instance_idx][field_idx]
+ * @param {Proof} proof The batch proof to verify
+ * @returns {boolean} True if the batch proof is valid, false otherwise
+ * @param {Array<any>} verifying_keys
+ * @param {Array<any>} inputs
+ * @param {Proof} proof
+ * @returns {boolean}
+ */
+function snarkVerifyBatch(verifying_keys, inputs, proof) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(proof, Proof);
+        wasm.snarkVerifyBatch(retptr, addHeapObject(verifying_keys), addHeapObject(inputs), proof.__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);
+    }
+}
+
 /**
  * @param {string} string
  * @returns {Field}
@@ -471,16 +471,16 @@ function getArrayJsValueFromWasm0(ptr, len) {
     }
     return result;
 }
-function __wasm_bindgen_func_elem_8536(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_8536(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_7201(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_7201(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_7166(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_7166(arg0, arg1);
+function __wasm_bindgen_func_elem_8569(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_8569(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_7439(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_7439(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_7473(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_7473(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));
@@ -10367,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();
@@ -10404,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);
@@ -10428,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();
@@ -10448,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);
@@ -10803,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;
@@ -10839,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);
@@ -10912,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;
@@ -10935,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.
      *
@@ -11014,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;
@@ -11052,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);
@@ -11087,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;
@@ -11129,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);
@@ -11913,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));
@@ -18169,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);
     };
@@ -18196,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);
@@ -18302,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 {
@@ -18346,7 +18512,7 @@ function __wbg_get_imports(memory) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_4688d4dee83f4df4 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_78f898e0b3066062 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
@@ -18368,7 +18534,7 @@ function __wbg_get_imports(memory) {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_7439(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_7473(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -18555,7 +18721,7 @@ function __wbg_get_imports(memory) {
         const ret = Signature.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_9ce4a98fc7b6f238 = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_16cedfb6613c80ac = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -18645,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_7165, __wasm_bindgen_func_elem_7166);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
@@ -18665,14 +18826,9 @@ function __wbg_get_imports(memory) {
         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_7165, __wasm_bindgen_func_elem_8536);
-        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_7165, __wasm_bindgen_func_elem_8536);
+    imports.wbg.__wbindgen_cast_711d7deea8fc39ca = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 356, function: Function { arguments: [Externref], shim_idx: 357, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7200, __wasm_bindgen_func_elem_8569);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
@@ -18680,11 +18836,21 @@ function __wbg_get_imports(memory) {
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_cada7727142cd213 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 356, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 357, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7200, __wasm_bindgen_func_elem_8569);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
         const ret = getArrayU8FromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_cdf07f87b2615f8c = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 356, function: Function { arguments: [], shim_idx: 462, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_7200, __wasm_bindgen_func_elem_7201);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;
@@ -18788,6 +18954,7 @@ var exports$1 = /*#__PURE__*/Object.freeze({
     BHP512: BHP512,
     BHP768: BHP768,
     Boolean: Boolean,
+    CallbackQuery: CallbackQuery,
     Ciphertext: Ciphertext,
     ComputeKey: ComputeKey,
     DynamicRecord: DynamicRecord,
@@ -18819,6 +18986,7 @@ var exports$1 = /*#__PURE__*/Object.freeze({
     Proof: Proof,
     ProvingKey: ProvingKey,
     ProvingRequest: ProvingRequest,
+    QueryOption: QueryOption,
     RecordCiphertext: RecordCiphertext,
     RecordPlaintext: RecordPlaintext,
     Scalar: Scalar,