@provablehq/wasm 0.9.3 → 0.9.4-offline-rc

package/dist/mainnet/index.js

@@ -209,11 +209,12 @@ function passArray8ToWasm0(arg, malloc) {
  * @param {VerifyingKey} verifying_key
  * @param {Program} program
  * @param {string} function_id
- * @param {object | null} [imports]
- * @param {object | null} [imported_verifying_keys]
+ * @param {object | null | undefined} imports
+ * @param {object | null | undefined} imported_verifying_keys
+ * @param {number} block_height
  * @returns {boolean}
  */
-function verifyFunctionExecution(execution, verifying_key, program, function_id, imports, imported_verifying_keys) {
+function verifyFunctionExecution(execution, verifying_key, program, function_id, imports, imported_verifying_keys, block_height) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         _assertClass(execution, Execution);
@@ -221,7 +222,7 @@ function verifyFunctionExecution(execution, verifying_key, program, function_id,
         _assertClass(program, Program);
         const ptr0 = passStringToWasm0(function_id, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
         const len0 = WASM_VECTOR_LEN;
-        wasm.verifyFunctionExecution(retptr, execution.__wbg_ptr, verifying_key.__wbg_ptr, program.__wbg_ptr, ptr0, len0, isLikeNone(imports) ? 0 : addHeapObject(imports), isLikeNone(imported_verifying_keys) ? 0 : addHeapObject(imported_verifying_keys));
+        wasm.verifyFunctionExecution(retptr, execution.__wbg_ptr, verifying_key.__wbg_ptr, program.__wbg_ptr, ptr0, len0, isLikeNone(imports) ? 0 : addHeapObject(imports), isLikeNone(imported_verifying_keys) ? 0 : addHeapObject(imported_verifying_keys), block_height);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -263,12 +264,16 @@ function initThreadPool$1(url, num_threads) {
     return takeObject(ret);
 }
 
-function __wbg_adapter_40(arg0, arg1, arg2) {
-    wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
+function __wbg_adapter_40(arg0, arg1) {
+    wasm.__wbindgen_export_6(arg0, arg1);
 }
 
-function __wbg_adapter_571(arg0, arg1, arg2, arg3) {
-    wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_43(arg0, arg1, arg2) {
+    wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wbg_adapter_606(arg0, arg1, arg2, arg3) {
+    wasm.__wbindgen_export_8(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
@@ -1370,6 +1375,248 @@ class BHP768 {
     }
 }
 
+const BooleanFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_boolean_free(ptr >>> 0, 1));
+/**
+ * Boolean element.
+ */
+class Boolean {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Boolean.prototype);
+        obj.__wbg_ptr = ptr;
+        BooleanFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BooleanFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_boolean_free(ptr, 0);
+    }
+    /**
+     * Creates a Boolean from a native JS bool.
+     * @param {boolean} value
+     */
+    constructor(value) {
+        const ret = wasm.boolean_new(value);
+        this.__wbg_ptr = ret >>> 0;
+        BooleanFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Creates a boolean object from a string representation ("true"/"false").
+     * @param {string} boolean
+     * @returns {Boolean}
+     */
+    static fromString(boolean) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(boolean, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.boolean_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 Boolean.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the string representation of the boolean element.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.boolean_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_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Create a boolean element from a Uint8Array of left endian bytes.
+     * @param {Uint8Array} bytes
+     * @returns {Boolean}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.boolean_fromBytesLe(retptr, addBorrowedObject(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 Boolean.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Encode the boolean element as a Uint8Array of left endian bytes.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.boolean_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);
+        }
+    }
+    /**
+     * Reconstruct a boolean element from a boolean array representation.
+     * @param {Array<any>} bits
+     * @returns {Boolean}
+     */
+    static fromBitsLe(bits) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.boolean_fromBitsLe(retptr, addBorrowedObject(bits));
+            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 Boolean.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Get the left endian boolean array representation of the boolean element.
+     * @returns {Array<any>}
+     */
+    toBitsLe() {
+        const ret = wasm.boolean_toBitsLe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create a plaintext from the boolean element.
+     * @returns {Plaintext}
+     */
+    toPlaintext() {
+        const ret = wasm.boolean_toPlaintext(this.__wbg_ptr);
+        return Plaintext.__wrap(ret);
+    }
+    /**
+     * Clone the boolean element.
+     * @returns {Boolean}
+     */
+    clone() {
+        const ret = wasm.boolean_clone(this.__wbg_ptr);
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Generate a random boolean element.
+     * @returns {Boolean}
+     */
+    static random() {
+        const ret = wasm.boolean_random();
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Logical NOT.
+     * @returns {Boolean}
+     */
+    not() {
+        const ret = wasm.boolean_not(this.__wbg_ptr);
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Logical AND.
+     * @param {Boolean} other
+     * @returns {Boolean}
+     */
+    and(other) {
+        _assertClass(other, Boolean);
+        const ret = wasm.boolean_and(this.__wbg_ptr, other.__wbg_ptr);
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Logical OR.
+     * @param {Boolean} other
+     * @returns {Boolean}
+     */
+    or(other) {
+        _assertClass(other, Boolean);
+        const ret = wasm.boolean_or(this.__wbg_ptr, other.__wbg_ptr);
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Logical XOR.
+     * @param {Boolean} other
+     * @returns {Boolean}
+     */
+    xor(other) {
+        _assertClass(other, Boolean);
+        const ret = wasm.boolean_xor(this.__wbg_ptr, other.__wbg_ptr);
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Logical NAND.
+     * @param {Boolean} other
+     * @returns {Boolean}
+     */
+    nand(other) {
+        _assertClass(other, Boolean);
+        const ret = wasm.boolean_nand(this.__wbg_ptr, other.__wbg_ptr);
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Logical NOR.
+     * @param {Boolean} other
+     * @returns {Boolean}
+     */
+    nor(other) {
+        _assertClass(other, Boolean);
+        const ret = wasm.boolean_nor(this.__wbg_ptr, other.__wbg_ptr);
+        return Boolean.__wrap(ret);
+    }
+    /**
+     * Check if one boolean element equals another.
+     * @param {Boolean} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, Boolean);
+        const ret = wasm.boolean_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+
 const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr >>> 0, 1));
@@ -1432,6 +1679,14 @@ class Ciphertext {
     /**
      * Decrypt a ciphertext using the view key of the transition signer, transition public key, and
      * (program, function, index) tuple.
+     *
+     * @param {ViewKey} view_key The view key of the transition signer.
+     * @param {Group} transition_public_key The transition public key used to encrypt the ciphertext.
+     * @param {string} program The program ID associated with the ciphertext.
+     * @param {string} function_name The name of the function associated with the encrypted inputs and outputs.
+     * @param {u16} index The index of the input or output parameter that was encrypted.
+     *
+     * @returns {Plaintext} The decrypted plaintext.
      * @param {ViewKey} view_key
      * @param {Group} transition_public_key
      * @param {string} program
@@ -1464,6 +1719,13 @@ class Ciphertext {
     }
     /**
      * Decrypt a ciphertext using the transition view key and a (program, function, index) tuple.
+     *
+     * @param {Field} transition_view_key The transition view key that was used to encrypt the ciphertext.
+     * @param {string} program The program ID associated with the ciphertext.
+     * @param {string} function_name The name of the function associated with the encrypted inputs and outputs.
+     * @param {u16} index The index of the input or output parameter that was encrypted.
+     *
+     * @returns {Plaintext} The decrypted plaintext.
      * @param {Field} transition_view_key
      * @param {string} program
      * @param {string} function_name
@@ -1806,6 +2068,11 @@ class EncryptionToolkit {
     }
     /**
      * Generates a transition view key from the view key and the transition public key.
+     *
+     * @param {ViewKey} view_key The view key of the account that generated the transition.
+     * @param {Group} tpk The transition public key.
+     *
+     * @returns {Field} The transition view key.
      * @param {ViewKey} view_key
      * @param {Group} tpk
      * @returns {Field}
@@ -1818,6 +2085,11 @@ class EncryptionToolkit {
     }
     /**
      * Creates a record view key from the view key.  This can be later be used to decrypt a
+     *
+     * @param {ViewKey} view_key The view key of the owner of the record.
+     * @param {RecordCiphertext} record_ciphertext The record ciphertext used to derive the record view key.
+     *
+     * @returns {Field} The record view key.
      * @param {ViewKey} view_key
      * @param {RecordCiphertext} record_ciphertext
      * @returns {Field}
@@ -1842,6 +2114,11 @@ class EncryptionToolkit {
     /**
      * Decrypts a record ciphertext using the record view key.  Decryption only succeeds
      * if the record view key was generated from the view key of the record owner.
+     *
+     * @param {Field} record_vk The record view key.
+     * @param {RecordCiphertext} record_ciphertext The record ciphertext to decrypt.
+     *
+     * @returns {RecordPlaintext} The decrypted record plaintext.
      * @param {Field} record_vk
      * @param {RecordCiphertext} record_ciphertext
      * @returns {RecordPlaintext}
@@ -1866,6 +2143,11 @@ class EncryptionToolkit {
     /**
      * Decrypts a transition using the transition view key.  The ciphertext inputs and outputs
      * can only be decrypted if the transition view key was generated by the transaction signer.
+     *
+     * @param {Transition} transition The transition to decrypt.
+     * @param {Field} transition_vk The transition view key.
+     *
+     * @returns {Transition} The decrypted transition.
      * @param {Transition} transition
      * @param {Field} transition_vk
      * @returns {Transition}
@@ -2045,6 +2327,8 @@ class ExecutionRequest {
     }
     /**
      * Returns the request as a string.
+     *
+     * @returns {string} String representation of the request.
      * @returns {string}
      */
     toString() {
@@ -2065,6 +2349,8 @@ class ExecutionRequest {
     }
     /**
      * Builds a request object from a string representation of a request.
+     *
+     * @param {string} request String representation of the request.
      * @param {string} request
      * @returns {ExecutionRequest}
      */
@@ -3442,6 +3728,11 @@ class OfflineQuery {
     }
     /**
      * Creates a new offline query object. The state root is required to be passed in as a string
+     *
+     * @param {u32} block_height The block height.
+     * @param {string} state_root The state root of the current network.
+     *
+     * @returns {OfflineQuery} The newly created offline query object.
      * @param {number} block_height
      * @param {string} state_root
      */
@@ -3466,6 +3757,8 @@ class OfflineQuery {
     }
     /**
      * Add a new block height to the offline query object.
+     *
+     * @param {u32} block_height The block height to add.
      * @param {number} block_height
      */
     addBlockHeight(block_height) {
@@ -3474,8 +3767,8 @@ class OfflineQuery {
     /**
      * Add a new state path to the offline query object.
      *
-     * @param {string} commitment: The commitment corresponding to a record inpout
-     * @param {string} state_path: The state path corresponding to the commitment
+     * @param {string} commitment: The commitment corresponding to a record input.
+     * @param {string} state_path: The state path corresponding to the commitment.
      * @param {string} commitment
      * @param {string} state_path
      */
@@ -3497,7 +3790,9 @@ class OfflineQuery {
         }
     }
     /**
-     * Get a json string representation of the offline query object
+     * Get a json string representation of the offline query object.
+     *
+     * @returns {string} JSON string representation of the offline query object.
      * @returns {string}
      */
     toString() {
@@ -3517,7 +3812,9 @@ class OfflineQuery {
         }
     }
     /**
-     * Create an offline query object from a json string representation
+     * Create an offline query object from a json string representation.
+     *
+     * @param {string} JSON string representation of the offline query object.
      * @param {string} s
      * @returns {OfflineQuery}
      */
@@ -3839,6 +4136,11 @@ class Plaintext {
     }
     /**
      * Encrypt a plaintext with an address and randomizer.
+     *
+     * @param {Address} address The address to encrypt the plaintext for.
+     * @param {Scalar} randomizer The randomizer to use for encryption.
+     *
+     * @returns {Ciphertext} The encrypted ciphertext.
      * @param {Address} address
      * @param {Scalar} randomizer
      * @returns {Ciphertext}
@@ -3862,6 +4164,11 @@ class Plaintext {
     }
     /**
      * Encrypt a plaintext with a transition view key.
+     *
+     * @param {Field} transition_view_key The transition view key of the transition
+     * associated with the plaintext.
+     *
+     * @returns {Ciphertext} The encrypted ciphertext.
      * @param {Field} transition_view_key
      * @returns {Ciphertext}
      */
@@ -3933,6 +4240,8 @@ class Plaintext {
     }
     /**
      * Get the left endian byte array representation of the plaintext.
+     *
+     * @returns {Uint8Array} The left endian byte array representation of the plaintext.
      * @returns {Uint8Array}
      */
     toBytesLe() {
@@ -3976,6 +4285,8 @@ class Plaintext {
     }
     /**
      * Get the left endian boolean array representation of the bits of the plaintext.
+     *
+     * @returns {Array} The left endian boolean array representation of the bits of the plaintext.
      * @returns {Array<any>}
      */
     toBitsLe() {
@@ -4008,6 +4319,8 @@ class Plaintext {
     }
     /**
      * Get the field array representation of the plaintext.
+     *
+     * @returns {Array} The field array representation of the plaintext.
      * @returns {Array<any>}
      */
     toFields() {
@@ -5315,6 +5628,31 @@ class ProgramManager {
         const ret = wasm.programmanager_authorize(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), isLikeNone(imports) ? 0 : addHeapObject(imports));
         return takeObject(ret);
     }
+    /**
+     * Create an execution `Authorization` without generating a circuit. Use this function when
+     * fast delegated proving is needed.
+     *
+     * @param private_key The private key of the signer.
+     * @param program The program source code containing the function to authorize.
+     * @param function_name The function to authorize.
+     * @param inputs A javascript array of inputs to the function.
+     * @param imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
+     * @param {PrivateKey} private_key
+     * @param {string} program
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {object | null} [imports]
+     * @returns {Promise<Authorization>}
+     */
+    static buildAuthorizationUnchecked(private_key, program, function_name, inputs, imports) {
+        _assertClass(private_key, PrivateKey);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(function_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.programmanager_buildAuthorizationUnchecked(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), isLikeNone(imports) ? 0 : addHeapObject(imports));
+        return takeObject(ret);
+    }
     /**
      * 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
@@ -5745,6 +6083,48 @@ class ProgramManager {
         const ret = wasm.programmanager_buildJoinTransaction(private_key.__wbg_ptr, ptr0, ptr1, priority_fee_credits, ptr2, ptr3, len3, ptr4, ptr5, ptr6, ptr7, ptr8);
         return takeObject(ret);
     }
+    /**
+     * Create a `ProvingRequest` object. This object creates authorizations for the top level
+     * function and associated fee function. This object can be sent directly to a remote prover
+     * OR used to extract both execution and fee authorizations.
+     *
+     * @param private_key The private key of the signer.
+     * @param program The program source code containing the function to authorize.
+     * @param function_name The function to authorize.
+     * @param inputs A javascript array of inputs to the function.
+     * @param base_fee_credits The base fee to be paid for the authorization
+     * @param priority_fee_credits The optional priority fee to be paid for the transaction
+     * @param fee_record The record to spend the fee from
+     * @param imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
+     * @param url The url of the Aleo network node to send the transaction to
+     * @param broadcast (optional) Flag to indicate if the transaction should be broadcast
+     * @returns {Authorization}
+     * @param {PrivateKey} private_key
+     * @param {string} program
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {number} base_fee_credits
+     * @param {number} priority_fee_credits
+     * @param {RecordPlaintext | null | undefined} fee_record
+     * @param {object | null | undefined} imports
+     * @param {boolean} broadcast
+     * @param {boolean} unchecked
+     * @returns {Promise<ProvingRequest>}
+     */
+    static buildProvingRequest(private_key, program, function_name, inputs, base_fee_credits, priority_fee_credits, fee_record, imports, broadcast, unchecked) {
+        _assertClass(private_key, PrivateKey);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(function_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len1 = WASM_VECTOR_LEN;
+        let ptr2 = 0;
+        if (!isLikeNone(fee_record)) {
+            _assertClass(fee_record, RecordPlaintext);
+            ptr2 = fee_record.__destroy_into_raw();
+        }
+        const ret = wasm.programmanager_buildProvingRequest(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), base_fee_credits, priority_fee_credits, ptr2, isLikeNone(imports) ? 0 : addHeapObject(imports), broadcast, unchecked);
+        return takeObject(ret);
+    }
     /**
      * Split an Aleo credits record into two separate records. This function does not require a fee.
      *
@@ -5869,10 +6249,10 @@ class ProgramManager {
     /**
      * Synthesize proving and verifying keys for a program
      *
-     * @param program {string} The program source code of the program to synthesize keys for
-     * @param function_id {string} The function to synthesize keys for
-     * @param inputs {Array} The inputs to the function
-     * @param imports {Object | undefined} The imports for the program
+     * @param {string} program The program source code of the program to synthesize keys for
+     * @param {string} function_id The function to synthesize keys for
+     * @param {Array} inputs The inputs to the function
+     * @param {Object | undefined} imports The imports for the program
      * @param {PrivateKey} private_key
      * @param {string} program
      * @param {string} function_id
@@ -5889,6 +6269,14 @@ class ProgramManager {
         const ret = wasm.programmanager_synthesizeKeyPair(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), isLikeNone(imports) ? 0 : addHeapObject(imports));
         return takeObject(ret);
     }
+    /**
+     * @param {ProvingKey} proving_key
+     */
+    static loadInclusionProver(proving_key) {
+        _assertClass(proving_key, ProvingKey);
+        var ptr0 = proving_key.__destroy_into_raw();
+        wasm.programmanager_loadInclusionProver(ptr0);
+    }
 }
 
 const ProvingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -6257,6 +6645,176 @@ class ProvingKey {
     }
 }
 
+const ProvingRequestFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_provingrequest_free(ptr >>> 0, 1));
+/**
+ * Represents a proving request to a prover.
+ */
+class ProvingRequest {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ProvingRequest.prototype);
+        obj.__wbg_ptr = ptr;
+        ProvingRequestFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProvingRequestFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_provingrequest_free(ptr, 0);
+    }
+    /**
+     * Creates a new ProvingRequest from a function Authorization and an optional fee Authorization.
+     *
+     * @param {Authorization} authorization An Authorization for a function.
+     * @param {Authorization} fee_authorization The authorization for the `credits.aleo/fee_public` or `credits.aleo/fee_private` function that pays the fee for the execution of the main function.
+     * @param {boolean} broadcast Flag that indicates whether the remote proving service should attempt to submit the transaction on the caller's behalf.
+     * @param {Authorization} authorization
+     * @param {Authorization | null | undefined} fee_authorization
+     * @param {boolean} broadcast
+     * @returns {ProvingRequest}
+     */
+    static new(authorization, fee_authorization, broadcast) {
+        _assertClass(authorization, Authorization);
+        var ptr0 = authorization.__destroy_into_raw();
+        let ptr1 = 0;
+        if (!isLikeNone(fee_authorization)) {
+            _assertClass(fee_authorization, Authorization);
+            ptr1 = fee_authorization.__destroy_into_raw();
+        }
+        const ret = wasm.provingrequest_new(ptr0, ptr1, broadcast);
+        return ProvingRequest.__wrap(ret);
+    }
+    /**
+     * Creates a ProvingRequest from a string representation.
+     *
+     * @param {Uint8Array} request String representation of the ProvingRequest.
+     * @param {string} request
+     * @returns {ProvingRequest}
+     */
+    static fromString(request) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(request, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.provingrequest_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 ProvingRequest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a string representation of the ProvingRequest.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.provingrequest_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_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Creates a ProvingRequest from a left-endian byte representation of the ProvingRequest.
+     *
+     * @param {Uint8Array} bytes Left-endian bytes representing the proving request.
+     * @param {Uint8Array} bytes
+     * @returns {ProvingRequest}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.provingrequest_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 ProvingRequest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a left-endian byte representation of the ProvingRequest.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.provingrequest_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);
+        }
+    }
+    /**
+     * Get the Authorization of the main function in the ProvingRequest.
+     * @returns {Authorization}
+     */
+    authorization() {
+        const ret = wasm.provingrequest_authorization(this.__wbg_ptr);
+        return Authorization.__wrap(ret);
+    }
+    /**
+     * Get the fee Authorization in the ProvingRequest.
+     * @returns {Authorization | undefined}
+     */
+    feeAuthorization() {
+        const ret = wasm.provingrequest_feeAuthorization(this.__wbg_ptr);
+        return ret === 0 ? undefined : Authorization.__wrap(ret);
+    }
+    /**
+     * Get the broadcast flag set in the ProvingRequest.
+     * @returns {boolean}
+     */
+    broadcast() {
+        const ret = wasm.provingrequest_broadcast(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if a ProvingRequest is the same as another ProvingRequest.
+     * @param {ProvingRequest} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, ProvingRequest);
+        const ret = wasm.provingrequest_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+
 const RecordCiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_recordciphertext_free(ptr >>> 0, 1));
@@ -6439,6 +6997,8 @@ class RecordCiphertext {
     }
     /**
      * Get the left endian byte array representation of the record ciphertext.
+     *
+     * @returns {Uint8Array} Left endian byte array representation of the record ciphertext.
      * @returns {Uint8Array}
      */
     toBytesLe() {
@@ -6458,6 +7018,8 @@ class RecordCiphertext {
     }
     /**
      * Get the left endian boolean array representation of the record ciphertext bits.
+     *
+     * returns {Array} Left endian boolean array representation of the bits of the record ciphertext.
      * @returns {Array<any>}
      */
     toBitsLe() {
@@ -6466,6 +7028,8 @@ class RecordCiphertext {
     }
     /**
      * Get the field array representation of the record ciphertext.
+     *
+     * @returns {Array} Field array representation of the record ciphertext.
      * @returns {Array<any>}
      */
     toFields() {
@@ -6511,6 +7075,8 @@ class RecordCiphertext {
     }
     /**
      * Get the record nonce.
+     *
+     * @returns {Group} The record nonce.
      * @returns {Group}
      */
     nonce() {
@@ -6549,16 +7115,19 @@ class RecordPlaintext {
     /**
      * @param {string} program_id
      * @param {string} record_name
+     * @param {string} record_view_key
      * @returns {Field}
      */
-    commitment(program_id, record_name) {
+    commitment(program_id, record_name, record_view_key) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(program_id, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(record_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
             const len1 = WASM_VECTOR_LEN;
-            wasm.recordplaintext_commitment(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            const ptr2 = passStringToWasm0(record_view_key, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.recordplaintext_commitment(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -6573,7 +7142,8 @@ class RecordPlaintext {
     /**
      * Return a record plaintext from a string.
      *
-     * @param {string} record String representation of a plaintext representation of an Aleo record
+     * @param {string} record String representation of a plaintext representation of an Aleo record.
+     *
      * @returns {RecordPlaintext} Record plaintext
      * @param {string} record
      * @returns {RecordPlaintext}
@@ -6596,6 +7166,11 @@ class RecordPlaintext {
         }
     }
     /**
+     * Get the record entry matching a key.
+     *
+     * @param {string} input The key to retrieve the value in the record data field.
+     *
+     * @returns {Plaintext} The plaintext value corresponding to the key.
      * @param {string} input
      * @returns {Plaintext}
      */
@@ -6618,6 +7193,8 @@ class RecordPlaintext {
     }
     /**
      * Get the owner of the record.
+     *
+     * @returns {Address} Address of the owner of the record.
      * @returns {Address}
      */
     owner() {
@@ -6836,16 +7413,18 @@ class RecordPlaintext {
      * @param {PrivateKey} private_key Private key of the account that owns the record
      * @param {string} program_id Program ID of the program that the record is associated with
      * @param {string} record_name Name of the record
+     * @param {string} record_view_key The string representation of the record view key.
      *
      * @returns {string} Serial number of the record
      * @param {PrivateKey} private_key
      * @param {string} program_id
      * @param {string} record_name
+     * @param {string} record_view_key
      * @returns {string}
      */
-    serialNumberString(private_key, program_id, record_name) {
-        let deferred4_0;
-        let deferred4_1;
+    serialNumberString(private_key, program_id, record_name, record_view_key) {
+        let deferred5_0;
+        let deferred5_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(private_key, PrivateKey);
@@ -6853,23 +7432,25 @@ class RecordPlaintext {
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(record_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
             const len1 = WASM_VECTOR_LEN;
-            wasm.recordplaintext_serialNumberString(retptr, this.__wbg_ptr, private_key.__wbg_ptr, ptr0, len0, ptr1, len1);
+            const ptr2 = passStringToWasm0(record_view_key, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.recordplaintext_serialNumberString(retptr, this.__wbg_ptr, private_key.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             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);
-            var ptr3 = r0;
-            var len3 = r1;
+            var ptr4 = r0;
+            var len4 = r1;
             if (r3) {
-                ptr3 = 0; len3 = 0;
+                ptr4 = 0; len4 = 0;
                 throw takeObject(r2);
             }
-            deferred4_0 = ptr3;
-            deferred4_1 = len3;
-            return getStringFromWasm0(ptr3, len3);
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+            wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
         }
     }
     /**
@@ -6896,6 +7477,21 @@ class RecordPlaintext {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Generate the record view key. The record view key can only decrypt record if the
+     * supplied view key belongs to the record owner.
+     *
+     * @param {ViewKey} view_key View key used to generate the record view key
+     *
+     * @returns {Group} record view key
+     * @param {ViewKey} view_key
+     * @returns {Field}
+     */
+    recordViewKey(view_key) {
+        _assertClass(view_key, ViewKey);
+        const ret = wasm.recordplaintext_recordViewKey(this.__wbg_ptr, view_key.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
 }
 
 const ScalarFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -7195,7 +7791,7 @@ class Signature {
         _assertClass(private_key, PrivateKey);
         const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.privatekey_sign(private_key.__wbg_ptr, ptr0, len0);
+        const ret = wasm.signature_sign(private_key.__wbg_ptr, ptr0, len0);
         return Signature.__wrap(ret);
     }
     /**
@@ -7997,6 +8593,8 @@ class Transition {
     }
     /**
      * Get the transition public key of the transition.
+     *
+     * @returns {Group} Transition public key
      * @returns {Group}
      */
     tpk() {
@@ -8005,6 +8603,10 @@ class Transition {
     }
     /**
      * Get the transition view key of the transition.
+     *
+     * @param {ViewKey} view_key The view key of the transition signer.
+     *
+     * @returns {Field} Transition view key
      * @param {ViewKey} view_key
      * @returns {Field}
      */
@@ -8015,6 +8617,8 @@ class Transition {
     }
     /**
      * Get the transition commitment of the transition.
+     *
+     * @returns {Field} Transition commitment
      * @returns {Field}
      */
     tcm() {
@@ -8023,6 +8627,8 @@ class Transition {
     }
     /**
      * Get the transition signer commitment of the transition.
+     *
+     * @returns {Field} Transition signer commitment
      * @returns {Field}
      */
     scm() {
@@ -8042,7 +8648,7 @@ class Transition {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(tvk, Field);
-            wasm.encryptiontoolkit_decryptTransitionWithVk(retptr, this.__wbg_ptr, tvk.__wbg_ptr);
+            wasm.transition_decryptTransition(retptr, this.__wbg_ptr, tvk.__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);
@@ -8548,7 +9154,7 @@ class ViewKey {
      */
     static from_private_key(private_key) {
         _assertClass(private_key, PrivateKey);
-        const ret = wasm.privatekey_to_view_key(private_key.__wbg_ptr);
+        const ret = wasm.viewkey_from_private_key(private_key.__wbg_ptr);
         return ViewKey.__wrap(ret);
     }
     /**
@@ -8675,6 +9281,9 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbg_abort_410ec47a64ac6117 = function(arg0, arg1) {
+        getObject(arg0).abort(getObject(arg1));
+    };
     imports.wbg.__wbg_abort_775ef1d17fc65868 = function(arg0) {
         getObject(arg0).abort();
     };
@@ -8713,6 +9322,10 @@ function __wbg_get_imports() {
         const ret = Ciphertext.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_clearTimeout_86721db0036bea98 = function(arg0) {
+        const ret = clearTimeout(takeObject(arg0));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_crypto_ed58b8e10a292839 = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -8744,7 +9357,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).fetch(getObject(arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_fetch_f1856afdb49415d1 = function(arg0) {
+    imports.wbg.__wbg_fetch_d36a73832f0a45e8 = function(arg0) {
         const ret = fetch(getObject(arg0));
         return addHeapObject(ret);
     };
@@ -8809,7 +9422,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_112b57e1bd7dc2f1 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_b1cdcca99372fe6e = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
@@ -8827,7 +9440,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_571(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_606(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -8923,6 +9536,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).process;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_provingrequest_new = function(arg0) {
+        const ret = ProvingRequest.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_push_737cfc8c1432c2c6 = function(arg0, arg1) {
         const ret = getObject(arg0).push(getObject(arg1));
         return ret;
@@ -8967,6 +9584,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_send_40a47636ff90f64d = function() { return handleError(function (arg0) {
         getObject(arg0).send();
     }, arguments) };
+    imports.wbg.__wbg_setTimeout_2e707715f8cc9497 = function(arg0, arg1) {
+        const ret = setTimeout(getObject(arg0), arg1);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
@@ -9006,7 +9627,7 @@ function __wbg_get_imports() {
         const ret = Signature.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_e58e27d3efb914e4 = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_41e51220404b3348 = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -9126,12 +9747,16 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper6258 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 520, __wbg_adapter_40);
+    imports.wbg.__wbindgen_closure_wrapper6193 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 470, __wbg_adapter_40);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper6795 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 470, __wbg_adapter_43);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper6264 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 520, __wbg_adapter_40);
+    imports.wbg.__wbindgen_closure_wrapper6799 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 470, __wbg_adapter_43);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_is_function = function(arg0) {
@@ -9207,7 +9832,7 @@ function __wbg_get_imports() {
 }
 
 function __wbg_init_memory(imports, memory) {
-    imports.wbg.memory = memory || new WebAssembly.Memory({initial:23,maximum:65536,shared:true});
+    imports.wbg.memory = memory || new WebAssembly.Memory({initial:119,maximum:65536,shared:true});
 }
 
 function __wbg_finalize_init(instance, module, thread_stack_size) {
@@ -9286,5 +9911,5 @@ async function initThreadPool(threads) {
     await initThreadPool$1(new URL("worker.js", import.meta.url), threads);
 }
 
-export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Ciphertext, ComputeKey, EncryptionToolkit, Execution, ExecutionRequest, ExecutionResponse, Field, GraphKey, Group, KeyPair, Metadata, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, ProvingKey, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, VerifyingKey, ViewKey, initSync, initThreadPool, runRayonThread, verifyFunctionExecution };
+export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Boolean, Ciphertext, ComputeKey, EncryptionToolkit, Execution, ExecutionRequest, ExecutionResponse, Field, GraphKey, Group, KeyPair, Metadata, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, VerifyingKey, ViewKey, initSync, initThreadPool, runRayonThread, verifyFunctionExecution };
 //# sourceMappingURL=index.js.map