@provablehq/wasm 0.9.2 → 0.9.4-offline

package/dist/mainnet/worker.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(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_526(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"];
@@ -544,6 +549,256 @@ class Address {
     }
 }
 
+const AuthorizationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authorization_free(ptr >>> 0, 1));
+/**
+ * Authorization object containing the authorization for a transaction.
+ */
+class Authorization {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Authorization.prototype);
+        obj.__wbg_ptr = ptr;
+        AuthorizationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AuthorizationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_authorization_free(ptr, 0);
+    }
+    /**
+     * Create a new authorization from a request object.
+     *
+     * @param {ExecutionRequest} request The ExecutionRequest to build the authorization from.
+     * @param {ExecutionRequest} request
+     * @returns {Authorization}
+     */
+    static new(request) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(request, ExecutionRequest);
+            var ptr0 = request.__destroy_into_raw();
+            wasm.authorization_new(retptr, ptr0);
+            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 Authorization.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns a new and independent replica of the Authorization.
+     * @returns {Authorization}
+     */
+    replicate() {
+        const ret = wasm.authorization_replicate(this.__wbg_ptr);
+        return Authorization.__wrap(ret);
+    }
+    /**
+     * Returns the string representation of the Authorization.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authorization_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);
+        }
+    }
+    /**
+     * Reconstructs an Authorization object from its string representation.
+     *
+     * @param {String} authorization The string representation of the Authorization.
+     * @param {string} authorization
+     * @returns {Authorization}
+     */
+    static fromString(authorization) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(authorization, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.authorization_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 Authorization.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the left-endian byte representation of the Authorization.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authorization_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);
+        }
+    }
+    /**
+     * Creates an authorization object from a left-endian byte representation of an Authorization.
+     *
+     * @param {Uint8Array} bytes Left-endian bytes representing the Authorization.
+     * @param {Uint8Array} bytes
+     * @returns {Authorization}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authorization_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 Authorization.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Check if an Authorization object is the same as another.
+     *
+     * @param {Authorization} other The Authorization object to determine equality with.
+     * @param {Authorization} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, Authorization);
+        const ret = wasm.authorization_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns the number of `Request`s in the Authorization.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.authorization_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Return `true` if the Authorization is empty.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.authorization_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns `true` if the Authorization is for `credits.aleo/fee_private`.
+     * @returns {boolean}
+     */
+    isFeePrivate() {
+        const ret = wasm.authorization_isFeePrivate(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns `true` if the Authorization is for `credits.aleo/fee_public`.
+     * @returns {boolean}
+     */
+    isFeePublic() {
+        const ret = wasm.authorization_isFeePublic(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns `true` if the Authorization is for `credits.aleo/split`.
+     * @returns {boolean}
+     */
+    isSplit() {
+        const ret = wasm.authorization_isSplit(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Insert a transition into the Authorization.
+     *
+     * @param {Transition} transition The transition object to insert into the Authorization.
+     * @param {Transition} transition
+     */
+    insertTransition(transition) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(transition, Transition);
+            var ptr0 = transition.__destroy_into_raw();
+            wasm.authorization_insertTransition(retptr, this.__wbg_ptr, ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the transitions in an Authorization.
+     *
+     * @returns {Array<Transition>} Array of transition objects
+     * @returns {Array<any>}
+     */
+    transitions() {
+        const ret = wasm.authorization_transitions(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Returns the execution ID for the Authorization.
+     *
+     * @returns {Field} The execution ID for the Authorization, call toString() after this result to get the string representation.
+     * @returns {Field}
+     */
+    toExecutionId() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authorization_toExecutionId(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 Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
 const BHP1024Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bhp1024_free(ptr >>> 0, 1));
@@ -1120,105 +1375,360 @@ class BHP768 {
     }
 }
 
-const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
+const BooleanFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_boolean_free(ptr >>> 0, 1));
 /**
- * SnarkVM Ciphertext object. A Ciphertext represents an symmetrically encrypted plaintext. This
- * object provides decryption methods to recover the plaintext from the ciphertext (given the
- * api consumer has the proper decryption materials).
- *
- * @example
+ * Boolean element.
  */
-class Ciphertext {
+class Boolean {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Ciphertext.prototype);
+        const obj = Object.create(Boolean.prototype);
         obj.__wbg_ptr = ptr;
-        CiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
+        BooleanFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CiphertextFinalization.unregister(this);
+        BooleanFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ciphertext_free(ptr, 0);
+        wasm.__wbg_boolean_free(ptr, 0);
     }
     /**
-     * Decrypt the ciphertext using the given view key.
-     *
-     * @param {ViewKey} viewKey The view key of the account that encrypted the ciphertext.
-     * @param {Group} nonce The nonce used to encrypt the ciphertext.
-     *
-     * @returns {Plaintext} The decrypted plaintext.
-     * @param {ViewKey} view_key
-     * @param {Group} nonce
-     * @returns {Plaintext}
+     * Creates a Boolean from a native JS bool.
+     * @param {boolean} value
      */
-    decrypt(view_key, nonce) {
+    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);
-            _assertClass(view_key, ViewKey);
-            var ptr0 = view_key.__destroy_into_raw();
-            _assertClass(nonce, Group);
-            var ptr1 = nonce.__destroy_into_raw();
-            wasm.ciphertext_decrypt(retptr, this.__wbg_ptr, ptr0, ptr1);
+            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 Plaintext.__wrap(r0);
+            return Boolean.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Decrypt a ciphertext using the view key of the transition signer, transition public key, and
-     * (program, function, index) tuple.
-     * @param {ViewKey} view_key
-     * @param {Group} transition_public_key
-     * @param {string} program
-     * @param {string} function_name
-     * @param {number} index
-     * @returns {Plaintext}
+     * Returns the string representation of the boolean element.
+     * @returns {string}
      */
-    decryptWithTransitionInfo(view_key, transition_public_key, program, function_name, index) {
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(view_key, ViewKey);
-            var ptr0 = view_key.__destroy_into_raw();
-            _assertClass(transition_public_key, Group);
-            var ptr1 = transition_public_key.__destroy_into_raw();
-            const ptr2 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passStringToWasm0(function_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.ciphertext_decryptWithTransitionInfo(retptr, this.__wbg_ptr, ptr0, ptr1, ptr2, len2, ptr3, len3, index);
+            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 Plaintext.__wrap(r0);
+            return Boolean.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
         }
     }
     /**
-     * Decrypt a ciphertext using the transition view key and a (program, function, index) tuple.
-     * @param {Field} transition_view_key
-     * @param {string} program
-     * @param {string} function_name
+     * 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));
+/**
+ * SnarkVM Ciphertext object. A Ciphertext represents an symmetrically encrypted plaintext. This
+ * object provides decryption methods to recover the plaintext from the ciphertext (given the
+ * api consumer has the proper decryption materials).
+ */
+class Ciphertext {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Ciphertext.prototype);
+        obj.__wbg_ptr = ptr;
+        CiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CiphertextFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ciphertext_free(ptr, 0);
+    }
+    /**
+     * Decrypt the ciphertext using the given view key.
+     *
+     * @param {ViewKey} viewKey The view key of the account that encrypted the ciphertext.
+     * @param {Group} nonce The nonce used to encrypt the ciphertext.
+     *
+     * @returns {Plaintext} The decrypted plaintext.
+     * @param {ViewKey} view_key
+     * @param {Group} nonce
+     * @returns {Plaintext}
+     */
+    decrypt(view_key, nonce) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(view_key, ViewKey);
+            var ptr0 = view_key.__destroy_into_raw();
+            _assertClass(nonce, Group);
+            var ptr1 = nonce.__destroy_into_raw();
+            wasm.ciphertext_decrypt(retptr, this.__wbg_ptr, ptr0, ptr1);
+            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);
+        }
+    }
+    /**
+     * 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
+     * @param {string} function_name
+     * @param {number} index
+     * @returns {Plaintext}
+     */
+    decryptWithTransitionInfo(view_key, transition_public_key, program, function_name, index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(view_key, ViewKey);
+            var ptr0 = view_key.__destroy_into_raw();
+            _assertClass(transition_public_key, Group);
+            var ptr1 = transition_public_key.__destroy_into_raw();
+            const ptr2 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(function_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.ciphertext_decryptWithTransitionInfo(retptr, this.__wbg_ptr, ptr0, ptr1, ptr2, len2, ptr3, len3, index);
+            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);
+        }
+    }
+    /**
+     * 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
      * @param {number} index
      * @returns {Plaintext}
      */
@@ -1518,58 +2028,307 @@ class ComputeKey {
         return Scalar.__wrap(ret);
     }
     /**
-     * Get the pr_tag of the compute key.
+     * Get the pr_tag of the compute key.
+     *
+     * @returns {Group} pr_tag
+     * @returns {Group}
+     */
+    pk_sig() {
+        const ret = wasm.address_toGroup(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Get the pr_sig of the compute key.
+     *
+     * @returns {Group} pr_sig
+     * @returns {Group}
+     */
+    pr_sig() {
+        const ret = wasm.computekey_pr_sig(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+}
+
+const EncryptionToolkitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encryptiontoolkit_free(ptr >>> 0, 1));
+
+class EncryptionToolkit {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncryptionToolkitFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encryptiontoolkit_free(ptr, 0);
+    }
+    /**
+     * 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}
+     */
+    static generateTvk(view_key, tpk) {
+        _assertClass(view_key, ViewKey);
+        _assertClass(tpk, Group);
+        const ret = wasm.encryptiontoolkit_generateTvk(view_key.__wbg_ptr, tpk.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * 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}
+     */
+    static generateRecordViewKey(view_key, record_ciphertext) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(view_key, ViewKey);
+            _assertClass(record_ciphertext, RecordCiphertext);
+            wasm.encryptiontoolkit_generateRecordViewKey(retptr, view_key.__wbg_ptr, record_ciphertext.__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 Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * 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}
+     */
+    static decryptRecordWithRVk(record_vk, record_ciphertext) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(record_vk, Field);
+            _assertClass(record_ciphertext, RecordCiphertext);
+            wasm.encryptiontoolkit_decryptRecordWithRVk(retptr, record_vk.__wbg_ptr, record_ciphertext.__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);
+        }
+    }
+    /**
+     * 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}
+     */
+    static decryptTransitionWithVk(transition, transition_vk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(transition, Transition);
+            _assertClass(transition_vk, Field);
+            wasm.encryptiontoolkit_decryptTransitionWithVk(retptr, transition.__wbg_ptr, transition_vk.__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 Transition.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
+const ExecutionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_execution_free(ptr >>> 0, 1));
+/**
+ * Execution of an Aleo program.
+ */
+class Execution {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Execution.prototype);
+        obj.__wbg_ptr = ptr;
+        ExecutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExecutionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_execution_free(ptr, 0);
+    }
+    /**
+     * Returns the string representation of the execution.
+     *
+     * @returns {string} The string representation of the execution.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.execution_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 an execution object from a string representation of an execution.
+     *
+     * @returns {Execution | Error} The wasm representation of an execution object.
+     * @param {string} execution
+     * @returns {Execution}
+     */
+    static fromString(execution) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(execution, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.execution_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 Execution.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the global state root of the execution.
+     *
+     * @returns {Execution | Error} The global state root used in the execution.
+     * @returns {string}
+     */
+    globalStateRoot() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.execution_globalStateRoot(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);
+        }
+    }
+    /**
+     * Returns the proof of the execution.
      *
-     * @returns {Group} pr_tag
-     * @returns {Group}
+     * @returns {string} The execution proof.
+     * @returns {string}
      */
-    pk_sig() {
-        const ret = wasm.address_toGroup(this.__wbg_ptr);
-        return Group.__wrap(ret);
+    proof() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.execution_proof(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);
+        }
     }
     /**
-     * Get the pr_sig of the compute key.
+     * Returns the transitions present in the execution.
      *
-     * @returns {Group} pr_sig
-     * @returns {Group}
+     * @returns Array<Transition> the array of transitions present in the execution.
+     * @returns {Array<any>}
      */
-    pr_sig() {
-        const ret = wasm.computekey_pr_sig(this.__wbg_ptr);
-        return Group.__wrap(ret);
+    transitions() {
+        const ret = wasm.execution_transitions(this.__wbg_ptr);
+        return takeObject(ret);
     }
 }
 
-const ExecutionFinalization = (typeof FinalizationRegistry === 'undefined')
+const ExecutionRequestFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_execution_free(ptr >>> 0, 1));
-/**
- * Execution of an Aleo program.
- */
-class Execution {
+    : new FinalizationRegistry(ptr => wasm.__wbg_executionrequest_free(ptr >>> 0, 1));
+
+class ExecutionRequest {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Execution.prototype);
+        const obj = Object.create(ExecutionRequest.prototype);
         obj.__wbg_ptr = ptr;
-        ExecutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        ExecutionRequestFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ExecutionFinalization.unregister(this);
+        ExecutionRequestFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_execution_free(ptr, 0);
+        wasm.__wbg_executionrequest_free(ptr, 0);
     }
     /**
-     * Returns the string representation of the execution.
+     * Returns the request as a string.
      *
-     * @returns {string} The string representation of the execution.
+     * @returns {string} String representation of the request.
      * @returns {string}
      */
     toString() {
@@ -1577,7 +2336,7 @@ class Execution {
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.execution_toString(retptr, this.__wbg_ptr);
+            wasm.executionrequest_toString(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1589,41 +2348,94 @@ class Execution {
         }
     }
     /**
-     * Creates an execution object from a string representation of an execution.
+     * Builds a request object from a string representation of a request.
      *
-     * @returns {Execution | Error} The wasm representation of an execution object.
-     * @param {string} execution
-     * @returns {Execution}
+     * @param {string} request String representation of the request.
+     * @param {string} request
+     * @returns {ExecutionRequest}
      */
-    static fromString(execution) {
+    static fromString(request) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(execution, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const ptr0 = passStringToWasm0(request, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
             const len0 = WASM_VECTOR_LEN;
-            wasm.execution_fromString(retptr, ptr0, len0);
+            wasm.executionrequest_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 Execution.__wrap(r0);
+            return ExecutionRequest.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Returns the global state root of the execution.
-     *
-     * @returns {Execution | Error} The global state root used in the execution.
+     * Returns the bytes representation of the request.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.executionrequest_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);
+        }
+    }
+    /**
+     * Creates an request object from a bytes representation of an request.
+     * @param {Uint8Array} bytes
+     * @returns {ExecutionRequest}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.executionrequest_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 ExecutionRequest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the request signer.
+     * @returns {Address}
+     */
+    signer() {
+        const ret = wasm.address_toGroup(this.__wbg_ptr);
+        return Address.__wrap(ret);
+    }
+    /**
+     * Returns the network ID.
+     * @returns {number}
+     */
+    network_id() {
+        const ret = wasm.executionrequest_network_id(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the program ID.
      * @returns {string}
      */
-    globalStateRoot() {
+    program_id() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.execution_globalStateRoot(retptr, this.__wbg_ptr);
+            wasm.executionrequest_program_id(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1635,17 +2447,15 @@ class Execution {
         }
     }
     /**
-     * Returns the proof of the execution.
-     *
-     * @returns {string} The execution proof.
+     * Returns the function name.
      * @returns {string}
      */
-    proof() {
+    function_name() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.execution_proof(retptr, this.__wbg_ptr);
+            wasm.executionrequest_function_name(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1657,15 +2467,127 @@ class Execution {
         }
     }
     /**
-     * Returns the transitions present in the execution.
-     *
-     * @returns Array<Transition> the array of transitions present in the execution.
+     * Returns the input IDs for the transition.
      * @returns {Array<any>}
      */
-    transitions() {
-        const ret = wasm.execution_transitions(this.__wbg_ptr);
+    input_ids() {
+        const ret = wasm.executionrequest_input_ids(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Returns the function inputs as an array of strings.
+     * @returns {Array<any>}
+     */
+    inputs() {
+        const ret = wasm.executionrequest_inputs(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * Returns the signature for the transition.
+     * @returns {Signature}
+     */
+    signature() {
+        const ret = wasm.executionrequest_signature(this.__wbg_ptr);
+        return Signature.__wrap(ret);
+    }
+    /**
+     * Returns the tag secret key `sk_tag`.
+     * @returns {Field}
+     */
+    sk_tag() {
+        const ret = wasm.executionrequest_sk_tag(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Returns the transition view key `tvk`.
+     * @returns {Field}
+     */
+    tvk() {
+        const ret = wasm.executionrequest_tvk(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Returns the transition public key `tpk`.
+     * @returns {Group}
+     */
+    to_tpk() {
+        const ret = wasm.executionrequest_to_tpk(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Returns the transition commitment `tcm`.
+     * @returns {Field}
+     */
+    tcm() {
+        const ret = wasm.executionrequest_tcm(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Returns the signer commitment `scm`.
+     * @returns {Field}
+     */
+    scm() {
+        const ret = wasm.executionrequest_scm(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Create a new request by signing over a program ID and set of inputs.
+     *
+     * @param {PrivateKey} private_key The private key of the signer.
+     * @param {string} program_id The id of the program to create the signature for.
+     * @param {string} function_name The function name to create the signature for.
+     * @param {string[]} inputs The inputs to the function.
+     * @param {string[]} input_types The input types of the function.
+     * @param {Field | undefined} root_tvk The tvk of the function at the top of the call graph. This is undefined if this request is built for the top-level call or if there is only one function in the call graph.
+     * @param {boolean} is_root Flag to indicate if this is the top level function in the call graph.
+     * @param {PrivateKey} private_key
+     * @param {string} program_id
+     * @param {string} function_name
+     * @param {Array<any>} inputs
+     * @param {Array<any>} input_types
+     * @param {Field | null | undefined} root_tvk
+     * @param {boolean} is_root
+     * @returns {ExecutionRequest}
+     */
+    static sign(private_key, program_id, function_name, inputs, input_types, root_tvk, is_root) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(private_key, PrivateKey);
+            var ptr0 = private_key.__destroy_into_raw();
+            const ptr1 = passStringToWasm0(program_id, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(function_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len2 = WASM_VECTOR_LEN;
+            let ptr3 = 0;
+            if (!isLikeNone(root_tvk)) {
+                _assertClass(root_tvk, Field);
+                ptr3 = root_tvk.__destroy_into_raw();
+            }
+            wasm.executionrequest_sign(retptr, ptr0, ptr1, len1, ptr2, len2, addHeapObject(inputs), addHeapObject(input_types), ptr3, is_root);
+            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);
+        }
+    }
+    /**
+     * Verify the input types within a request.
+     *
+     * @param {string[]} The input_types within the request.
+     * @param {boolean} Flag to indicate whether this request is the first function in the call graph.
+     * @param {Array<any>} input_types
+     * @param {boolean} is_root
+     * @returns {boolean}
+     */
+    verify(input_types, is_root) {
+        const ret = wasm.executionrequest_verify(this.__wbg_ptr, addHeapObject(input_types), is_root);
+        return ret !== 0;
+    }
 }
 
 const ExecutionResponseFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -2281,7 +3203,7 @@ class Group {
     toFields() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.group_toFields(retptr, this.__wbg_ptr);
+            wasm.address_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);
@@ -2314,7 +3236,7 @@ class Group {
      * @returns {Group}
      */
     clone() {
-        const ret = wasm.group_clone(this.__wbg_ptr);
+        const ret = wasm.address_toGroup(this.__wbg_ptr);
         return Group.__wrap(ret);
     }
     /**
@@ -2806,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
      */
@@ -2830,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) {
@@ -2838,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
      */
@@ -2861,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() {
@@ -2881,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}
      */
@@ -3203,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}
@@ -3226,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}
      */
@@ -3297,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() {
@@ -3340,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() {
@@ -3372,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() {
@@ -4632,29 +5581,108 @@ class Program {
      * console.log(imports === expected_imports); // Output should be "true"
      * @returns {Array<any>}
      */
-    getImports() {
-        const ret = wasm.program_getImports(this.__wbg_ptr);
+    getImports() {
+        const ret = wasm.program_getImports(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+
+const ProgramManagerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_programmanager_free(ptr >>> 0, 1));
+
+class ProgramManager {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProgramManagerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_programmanager_free(ptr, 0);
+    }
+    /**
+     * Create an execution `Authorization` for a given program:function tuple with specified inputs.
+     *
+     * @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 authorize(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_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
+     * any previously created authorization by calling (authorization.toExecutionId()).
+     *
+     * @param private_key The private key of the signer.
+     * @param deployment_or_execution_id The id of the deployment or execution to authorize the fee program for.
+     * @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
+     * @returns {Authorization}
+     * @param {PrivateKey} private_key
+     * @param {string} deployment_or_execution_id
+     * @param {number} base_fee_credits
+     * @param {number} priority_fee_credits
+     * @param {RecordPlaintext | null} [fee_record]
+     * @returns {Promise<Authorization>}
+     */
+    static authorizeFee(private_key, deployment_or_execution_id, base_fee_credits, priority_fee_credits, fee_record) {
+        _assertClass(private_key, PrivateKey);
+        const ptr0 = passStringToWasm0(deployment_or_execution_id, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(fee_record)) {
+            _assertClass(fee_record, RecordPlaintext);
+            ptr1 = fee_record.__destroy_into_raw();
+        }
+        const ret = wasm.programmanager_authorizeFee(private_key.__wbg_ptr, ptr0, len0, base_fee_credits, priority_fee_credits, ptr1);
         return takeObject(ret);
     }
-}
-
-const ProgramManagerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_programmanager_free(ptr >>> 0, 1));
-
-class ProgramManager {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ProgramManagerFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_programmanager_free(ptr, 0);
-    }
     /**
      * Deploy an Aleo program
      *
@@ -5055,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.
      *
@@ -5179,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
@@ -5199,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')
@@ -5567,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));
@@ -5620,7 +6868,7 @@ class RecordCiphertext {
         }
     }
     /**
-     * Return the string reprensentation of the record ciphertext
+     * Return the string representation of the record ciphertext
      *
      * @returns {string} String representation of the record ciphertext
      * @returns {string}
@@ -5666,6 +6914,21 @@ class RecordCiphertext {
             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.recordciphertext_recordViewKey(this.__wbg_ptr, view_key.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
     /**
      * Determines if the account corresponding to the view key is the owner of the record
      *
@@ -5734,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() {
@@ -5753,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() {
@@ -5761,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() {
@@ -5778,6 +7047,42 @@ class RecordCiphertext {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Decrypt the record ciphertext into plaintext using a record view key.
+     *
+     * @param {Field} record_vk Record view key used to decrypt the record.
+     *
+     * @returns {RecordPlaintext}
+     * @param {Field} record_vk
+     * @returns {RecordPlaintext}
+     */
+    decryptWithRecordViewKey(record_vk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(record_vk, Field);
+            var ptr0 = record_vk.__destroy_into_raw();
+            wasm.recordciphertext_decryptWithRecordViewKey(retptr, this.__wbg_ptr, ptr0);
+            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);
+        }
+    }
+    /**
+     * Get the record nonce.
+     *
+     * @returns {Group} The record nonce.
+     * @returns {Group}
+     */
+    nonce() {
+        const ret = wasm.recordciphertext_nonce(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
 }
 
 const RecordPlaintextFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -5810,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);
@@ -5834,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}
@@ -5857,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}
      */
@@ -5879,6 +7193,8 @@ class RecordPlaintext {
     }
     /**
      * Get the owner of the record.
+     *
+     * @returns {Address} Address of the owner of the record.
      * @returns {Address}
      */
     owner() {
@@ -6097,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);
@@ -6114,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);
         }
     }
     /**
@@ -6157,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')
@@ -6456,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);
     }
     /**
@@ -6946,7 +8281,6 @@ class Transaction {
         }
     }
     /**
-     * Get the
      * Get the type of the transaction (will return "deploy" or "execute")
      *
      * @returns {string} Transaction type
@@ -7259,6 +8593,8 @@ class Transition {
     }
     /**
      * Get the transition public key of the transition.
+     *
+     * @returns {Group} Transition public key
      * @returns {Group}
      */
     tpk() {
@@ -7267,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}
      */
@@ -7277,6 +8617,8 @@ class Transition {
     }
     /**
      * Get the transition commitment of the transition.
+     *
+     * @returns {Field} Transition commitment
      * @returns {Field}
      */
     tcm() {
@@ -7285,12 +8627,39 @@ class Transition {
     }
     /**
      * Get the transition signer commitment of the transition.
+     *
+     * @returns {Field} Transition signer commitment
      * @returns {Field}
      */
     scm() {
         const ret = wasm.transition_scm(this.__wbg_ptr);
         return Field.__wrap(ret);
     }
+    /**
+     * Decrypt the transition using the transition view key.
+     *
+     * @param {Field} tvk The transition view key.
+     *
+     * @returns {Transition} The transition with public values for inputs and outputs.
+     * @param {Field} tvk
+     * @returns {Transition}
+     */
+    decryptTransition(tvk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(tvk, Field);
+            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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Transition.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 
 const VerifyingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -7785,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);
     }
     /**
@@ -7912,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();
     };
@@ -7930,6 +9302,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).async;
         return ret;
     };
+    imports.wbg.__wbg_authorization_new = function(arg0) {
+        const ret = Authorization.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
@@ -7946,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);
@@ -7977,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);
     };
@@ -8042,7 +9422,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_c2efb44aadd442a1 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_b1cdcca99372fe6e = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
@@ -8060,7 +9440,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_526(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_606(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -8156,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;
@@ -8200,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);
     };
@@ -8239,7 +9627,7 @@ function __wbg_get_imports() {
         const ret = Signature.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_901bb736b5f301e9 = 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);
     };
@@ -8359,12 +9747,16 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper6083 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 519, __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_wrapper6089 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 519, __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) {
@@ -8440,7 +9832,7 @@ function __wbg_get_imports() {
 }
 
 function __wbg_init_memory(imports, memory) {
-    imports.wbg.memory = memory || new WebAssembly.Memory({initial:22,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) {
@@ -8508,13 +9900,17 @@ async function __wbg_init(module_or_path, memory) {
 var exports = /*#__PURE__*/Object.freeze({
     __proto__: null,
     Address: Address,
+    Authorization: Authorization,
     BHP1024: BHP1024,
     BHP256: BHP256,
     BHP512: BHP512,
     BHP768: BHP768,
+    Boolean: Boolean,
     Ciphertext: Ciphertext,
     ComputeKey: ComputeKey,
+    EncryptionToolkit: EncryptionToolkit,
     Execution: Execution,
+    ExecutionRequest: ExecutionRequest,
     ExecutionResponse: ExecutionResponse,
     Field: Field,
     GraphKey: GraphKey,
@@ -8533,6 +9929,7 @@ var exports = /*#__PURE__*/Object.freeze({
     Program: Program,
     ProgramManager: ProgramManager,
     ProvingKey: ProvingKey,
+    ProvingRequest: ProvingRequest,
     RecordCiphertext: RecordCiphertext,
     RecordPlaintext: RecordPlaintext,
     Scalar: Scalar,