@provablehq/wasm 0.10.4 → 0.10.5

package/dist/mainnet/aleo_wasm.d.ts

@@ -570,6 +570,25 @@ export class Boolean {
    */
   toString(): string;
 }
+/**
+ * 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.
+ */
+export class CallbackQuery {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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)
+   */
+  constructor(get_state_root: Function, get_state_paths: Function, get_block_height: Function);
+}
 /**
  * SnarkVM Ciphertext object. A Ciphertext represents an symmetrically encrypted plaintext. This
  * object provides decryption methods to recover the plaintext from the ciphertext (given the
@@ -3078,7 +3097,7 @@ export class ProgramManager {
    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
    * @returns {Transaction} Transaction object
    */
-  static buildJoinTransaction(private_key: PrivateKey, record_1: RecordPlaintext, record_2: RecordPlaintext, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, join_proving_key?: ProvingKey | null, join_verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null): Promise<Transaction>;
+  static buildJoinTransaction(private_key: PrivateKey, record_1: RecordPlaintext, record_2: RecordPlaintext, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, join_proving_key?: ProvingKey | null, join_verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, query?: QueryOption | null): Promise<Transaction>;
   /**
    * Split an Aleo credits record into two separate records. This function does not require a fee.
    *
@@ -3091,7 +3110,7 @@ export class ProgramManager {
    * @param split_verifying_key (optional) Provide a verifying key to use for the split function
    * @returns {Transaction} Transaction object
    */
-  static buildSplitTransaction(private_key: PrivateKey, split_amount: number, amount_record: RecordPlaintext, url?: string | null, split_proving_key?: ProvingKey | null, split_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null): Promise<Transaction>;
+  static buildSplitTransaction(private_key: PrivateKey, split_amount: number, amount_record: RecordPlaintext, url?: string | null, split_proving_key?: ProvingKey | null, split_verifying_key?: VerifyingKey | null, query?: QueryOption | null): Promise<Transaction>;
   /**
    * Deploy an Aleo program without synthesizing keys and generating certificates.
    * Intended for use with Leo Devnode.
@@ -3244,7 +3263,7 @@ export class ProgramManager {
    * @param url The url to get the inclusion proving information from.
    * @param offline_query Optional offline query object if building a Transaction offline.
    */
-  static executeAuthorization(authorization: Authorization, fee_authorization: Authorization | null | undefined, program: string, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, imports?: object | null, url?: string | null, offline_query?: OfflineQuery | null): Promise<Transaction>;
+  static executeAuthorization(authorization: Authorization, fee_authorization: Authorization | null | undefined, program: string, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, imports?: object | null, url?: string | null, query?: QueryOption | null): Promise<Transaction>;
   /**
    * Estimate Fee for Aleo function execution. Note if "cache" is set to true, the proving and
    * verifying keys will be stored in the ProgramManager's memory and used for subsequent
@@ -3279,7 +3298,24 @@ export class ProgramManager {
    * @param {ProvingKey | undefined} proving_key (optional) Provide a verifying key to use for the function execution
    * @param {VerifyingKey | undefined} verifying_key (optional) Provide a verifying key to use for the function execution
    */
-  static executeFunctionOffline(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, prove_execution: boolean, cache: boolean, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, url?: string | null, offline_query?: OfflineQuery | null, edition?: number | null): Promise<ExecutionResponse>;
+  static executeFunctionOffline(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, prove_execution: boolean, cache: boolean, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, url?: string | null, query?: QueryOption | null, edition?: number | null): Promise<ExecutionResponse>;
+  /**
+   * 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 }
+   */
+  static computeQueryRequirements(program: string, function_name: string, inputs: Array<any>, private_key: PrivateKey, fee_record?: RecordPlaintext | null): any;
   /**
    * Estimate Fee for an Authorization.
    *
@@ -3319,7 +3355,7 @@ export class ProgramManager {
    * @param edition The edition of the program to execute. Defaults to the latest found on the network, or 1 if the program does not exist on the network.
    * @returns {Transaction}
    */
-  static buildExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null, edition?: number | null): Promise<Transaction>;
+  static buildExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, query?: QueryOption | null, edition?: number | null): Promise<Transaction>;
   /**
    * Send credits from one Aleo account to another
    *
@@ -3337,7 +3373,7 @@ export class ProgramManager {
    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
    * @returns {Transaction}
    */
-  static buildTransferTransaction(private_key: PrivateKey, amount_credits: number, recipient: string, transfer_type: string, amount_record: RecordPlaintext | null | undefined, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, transfer_proving_key?: ProvingKey | null, transfer_verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null): Promise<Transaction>;
+  static buildTransferTransaction(private_key: PrivateKey, amount_credits: number, recipient: string, transfer_type: string, amount_record: RecordPlaintext | null | undefined, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, transfer_proving_key?: ProvingKey | null, transfer_verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, query?: QueryOption | null): Promise<Transaction>;
   /**
    * Create an `Authorization` for `credits.aleo/fee_public` or `credits.aleo/fee_private`.
    * This object requires an associated execution or deployment ID. This can be gained from
@@ -3665,6 +3701,27 @@ export class ProvingRequest {
    */
   toString(): string;
 }
+/**
+ * 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
+ */
+export class QueryOption {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a QueryOption from an OfflineQuery.
+   */
+  static offlineQuery(query: OfflineQuery): QueryOption;
+  /**
+   * Create a QueryOption from a CallbackQuery.
+   */
+  static callbackQuery(query: CallbackQuery): QueryOption;
+}
 /**
  * Encrypted Aleo record
  */

package/dist/mainnet/index.cjs

@@ -477,16 +477,16 @@ function getArrayJsValueFromWasm0(ptr, len) {
     }
     return result;
 }
-function __wasm_bindgen_func_elem_8536(arg0, arg1, arg2) {
-    wasm$1.__wasm_bindgen_func_elem_8536(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_7206(arg0, arg1) {
+    wasm$1.__wasm_bindgen_func_elem_7206(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_7170(arg0, arg1) {
-    wasm$1.__wasm_bindgen_func_elem_7170(arg0, arg1);
+function __wasm_bindgen_func_elem_8569(arg0, arg1, arg2) {
+    wasm$1.__wasm_bindgen_func_elem_8569(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_7443(arg0, arg1, arg2, arg3) {
-    wasm$1.__wasm_bindgen_func_elem_7443(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_7479(arg0, arg1, arg2, arg3) {
+    wasm$1.__wasm_bindgen_func_elem_7479(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
@@ -2229,6 +2229,48 @@ class Boolean {
 }
 if (Symbol.dispose) Boolean.prototype[Symbol.dispose] = Boolean.prototype.free;
 
+const CallbackQueryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm$1.__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$1.__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$1.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$1.__wbg_ciphertext_free(ptr >>> 0, 1));
@@ -10373,10 +10415,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();
@@ -10410,9 +10452,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$1.programmanager_buildJoinTransaction(private_key.__wbg_ptr, ptr0, ptr1, priority_fee_credits, ptr2, ptr3, len3, ptr4, ptr5, ptr6, ptr7, ptr8);
         return takeObject(ret);
@@ -10434,10 +10476,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();
@@ -10454,9 +10496,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$1.programmanager_buildSplitTransaction(private_key.__wbg_ptr, split_amount, ptr0, ptr1, len1, ptr2, ptr3, ptr4);
         return takeObject(ret);
@@ -10809,10 +10851,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;
@@ -10845,9 +10887,9 @@ class ProgramManager {
         var ptr7 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm$1.__wbindgen_export, wasm$1.__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$1.programmanager_executeAuthorization(ptr0, ptr1, ptr2, len2, ptr3, ptr4, ptr5, ptr6, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr7, len7, ptr8);
         return takeObject(ret);
@@ -10918,11 +10960,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$1.__wbindgen_export, wasm$1.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
@@ -10941,13 +10983,60 @@ class ProgramManager {
         var ptr4 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm$1.__wbindgen_export, wasm$1.__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$1.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$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program, wasm$1.__wbindgen_export, wasm$1.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(function_name, wasm$1.__wbindgen_export, wasm$1.__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$1.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$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Estimate Fee for an Authorization.
      *
@@ -11020,11 +11109,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$1.__wbindgen_export, wasm$1.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
@@ -11058,9 +11147,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$1.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);
@@ -11093,10 +11182,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$1.__wbindgen_export, wasm$1.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
@@ -11135,9 +11224,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$1.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);
@@ -11919,6 +12008,63 @@ class ProvingRequest {
 }
 if (Symbol.dispose) ProvingRequest.prototype[Symbol.dispose] = ProvingRequest.prototype.free;
 
+const QueryOptionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm$1.__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$1.__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$1.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$1.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$1.__wbg_recordciphertext_free(ptr >>> 0, 1));
@@ -18175,6 +18321,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);
     };
@@ -18202,6 +18354,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);
@@ -18308,6 +18464,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 {
@@ -18352,7 +18518,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) {
@@ -18374,7 +18540,7 @@ function __wbg_get_imports(memory) {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_7443(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_7479(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -18561,7 +18727,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);
     };
@@ -18661,14 +18827,24 @@ function __wbg_get_imports(memory) {
         const ret = (BigInt.asUintN(64, arg0) | (arg1 << BigInt(64)));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_3ebebf8ee554379e = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 354, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 355, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm$1.__wasm_bindgen_func_elem_7205, __wasm_bindgen_func_elem_8569);
+        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_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$1.__wasm_bindgen_func_elem_7169, __wasm_bindgen_func_elem_8536);
+    imports.wbg.__wbindgen_cast_5e9bcb6388942484 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 354, function: Function { arguments: [], shim_idx: 462, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm$1.__wasm_bindgen_func_elem_7205, __wasm_bindgen_func_elem_7206);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_74f3a90a349943d1 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 354, function: Function { arguments: [Externref], shim_idx: 355, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm$1.__wasm_bindgen_func_elem_7205, __wasm_bindgen_func_elem_8569);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
@@ -18676,16 +18852,6 @@ function __wbg_get_imports(memory) {
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_bff04fdc9653fdb7 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 356, function: Function { arguments: [], shim_idx: 465, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm$1.__wasm_bindgen_func_elem_7169, __wasm_bindgen_func_elem_7170);
-        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$1.__wasm_bindgen_func_elem_7169, __wasm_bindgen_func_elem_8536);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
         const ret = getArrayU8FromWasm0(arg0, arg1);
@@ -18794,6 +18960,7 @@ var exports$1$1 = /*#__PURE__*/Object.freeze({
     BHP512: BHP512,
     BHP768: BHP768,
     Boolean: Boolean,
+    CallbackQuery: CallbackQuery,
     Ciphertext: Ciphertext,
     ComputeKey: ComputeKey,
     DynamicRecord: DynamicRecord,
@@ -18825,6 +18992,7 @@ var exports$1$1 = /*#__PURE__*/Object.freeze({
     Proof: Proof,
     ProvingKey: ProvingKey,
     ProvingRequest: ProvingRequest,
+    QueryOption: QueryOption,
     RecordCiphertext: RecordCiphertext,
     RecordPlaintext: RecordPlaintext,
     Scalar: Scalar,