@provablehq/wasm 0.9.18 → 0.10.0

package/dist/mainnet/worker.js

@@ -2227,6 +2227,58 @@ class ExecutionRequest {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_executionrequest_free(ptr, 0);
     }
+    /**
+     * Computes the function ID and serialized input data for a program function call.
+     * This is a helper for external signing wallets and other applications that need to compute
+     * publicly computable inputs for the `Request::sign` function.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} input_types The input types of the function as strings.
+     * @param {string[]} inputs The inputs to the function as strings.
+     * @param {boolean} is_root Flag to indicate if this is the top level function in the call graph.
+     * @param {Field | undefined} program_checksum The program checksum (required if the program has a constructor).
+     * @param {ViewKey | undefined} view_key The view key of the signer to compute a record's tag and h values.
+     *
+     * @returns {ExternalSigningInput}
+     * @param {string} program_id
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {Array<any>} input_types
+     * @param {boolean} is_root
+     * @param {Field | null} [program_checksum]
+     * @param {ViewKey | null} [view_key]
+     * @returns {object}
+     */
+    static computeExternalSigningInputs(program_id, function_name, inputs, input_types, is_root, program_checksum, view_key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program_id, 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;
+            let ptr2 = 0;
+            if (!isLikeNone(program_checksum)) {
+                _assertClass(program_checksum, Field);
+                ptr2 = program_checksum.__destroy_into_raw();
+            }
+            let ptr3 = 0;
+            if (!isLikeNone(view_key)) {
+                _assertClass(view_key, ViewKey);
+                ptr3 = view_key.__destroy_into_raw();
+            }
+            wasm.executionrequest_computeExternalSigningInputs(retptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), addHeapObject(input_types), is_root, ptr2, ptr3);
+            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);
+        }
+    }
     /**
      * Creates an request object from a bytes representation of an request.
      * @param {Uint8Array} bytes
@@ -2247,6 +2299,176 @@ class ExecutionRequest {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Builds a request from externally-signed data using externally-supplied record view keys.
+     *
+     * For record inputs, the caller provides `record_view_keys` and `gammas` directly.
+     * The method uses these to compute commitment, serial number, tag, and InputID for each record.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} inputs The inputs to the function.
+     * @param {string[]} input_types The input types of the function.
+     * @param {Signature} signature The externally-computed signature.
+     * @param {Field} tvk The transition view key.
+     * @param {Address} signer The signer address.
+     * @param {Field} sk_tag The tag secret key.
+     * @param {Field[] | undefined} record_view_keys Pre-computed record view keys (required when there are record inputs).
+     * @param {Group[] | undefined} gammas An array of gammas (required when there are record inputs).
+     * @param {string} program_id
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {Array<any>} input_types
+     * @param {Signature} signature
+     * @param {Field} tvk
+     * @param {Address} signer
+     * @param {Field} sk_tag
+     * @param {Array<any> | null} [record_view_keys]
+     * @param {Array<any> | null} [gammas]
+     * @returns {ExecutionRequest}
+     */
+    static fromExternallySignedData(program_id, function_name, inputs, input_types, signature, tvk, signer, sk_tag, record_view_keys, gammas) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program_id, 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(signature, Signature);
+            var ptr2 = signature.__destroy_into_raw();
+            _assertClass(tvk, Field);
+            var ptr3 = tvk.__destroy_into_raw();
+            _assertClass(signer, Address);
+            var ptr4 = signer.__destroy_into_raw();
+            _assertClass(sk_tag, Field);
+            var ptr5 = sk_tag.__destroy_into_raw();
+            wasm.executionrequest_fromExternallySignedData(retptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), addHeapObject(input_types), ptr2, ptr3, ptr4, ptr5, isLikeNone(record_view_keys) ? 0 : addHeapObject(record_view_keys), isLikeNone(gammas) ? 0 : addHeapObject(gammas));
+            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 ExecutionRequest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Builds a request from externally-signed data with pre-computed input IDs.
+     *
+     * Each element of `input_ids` is either:
+     * - A `Field` for constant, public, or private inputs (the input hash).
+     * - A JS Array `[Field, Group, Field, Field, Field]` for record inputs
+     *   (commitment, gamma, record_view_key, serial_number, tag).
+     *
+     * The `input_types` array is used to determine the InputID variant for scalar fields.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} inputs The inputs to the function.
+     * @param {string[]} input_types The input types of the function.
+     * @param {Signature} signature The externally-computed signature.
+     * @param {Field} tvk The transition view key.
+     * @param {Address} signer The signer address.
+     * @param {Field} sk_tag The tag secret key.
+     * @param {(Field | [Field, Group, Field, Field, Field])[]} input_ids Pre-computed input IDs.
+     * @param {string} program_id
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {Array<any>} input_types
+     * @param {Signature} signature
+     * @param {Field} tvk
+     * @param {Address} signer
+     * @param {Field} sk_tag
+     * @param {Array<any>} input_ids
+     * @returns {ExecutionRequest}
+     */
+    static fromExternallySignedDataWithInputIds(program_id, function_name, inputs, input_types, signature, tvk, signer, sk_tag, input_ids) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program_id, 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(signature, Signature);
+            var ptr2 = signature.__destroy_into_raw();
+            _assertClass(tvk, Field);
+            var ptr3 = tvk.__destroy_into_raw();
+            _assertClass(signer, Address);
+            var ptr4 = signer.__destroy_into_raw();
+            _assertClass(sk_tag, Field);
+            var ptr5 = sk_tag.__destroy_into_raw();
+            wasm.executionrequest_fromExternallySignedDataWithInputIds(retptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), addHeapObject(input_types), ptr2, ptr3, ptr4, ptr5, addHeapObject(input_ids));
+            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 ExecutionRequest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Builds a request from externally-signed data using a view key to derive record view keys.
+     *
+     * For record inputs, the method computes `record_view_key = (nonce * view_key).to_x_coordinate()`
+     * for each record, then uses it with the supplied `gammas` to compute commitment, serial number,
+     * tag, and InputID.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} inputs The inputs to the function.
+     * @param {string[]} input_types The input types of the function.
+     * @param {Signature} signature The externally-computed signature.
+     * @param {Field} tvk The transition view key.
+     * @param {Address} signer The signer address.
+     * @param {Field} sk_tag The tag secret key.
+     * @param {ViewKey} view_key The view key of the signer.
+     * @param {Group[] | undefined} gammas An array of gammas (required when there are record inputs).
+     * @param {string} program_id
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {Array<any>} input_types
+     * @param {Signature} signature
+     * @param {Field} tvk
+     * @param {Address} signer
+     * @param {Field} sk_tag
+     * @param {ViewKey} view_key
+     * @param {Array<any> | null} [gammas]
+     * @returns {ExecutionRequest}
+     */
+    static fromExternallySignedDataWithViewKey(program_id, function_name, inputs, input_types, signature, tvk, signer, sk_tag, view_key, gammas) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program_id, 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(signature, Signature);
+            var ptr2 = signature.__destroy_into_raw();
+            _assertClass(tvk, Field);
+            var ptr3 = tvk.__destroy_into_raw();
+            _assertClass(signer, Address);
+            var ptr4 = signer.__destroy_into_raw();
+            _assertClass(sk_tag, Field);
+            var ptr5 = sk_tag.__destroy_into_raw();
+            _assertClass(view_key, ViewKey);
+            var ptr6 = view_key.__destroy_into_raw();
+            wasm.executionrequest_fromExternallySignedDataWithViewKey(retptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), addHeapObject(input_types), ptr2, ptr3, ptr4, ptr5, ptr6, isLikeNone(gammas) ? 0 : addHeapObject(gammas));
+            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 ExecutionRequest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Builds a request object from a string representation of a request.
      *
@@ -2271,6 +2493,26 @@ class ExecutionRequest {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Alias for `function_name` (camelCase).
+     * @returns {string}
+     */
+    functionName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.executionrequest_functionName(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Returns the function name.
      * @returns {string}
@@ -2291,8 +2533,20 @@ class ExecutionRequest {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Alias for `input_ids` (camelCase).
+     * @returns {Array<any>}
+     */
+    inputIds() {
+        const ret = wasm.executionrequest_inputIds(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Returns the input IDs for the transition.
+     *
+     * Each element is either a WASM `Field` (for constant/public/private/external_record inputs)
+     * or a JS Array `[Field, Group, Field, Field, Field]` (for record inputs: commitment, gamma,
+     * record_view_key, serial_number, tag).
      * @returns {Array<any>}
      */
     input_ids() {
@@ -2307,6 +2561,14 @@ class ExecutionRequest {
         const ret = wasm.executionrequest_inputs(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * Alias for `network_id` (camelCase).
+     * @returns {number}
+     */
+    networkId() {
+        const ret = wasm.executionrequest_networkId(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Returns the network ID.
      * @returns {number}
@@ -2315,6 +2577,26 @@ class ExecutionRequest {
         const ret = wasm.executionrequest_network_id(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Alias for `program_id` (camelCase).
+     * @returns {string}
+     */
+    programId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.executionrequest_programId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Returns the program ID.
      * @returns {string}
@@ -2410,6 +2692,14 @@ class ExecutionRequest {
         const ret = wasm.executionrequest_signer(this.__wbg_ptr);
         return Address.__wrap(ret);
     }
+    /**
+     * Alias for `sk_tag` (camelCase).
+     * @returns {Field}
+     */
+    skTag() {
+        const ret = wasm.executionrequest_skTag(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
     /**
      * Returns the tag secret key `sk_tag`.
      * @returns {Field}
@@ -2467,6 +2757,14 @@ class ExecutionRequest {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Alias for `to_tpk` (camelCase).
+     * @returns {Group}
+     */
+    toTpk() {
+        const ret = wasm.executionrequest_toTpk(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
     /**
      * Returns the transition public key `tpk`.
      * @returns {Group}
@@ -3000,6 +3298,12 @@ class Group {
         GroupFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof Group)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -3088,6 +3392,49 @@ class Group {
             heap[stack_pointer++] = undefined;
         }
     }
+    /**
+     * Generate the group element from the x coordinate of the group.
+     * @param {Field} field
+     * @returns {Group}
+     */
+    static fromField(field) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(field, Field);
+            wasm.group_fromField(retptr, field.__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 Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Generate the group element from a string representation of the x coordinate of the group.
+     * @param {string} field
+     * @returns {Group}
+     */
+    static fromFieldString(field) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(field, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.group_fromFieldString(retptr, ptr0, len0);
+            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 Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Creates a group object from a string representation of a group element.
      * @param {string} group
@@ -7298,6 +7645,35 @@ class ProgramManager {
         const ret = wasm.programmanager_authorizeFee(private_key.__wbg_ptr, ptr0, len0, base_fee_credits, priority_fee_credits, ptr1);
         return takeObject(ret);
     }
+    /**
+     * Build an authorization from a `Request` object.
+     *
+     * @param {ExecutionRequest} request The execution request to build the authorization from.
+     * @param {string} program The program source code containing the function to authorize.
+     * @param {boolean} unchecked Whether or not to generate an unchecked authorization.
+     * @param {number | undefined} edition The edition of the program.
+     * @param {object | undefined} imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
+     * @param {PrivateKey | undefined} [private_key] Optional private key of the signer. If not provided, functions which call other programs may not succeed.
+     * @param {ExecutionRequest} request
+     * @param {string} program
+     * @param {boolean} unchecked
+     * @param {number | null} [edition]
+     * @param {object | null} [imports]
+     * @param {PrivateKey | null} [private_key]
+     * @returns {Promise<Authorization>}
+     */
+    static buildAuthorizationFromExecutionRequest(request, program, unchecked, edition, imports, private_key) {
+        _assertClass(request, ExecutionRequest);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(private_key)) {
+            _assertClass(private_key, PrivateKey);
+            ptr1 = private_key.__destroy_into_raw();
+        }
+        const ret = wasm.programmanager_buildAuthorizationFromExecutionRequest(request.__wbg_ptr, ptr0, len0, unchecked, isLikeNone(edition) ? 0xFFFFFF : edition, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr1);
+        return takeObject(ret);
+    }
     /**
      * Create an execution `Authorization` without generating a circuit. Use this function when
      * fast delegated proving is needed.
@@ -7711,19 +8087,50 @@ class ProgramManager {
         return takeObject(ret);
     }
     /**
-     * Split an Aleo credits record into two separate records. This function does not require a fee.
+     * Build a proving request from a `Request` object. By default this method currently uses the feemaster.
      *
-     * @param private_key The private key of the sender
-     * @param split_amount The amount of the credit split. This amount will be subtracted from the
-     * value of the record and two new records will be created with the split amount and the remainder
-     * @param amount_record The record to split
-     * @param url The url of the Aleo network node to send the transaction to
-     * @param split_proving_key (optional) Provide a proving key to use for the split function
-     * @param split_verifying_key (optional) Provide a verifying key to use for the split function
-     * @returns {Transaction} Transaction object
-     * @param {PrivateKey} private_key
-     * @param {number} split_amount
-     * @param {RecordPlaintext} amount_record
+     * @param {ExecutionRequest} request The execution request to build the authorization from.
+     * @param {string} program The program source code containing the function to authorize.
+     * @param {boolean} unchecked Whether or not to generate an unchecked authorization.
+     * @param {boolean} broadcast Whether or not to broadcast the transaction.
+     * @param {number | undefined} edition The edition of the program.
+     * @param {object | undefined} imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
+     * @param {PrivateKey | undefined} [private_key] Optional private key of the signer. If not provided, functions which call other programs may not succeed.
+     * @param {ExecutionRequest} request
+     * @param {string} program
+     * @param {boolean} unchecked
+     * @param {boolean} broadcast
+     * @param {number | null} [edition]
+     * @param {object | null} [imports]
+     * @param {PrivateKey | null} [private_key]
+     * @returns {Promise<ProvingRequest>}
+     */
+    static buildProvingRequestFromExecutionRequest(request, program, unchecked, broadcast, edition, imports, private_key) {
+        _assertClass(request, ExecutionRequest);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(private_key)) {
+            _assertClass(private_key, PrivateKey);
+            ptr1 = private_key.__destroy_into_raw();
+        }
+        const ret = wasm.programmanager_buildProvingRequestFromExecutionRequest(request.__wbg_ptr, ptr0, len0, unchecked, broadcast, isLikeNone(edition) ? 0xFFFFFF : edition, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr1);
+        return takeObject(ret);
+    }
+    /**
+     * Split an Aleo credits record into two separate records. This function does not require a fee.
+     *
+     * @param private_key The private key of the sender
+     * @param split_amount The amount of the credit split. This amount will be subtracted from the
+     * value of the record and two new records will be created with the split amount and the remainder
+     * @param amount_record The record to split
+     * @param url The url of the Aleo network node to send the transaction to
+     * @param split_proving_key (optional) Provide a proving key to use for the split function
+     * @param split_verifying_key (optional) Provide a verifying key to use for the split function
+     * @returns {Transaction} Transaction object
+     * @param {PrivateKey} private_key
+     * @param {number} split_amount
+     * @param {RecordPlaintext} amount_record
      * @param {string | null} [url]
      * @param {ProvingKey | null} [split_proving_key]
      * @param {VerifyingKey | null} [split_verifying_key]
@@ -8197,6 +8604,126 @@ class ProgramManager {
 }
 if (Symbol.dispose) ProgramManager.prototype[Symbol.dispose] = ProgramManager.prototype.free;
 
+/**
+ * SNARK proof for verification of program execution
+ */
+class Proof {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Proof.prototype);
+        obj.__wbg_ptr = ptr;
+        ProofFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProofFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_proof_free(ptr, 0);
+    }
+    /**
+     * Construct a new proof from a byte array
+     *
+     * @param {Uint8Array} bytes Byte array representation of a proof
+     * @returns {Proof}
+     * @param {Uint8Array} bytes
+     * @returns {Proof}
+     */
+    static fromBytes(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.proof_fromBytes(retptr, ptr0, len0);
+            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 Proof.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Create a proof from string
+     *
+     * @param {string} string String representation of the proof
+     * @returns {Proof}
+     * @param {string} string
+     * @returns {Proof}
+     */
+    static fromString(string) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(string, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.proof_fromString(retptr, ptr0, len0);
+            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 Proof.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Return the byte representation of a proof
+     *
+     * @returns {Uint8Array} Byte array representation of a proof
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.proof_toBytes(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get a string representation of the proof
+     *
+     * @returns {string} String representation of the proof
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.proof_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Proof.prototype[Symbol.dispose] = Proof.prototype.free;
+
 /**
  * Proving key for a function within an Aleo program
  */
@@ -9140,6 +9667,38 @@ class RecordPlaintext {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Compute the record's gamma value.
+     *
+     * @param {string} program_id The program id that produced the record.
+     * @param {string} record_name The name of the record within the program.
+     * @param {PrivateKey} private_key The private key that created the record.
+     * @returns {Group} The computed value of gamma.
+     * @param {string} program_id
+     * @param {string} record_name
+     * @param {PrivateKey} private_key
+     * @returns {Group}
+     */
+    gamma(program_id, record_name, private_key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(record_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            _assertClass(private_key, PrivateKey);
+            wasm.recordplaintext_gamma(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, private_key.__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 Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Get the record entry matching a key.
      *
@@ -12295,6 +12854,331 @@ class U8 {
 }
 if (Symbol.dispose) U8.prototype[Symbol.dispose] = U8.prototype.free;
 
+/**
+ * Aleo Value type. Value is the fundamental type representing program function inputs and outputs
+ * in Aleo. It wraps three variants: Plaintext, Record, and Future.
+ *
+ * @example
+ * // Parse a plaintext value from a string.
+ * const value = Value.fromString("100u64");
+ * console.log(value.valueType()); // "plaintext"
+ * console.log(value.isPlaintext()); // true
+ *
+ * // Extract the inner Plaintext.
+ * const plaintext = value.toPlaintext();
+ * console.log(plaintext.toString()); // "100u64"
+ */
+class Value {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Value.prototype);
+        obj.__wbg_ptr = ptr;
+        ValueFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ValueFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_value_free(ptr, 0);
+    }
+    /**
+     * Creates a Value from a little-endian byte array.
+     *
+     * @param {Uint8Array} bytes A little-endian byte array.
+     * @returns {Value} The Value object.
+     * @param {Uint8Array} bytes
+     * @returns {Value}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_fromBytesLe(retptr, addHeapObject(bytes));
+            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 Value.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a Value from a Plaintext object.
+     *
+     * @param {Plaintext} plaintext The Plaintext to wrap.
+     * @returns {Value} A Value wrapping the Plaintext.
+     * @param {Plaintext} plaintext
+     * @returns {Value}
+     */
+    static fromPlaintext(plaintext) {
+        _assertClass(plaintext, Plaintext);
+        const ret = wasm.value_fromPlaintext(plaintext.__wbg_ptr);
+        return Value.__wrap(ret);
+    }
+    /**
+     * Creates a Value from a RecordPlaintext object.
+     *
+     * @param {RecordPlaintext} record The RecordPlaintext to wrap.
+     * @returns {Value} A Value wrapping the Record.
+     * @param {RecordPlaintext} record
+     * @returns {Value}
+     */
+    static fromRecordPlaintext(record) {
+        _assertClass(record, RecordPlaintext);
+        const ret = wasm.value_fromRecordPlaintext(record.__wbg_ptr);
+        return Value.__wrap(ret);
+    }
+    /**
+     * Creates a Value from its string representation.
+     *
+     * @param {string} value The string representation of the value.
+     * @returns {Value} The Value object.
+     * @param {string} value
+     * @returns {Value}
+     */
+    static fromString(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.value_fromString(retptr, ptr0, len0);
+            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 Value.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns true if the value is a Future variant.
+     *
+     * Note: There is no `toFuture()` method because the Future type does not have a WASM wrapper.
+     * Use `toString()` or `toBytesLe()` to serialize a Future value.
+     *
+     * @returns {boolean}
+     * @returns {boolean}
+     */
+    isFuture() {
+        const ret = wasm.value_isFuture(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns true if the value is a Plaintext variant.
+     *
+     * @returns {boolean}
+     * @returns {boolean}
+     */
+    isPlaintext() {
+        const ret = wasm.value_isPlaintext(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns true if the value is a Record variant.
+     *
+     * @returns {boolean}
+     * @returns {boolean}
+     */
+    isRecord() {
+        const ret = wasm.value_isRecord(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns the little-endian boolean array representation of the bits.
+     *
+     * @returns {Array} Boolean array of bits in little-endian order.
+     * @returns {Array<any>}
+     */
+    toBitsLe() {
+        const ret = wasm.value_toBitsLe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Returns the raw big-endian boolean array representation of the bits.
+     *
+     * @returns {Array} Raw boolean array of bits in big-endian order.
+     * @returns {Array<any>}
+     */
+    toBitsRawBe() {
+        const ret = wasm.value_toBitsRawBe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Returns the raw little-endian boolean array representation of the bits.
+     *
+     * @returns {Array} Raw boolean array of bits in little-endian order.
+     * @returns {Array<any>}
+     */
+    toBitsRawLe() {
+        const ret = wasm.value_toBitsRawLe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Returns the little-endian byte array representation of the value.
+     *
+     * @returns {Uint8Array} The little-endian byte array.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_toBytesLe(retptr, this.__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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the field array representation of the value.
+     *
+     * @returns {Array} Array of Field elements.
+     * @returns {Array<any>}
+     */
+    toFields() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_toFields(retptr, this.__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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the raw field array representation of the value.
+     *
+     * @returns {Array} Array of raw Field elements.
+     * @returns {Array<any>}
+     */
+    toFieldsRaw() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_toFieldsRaw(retptr, this.__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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Extracts the inner Plaintext from a Plaintext variant.
+     *
+     * @returns {Plaintext} The inner Plaintext value.
+     * @throws If the value is not a Plaintext variant.
+     * @returns {Plaintext}
+     */
+    toPlaintext() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_toPlaintext(retptr, this.__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 Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Extracts the inner Record from a Record variant as a RecordPlaintext.
+     *
+     * @returns {RecordPlaintext} The inner record.
+     * @throws If the value is not a Record variant.
+     * @returns {RecordPlaintext}
+     */
+    toRecordPlaintext() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_toRecordPlaintext(retptr, this.__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 RecordPlaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the string representation of the value.
+     *
+     * @returns {string} The string representation of the value.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Returns the type of the value variant as a string.
+     *
+     * Possible values: "plaintext", "record", "future".
+     *
+     * @returns {string} The variant type name.
+     * @returns {string}
+     */
+    valueType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.value_valueType(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Value.prototype[Symbol.dispose] = Value.prototype.free;
+
 /**
  * Verifying key for a function within an Aleo program
  */
@@ -12754,6 +13638,60 @@ class VerifyingKey {
         const ret = wasm.verifyingkey_unbondPublicVerifier();
         return VerifyingKey.__wrap(ret);
     }
+    /**
+     * Verify a SNARK proof against this verifying key and public inputs.
+     *
+     * @param {Array<string>} inputs Array of field element strings representing public inputs (e.g. ["1field", "2field"])
+     * @param {Proof} proof The proof to verify
+     * @returns {boolean} True if the proof is valid, false otherwise
+     * @param {Array<any>} inputs
+     * @param {Proof} proof
+     * @returns {boolean}
+     */
+    verify(inputs, proof) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(proof, Proof);
+            wasm.verifyingkey_verify(retptr, this.__wbg_ptr, 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 a batch SNARK proof against multiple verifying keys and their corresponding public inputs.
+     *
+     * @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}
+     */
+    static verifyBatch(verifying_keys, inputs, proof) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(proof, Proof);
+            wasm.verifyingkey_verifyBatch(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);
+        }
+    }
 }
 if (Symbol.dispose) VerifyingKey.prototype[Symbol.dispose] = VerifyingKey.prototype.free;
 
@@ -12976,7 +13914,7 @@ if (Symbol.dispose) ViewKey.prototype[Symbol.dispose] = ViewKey.prototype.free;
  * @param {string | undefined} heights The block heights at which each consensus version applies. This input should be a simple csv list of block heights and there should be one number for each consensus version. If left undefined, the default test heights will be applied.
  *
  * @example
- * import { getOrInitConsensusVersionHeights } from @provablehq/sdk;
+ * import { getOrInitConsensusVersionTestHeights } from '@provablehq/sdk';
  *
  * Set the consensus version heights.
  * getOrInitConsensusVersionTestHeights("0,1,2,3,4,5,6,7,8,9,10,11,12");
@@ -13007,6 +13945,93 @@ function runRayonThread(receiver) {
     wasm.runRayonThread(receiver);
 }
 
+/**
+ * Verify a SNARK proof against a verifying key and public inputs.
+ *
+ * This function verifies a proof produced by an Aleo program that may not be deployed on chain.
+ * It directly invokes the Varuna proof verification from snarkVM.
+ *
+ * @param {VerifyingKey} verifying_key The verifying key for the circuit
+ * @param {Array<string>} inputs Array of field element strings representing public inputs (e.g. ["1field", "2field"])
+ * @param {Proof} proof The proof to verify
+ * @returns {boolean} True if the proof is valid, false otherwise
+ * @param {VerifyingKey} verifying_key
+ * @param {Array<any>} inputs
+ * @param {Proof} proof
+ * @returns {boolean}
+ */
+function snarkVerify(verifying_key, inputs, proof) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(verifying_key, VerifyingKey);
+        _assertClass(proof, Proof);
+        wasm.snarkVerify(retptr, verifying_key.__wbg_ptr, 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 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}
+ */
+function stringToField(string) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(string, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.stringToField(retptr, ptr0, len0);
+        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 Field.__wrap(r0);
+    } 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
@@ -13191,6 +14216,10 @@ function __wbg_get_imports(memory) {
             const ret = Field.__unwrap(getObject(arg0));
             return ret;
         },
+        __wbg_from_291708c278f9eb83: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
         __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
             getObject(arg0).getRandomValues(getObject(arg1));
         }, arguments); },
@@ -13214,6 +14243,10 @@ function __wbg_get_imports(memory) {
             const ret = Group.__wrap(arg0);
             return addHeapObject(ret);
         },
+        __wbg_group_unwrap: function(arg0) {
+            const ret = Group.__unwrap(getObject(arg0));
+            return ret;
+        },
         __wbg_has_393943c179c58bfe: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.has(getObject(arg0), getObject(arg1));
             return ret;
@@ -13242,6 +14275,10 @@ function __wbg_get_imports(memory) {
             const ret = result;
             return ret;
         },
+        __wbg_isArray_2efa5973cef6ec32: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
         __wbg_iterator_e77d2b7575cca5a7: function() {
             const ret = Symbol.iterator;
             return addHeapObject(ret);
@@ -13262,7 +14299,7 @@ function __wbg_get_imports(memory) {
             const ret = getObject(arg0).length;
             return ret;
         },
-        __wbg_log_aa601feca8d69ed7: function(arg0, arg1) {
+        __wbg_log_50a68fe5eae22785: function(arg0, arg1) {
             console.log(getStringFromWasm0(arg0, arg1));
         },
         __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
@@ -13312,7 +14349,7 @@ function __wbg_get_imports(memory) {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6934(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_7051(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -13334,7 +14371,7 @@ function __wbg_get_imports(memory) {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6934(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_7051(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -13496,7 +14533,7 @@ function __wbg_get_imports(memory) {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_spawnWorker_f36316fbdd1713a5: function(arg0, arg1, arg2, arg3) {
+        __wbg_spawnWorker_b6845553df24e4a0: function(arg0, arg1, arg2, arg3) {
             const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
             return addHeapObject(ret);
         },
@@ -13592,22 +14629,22 @@ function __wbg_get_imports(memory) {
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 311, function: Function { arguments: [Externref], shim_idx: 312, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1521, __wasm_bindgen_func_elem_6940);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1528, __wasm_bindgen_func_elem_7057);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 311, function: Function { arguments: [Externref], shim_idx: 325, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1521, __wasm_bindgen_func_elem_1522);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1528, __wasm_bindgen_func_elem_1529);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 311, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 325, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1521, __wasm_bindgen_func_elem_1522_2);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1528, __wasm_bindgen_func_elem_1529_2);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 311, function: Function { arguments: [], shim_idx: 445, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1521, __wasm_bindgen_func_elem_6589);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1528, __wasm_bindgen_func_elem_6706);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function(arg0) {
@@ -13674,22 +14711,22 @@ function __wbg_get_imports(memory) {
     };
 }
 
-function __wasm_bindgen_func_elem_6589(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_6589(arg0, arg1);
+function __wasm_bindgen_func_elem_6706(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_6706(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_1522(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_1522(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_1529(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1529(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1522_2(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_1522_2(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_1529_2(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1529_2(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_6940(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_7057(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_6940(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_7057(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -13700,8 +14737,8 @@ function __wasm_bindgen_func_elem_6940(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_6934(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_6934(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_7051(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_7051(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 
@@ -13811,6 +14848,9 @@ const ProgramFinalization = (typeof FinalizationRegistry === 'undefined')
 const ProgramManagerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_programmanager_free(ptr >>> 0, 1));
+const ProofFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_proof_free(ptr >>> 0, 1));
 const ProvingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_provingkey_free(ptr >>> 0, 1));
@@ -13850,6 +14890,9 @@ const U64Finalization = (typeof FinalizationRegistry === 'undefined')
 const U8Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_u8_free(ptr >>> 0, 1));
+const ValueFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_value_free(ptr >>> 0, 1));
 const VerifyingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_verifyingkey_free(ptr >>> 0, 1));
@@ -14257,6 +15300,7 @@ var exports$1 = /*#__PURE__*/Object.freeze({
     PrivateKeyCiphertext: PrivateKeyCiphertext,
     Program: Program,
     ProgramManager: ProgramManager,
+    Proof: Proof,
     ProvingKey: ProvingKey,
     ProvingRequest: ProvingRequest,
     RecordCiphertext: RecordCiphertext,
@@ -14270,6 +15314,7 @@ var exports$1 = /*#__PURE__*/Object.freeze({
     U32: U32,
     U64: U64,
     U8: U8,
+    Value: Value,
     VerifyingKey: VerifyingKey,
     ViewKey: ViewKey,
     default: __wbg_init,
@@ -14277,6 +15322,9 @@ var exports$1 = /*#__PURE__*/Object.freeze({
     initSync: initSync,
     initThreadPool: initThreadPool,
     runRayonThread: runRayonThread,
+    snarkVerify: snarkVerify,
+    snarkVerifyBatch: snarkVerifyBatch,
+    stringToField: stringToField,
     verifyFunctionExecution: verifyFunctionExecution
 });