@provablehq/wasm 0.9.2 → 0.9.3

package/dist/testnet/index.js

@@ -267,7 +267,7 @@ function __wbg_adapter_40(arg0, arg1, arg2) {
     wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wbg_adapter_526(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_571(arg0, arg1, arg2, arg3) {
     wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
@@ -544,6 +544,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));
@@ -1127,8 +1377,6 @@ const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
  * 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
  */
 class Ciphertext {
 
@@ -1528,48 +1776,275 @@ class ComputeKey {
         return Group.__wrap(ret);
     }
     /**
-     * Get the pr_sig of the compute key.
+     * 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
+     * @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
+     * @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
+     * @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
+     * @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 {string} The execution proof.
+     * @returns {string}
+     */
+    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);
+        }
+    }
+    /**
+     * 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 {string} The string representation of the execution.
+     * Returns the request as a string.
      * @returns {string}
      */
     toString() {
@@ -1577,7 +2052,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 +2064,92 @@ class Execution {
         }
     }
     /**
-     * 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}
+     * Builds a request object from a string representation of a 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 +2161,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 +2181,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 +2917,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 +2950,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);
     }
     /**
@@ -4655,6 +5291,60 @@ class ProgramManager {
         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 `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);
+    }
     /**
      * Deploy an Aleo program
      *
@@ -5620,7 +6310,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 +6356,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
      *
@@ -5778,6 +6483,40 @@ 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}
+     */
+    nonce() {
+        const ret = wasm.recordciphertext_nonce(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
 }
 
 const RecordPlaintextFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -6946,7 +7685,6 @@ class Transaction {
         }
     }
     /**
-     * Get the
      * Get the type of the transaction (will return "deploy" or "execute")
      *
      * @returns {string} Transaction type
@@ -7291,6 +8029,31 @@ class Transition {
         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.encryptiontoolkit_decryptTransitionWithVk(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')
@@ -7930,6 +8693,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);
@@ -8042,7 +8809,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_c2efb44aadd442a1 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_112b57e1bd7dc2f1 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
@@ -8060,7 +8827,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_571(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -8239,7 +9006,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_e58e27d3efb914e4 = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -8359,12 +9126,12 @@ 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_wrapper6258 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 520, __wbg_adapter_40);
         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_wrapper6264 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 520, __wbg_adapter_40);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_is_function = function(arg0) {
@@ -8440,7 +9207,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:23,maximum:65536,shared:true});
 }
 
 function __wbg_finalize_init(instance, module, thread_stack_size) {
@@ -8519,5 +9286,5 @@ async function initThreadPool(threads) {
     await initThreadPool$1(new URL("worker.js", import.meta.url), threads);
 }
 
-export { Address, BHP1024, BHP256, BHP512, BHP768, Ciphertext, ComputeKey, Execution, 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, 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 };
 //# sourceMappingURL=index.js.map