@puzzlehq/aleo-wasm-web 0.6.11 → 0.6.12

package/aleo_wasm.js

@@ -1,4 +1,4 @@
-import { spawnWorker } from './snippets/aleo-wasm-665eb111429d19b5/inline0.js';
+import { spawnWorker } from './snippets/aleo-wasm-7414781f25a5869a/inline0.js';
 
 let wasm;
 
@@ -22,24 +22,6 @@ function takeObject(idx) {
     return ret;
 }
 
-const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
-
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
-
-let cachedUint8Memory0 = null;
-
-function getUint8Memory0() {
-    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
-        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8Memory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
-}
-
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
     const idx = heap_next;
@@ -51,6 +33,15 @@ function addHeapObject(obj) {
 
 let WASM_VECTOR_LEN = 0;
 
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
@@ -118,6 +109,15 @@ function getInt32Memory0() {
     return cachedInt32Memory0;
 }
 
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -231,10 +231,42 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+let cachedBigInt64Memory0 = null;
+
+function getBigInt64Memory0() {
+    if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
+        cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
+    }
+    return cachedBigInt64Memory0;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
 }
+/**
+* @param {number} receiver
+*/
+export function runRayonThread(receiver) {
+    wasm.runRayonThread(receiver);
+}
+
+/**
+*/
+export function init_panic_hook() {
+    wasm.init_panic_hook();
+}
+
+/**
+* @param {URL} url
+* @param {number} num_threads
+* @returns {Promise<void>}
+*/
+export function initThreadPool(url, num_threads) {
+    const ret = wasm.initThreadPool(addHeapObject(url), num_threads);
+    return takeObject(ret);
+}
+
 /**
 * Verify an execution with a single function and a single transition. Executions with multiple
 * transitions or functions will fail to verify. Also, this does not verify that the state root of
@@ -272,37 +304,6 @@ export function verifyFunctionExecution(execution, verifying_key, program, funct
     }
 }
 
-/**
-* @param {number} receiver
-*/
-export function runRayonThread(receiver) {
-    wasm.runRayonThread(receiver);
-}
-
-let cachedBigInt64Memory0 = null;
-
-function getBigInt64Memory0() {
-    if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
-        cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
-    }
-    return cachedBigInt64Memory0;
-}
-/**
-*/
-export function init_panic_hook() {
-    wasm.init_panic_hook();
-}
-
-/**
-* @param {URL} url
-* @param {number} num_threads
-* @returns {Promise<void>}
-*/
-export function initThreadPool(url, num_threads) {
-    const ret = wasm.initThreadPool(addHeapObject(url), num_threads);
-    return takeObject(ret);
-}
-
 function handleError(f, args) {
     try {
         return f.apply(this, args);
@@ -310,7 +311,7 @@ function handleError(f, args) {
         wasm.__wbindgen_exn_store(addHeapObject(e));
     }
 }
-function __wbg_adapter_291(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_295(arg0, arg1, arg2, arg3) {
     wasm.wasm_bindgen__convert__closures__invoke2_mut__h69b3d6b389ddc7fb(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
@@ -422,6 +423,72 @@ export class Address {
     }
 }
 
+const AuthorizationResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authorizationresponse_free(ptr >>> 0));
+/**
+*/
+export class AuthorizationResponse {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AuthorizationResponse.prototype);
+        obj.__wbg_ptr = ptr;
+        AuthorizationResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AuthorizationResponseFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_authorizationresponse_free(ptr);
+    }
+    /**
+    * @returns {string}
+    */
+    get authorization() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authorizationresponse_authorization(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get fee_authorization() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authorizationresponse_fee_authorization(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
 const ExecutionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_execution_free(ptr >>> 0));
@@ -1770,219 +1837,252 @@ export class ProgramManager {
         wasm.__wbg_programmanager_free(ptr);
     }
     /**
-    * Join two records together to create a new record with an amount of credits equal to the sum
-    * of the credits of the two original records
+    * @param {string} program
+    * @param {string} function_id
+    * @param {Array<any>} inputs_str
+    * @param {string} private_key
+    * @param {object | undefined} imports
+    * @param {bigint} fee_microcredits
+    * @param {string | undefined} [fee_record]
+    * @returns {Promise<AuthorizationResponse>}
+    */
+    static authExecute(program, function_id, inputs_str, private_key, imports, fee_microcredits, fee_record) {
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(function_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(private_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(fee_record) ? 0 : passStringToWasm0(fee_record, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.programmanager_authExecute(ptr0, len0, ptr1, len1, addHeapObject(inputs_str), ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), fee_microcredits, ptr3, len3);
+        return takeObject(ret);
+    }
+    /**
+    * Execute an arbitrary function locally
     *
-    * @param private_key The private key of the sender
-    * @param record_1 The first record to combine
-    * @param record_2 The second record to combine
-    * @param fee_credits The amount of credits to pay as a fee
-    * @param fee_record The record to spend the fee from
-    * @param url The url of the Aleo network node to send the transaction to
-    * @param join_proving_key (optional) Provide a proving key to use for the join function
-    * @param join_verifying_key (optional) Provide a verifying key to use for the join function
-    * @param fee_proving_key (optional) Provide a proving key to use for the fee execution
-    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
-    * @returns {Transaction | Error} Transaction object
+    * @param {PrivateKey} private_key The private key of the sender
+    * @param {string} program The source code of the program being executed
+    * @param {string} function The name of the function to execute
+    * @param {Array} inputs A javascript array of inputs to the function
+    * @param {boolean} prove_execution If true, the execution will be proven and an execution object
+    * containing the proof and the encrypted inputs and outputs needed to verify the proof offline
+    * will be returned.
+    * @param {boolean} cache Cache the proving and verifying keys in the Execution response.
+    * If this is set to 'true' the keys synthesized will be stored in the Execution Response
+    * and the `ProvingKey` and `VerifyingKey` can be retrieved from the response via the `.getKeys()`
+    * method.
+    * @param {Object | undefined} imports (optional) Provide a list of imports to use for the function execution in the
+    * form of a javascript object where the keys are a string of the program name and the values
+    * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
+    * @param {ProvingKey | undefined} proving_key (optional) Provide a verifying key to use for the function execution
+    * @param {VerifyingKey | undefined} verifying_key (optional) Provide a verifying key to use for the function execution
     * @param {PrivateKey} private_key
-    * @param {RecordPlaintext} record_1
-    * @param {RecordPlaintext} record_2
-    * @param {number} fee_credits
-    * @param {RecordPlaintext | undefined} [fee_record]
+    * @param {string} program
+    * @param {string} _function
+    * @param {Array<any>} inputs
+    * @param {boolean} prove_execution
+    * @param {boolean} cache
+    * @param {object | undefined} [imports]
+    * @param {ProvingKey | undefined} [proving_key]
+    * @param {VerifyingKey | undefined} [verifying_key]
     * @param {string | undefined} [url]
-    * @param {ProvingKey | undefined} [join_proving_key]
-    * @param {VerifyingKey | undefined} [join_verifying_key]
-    * @param {ProvingKey | undefined} [fee_proving_key]
-    * @param {VerifyingKey | undefined} [fee_verifying_key]
     * @param {OfflineQuery | undefined} [offline_query]
-    * @returns {Promise<Transaction>}
+    * @returns {Promise<ExecutionResponse>}
     */
-    static buildJoinTransaction(private_key, record_1, record_2, fee_credits, fee_record, url, join_proving_key, join_verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
+    static executeFunctionOffline(private_key, program, _function, inputs, prove_execution, cache, imports, proving_key, verifying_key, url, offline_query) {
         _assertClass(private_key, PrivateKey);
-        _assertClass(record_1, RecordPlaintext);
-        var ptr0 = record_1.__destroy_into_raw();
-        _assertClass(record_2, RecordPlaintext);
-        var ptr1 = record_2.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
         let ptr2 = 0;
-        if (!isLikeNone(fee_record)) {
-            _assertClass(fee_record, RecordPlaintext);
-            ptr2 = fee_record.__destroy_into_raw();
+        if (!isLikeNone(proving_key)) {
+            _assertClass(proving_key, ProvingKey);
+            ptr2 = proving_key.__destroy_into_raw();
         }
-        var ptr3 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len3 = WASM_VECTOR_LEN;
-        let ptr4 = 0;
-        if (!isLikeNone(join_proving_key)) {
-            _assertClass(join_proving_key, ProvingKey);
-            ptr4 = join_proving_key.__destroy_into_raw();
+        let ptr3 = 0;
+        if (!isLikeNone(verifying_key)) {
+            _assertClass(verifying_key, VerifyingKey);
+            ptr3 = verifying_key.__destroy_into_raw();
         }
+        var ptr4 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
         let ptr5 = 0;
-        if (!isLikeNone(join_verifying_key)) {
-            _assertClass(join_verifying_key, VerifyingKey);
-            ptr5 = join_verifying_key.__destroy_into_raw();
-        }
-        let ptr6 = 0;
-        if (!isLikeNone(fee_proving_key)) {
-            _assertClass(fee_proving_key, ProvingKey);
-            ptr6 = fee_proving_key.__destroy_into_raw();
+        if (!isLikeNone(offline_query)) {
+            _assertClass(offline_query, OfflineQuery);
+            ptr5 = offline_query.__destroy_into_raw();
         }
-        let ptr7 = 0;
-        if (!isLikeNone(fee_verifying_key)) {
-            _assertClass(fee_verifying_key, VerifyingKey);
-            ptr7 = fee_verifying_key.__destroy_into_raw();
-        }
-        let ptr8 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr8 = offline_query.__destroy_into_raw();
-        }
-        const ret = wasm.programmanager_buildJoinTransaction(private_key.__wbg_ptr, ptr0, ptr1, fee_credits, ptr2, ptr3, len3, ptr4, ptr5, ptr6, ptr7, ptr8);
-        return takeObject(ret);
-    }
-    /**
-    * Split an Aleo credits record into two separate records. This function does not require a fee.
-    *
-    * @param private_key The private key of the sender
-    * @param split_amount The amount of the credit split. This amount will be subtracted from the
-    * value of the record and two new records will be created with the split amount and the remainder
-    * @param amount_record The record to split
-    * @param url The url of the Aleo network node to send the transaction to
-    * @param split_proving_key (optional) Provide a proving key to use for the split function
-    * @param split_verifying_key (optional) Provide a verifying key to use for the split function
-    * @returns {Transaction | Error} Transaction object
-    * @param {PrivateKey} private_key
-    * @param {number} split_amount
-    * @param {RecordPlaintext} amount_record
-    * @param {string | undefined} [url]
-    * @param {ProvingKey | undefined} [split_proving_key]
-    * @param {VerifyingKey | undefined} [split_verifying_key]
-    * @param {OfflineQuery | undefined} [offline_query]
-    * @returns {Promise<Transaction>}
-    */
-    static buildSplitTransaction(private_key, split_amount, amount_record, url, split_proving_key, split_verifying_key, offline_query) {
-        _assertClass(private_key, PrivateKey);
-        _assertClass(amount_record, RecordPlaintext);
-        var ptr0 = amount_record.__destroy_into_raw();
-        var ptr1 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        let ptr2 = 0;
-        if (!isLikeNone(split_proving_key)) {
-            _assertClass(split_proving_key, ProvingKey);
-            ptr2 = split_proving_key.__destroy_into_raw();
-        }
-        let ptr3 = 0;
-        if (!isLikeNone(split_verifying_key)) {
-            _assertClass(split_verifying_key, VerifyingKey);
-            ptr3 = split_verifying_key.__destroy_into_raw();
-        }
-        let ptr4 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr4 = offline_query.__destroy_into_raw();
-        }
-        const ret = wasm.programmanager_buildSplitTransaction(private_key.__wbg_ptr, split_amount, ptr0, ptr1, len1, ptr2, ptr3, ptr4);
-        return takeObject(ret);
-    }
-    /**
-    * 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 {PrivateKey} private_key
-    * @param {string} program
-    * @param {string} function_id
-    * @param {Array<any>} inputs
-    * @param {object | undefined} [imports]
-    * @returns {Promise<KeyPair>}
-    */
-    static synthesizeKeyPair(private_key, program, function_id, inputs, imports) {
-        _assertClass(private_key, PrivateKey);
-        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(function_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.programmanager_synthesizeKeyPair(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), isLikeNone(imports) ? 0 : addHeapObject(imports));
+        const ret = wasm.programmanager_executeFunctionOffline(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), prove_execution, cache, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr2, ptr3, ptr4, len4, ptr5);
         return takeObject(ret);
     }
     /**
-    * Send credits from one Aleo account to another
+    * Execute Aleo function and create an Aleo execution transaction
     *
     * @param private_key The private key of the sender
-    * @param amount_credits The amount of credits to send
-    * @param recipient The recipient of the transaction
-    * @param transfer_type The type of the transfer (options: "private", "public", "private_to_public", "public_to_private")
-    * @param amount_record The record to fund the amount from
+    * @param program The source code of the program being executed
+    * @param function The name of the function to execute
+    * @param inputs A javascript array of inputs to the function
     * @param fee_credits The amount of credits to pay as a fee
     * @param fee_record The record to spend the fee from
     * @param url The url of the Aleo network node to send the transaction to
-    * @param transfer_verifying_key (optional) Provide a verifying key to use for the transfer
-    * function
+    * If this is set to 'true' the keys synthesized (or passed in as optional parameters via the
+    * `proving_key` and `verifying_key` arguments) will be stored in the ProgramManager's memory
+    * and used for subsequent transactions. If this is set to 'false' the proving and verifying
+    * keys will be deallocated from memory after the transaction is executed.
+    * @param imports (optional) Provide a list of imports to use for the function execution in the
+    * form of a javascript object where the keys are a string of the program name and the values
+    * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
+    * @param proving_key (optional) Provide a verifying key to use for the function execution
+    * @param verifying_key (optional) Provide a verifying key to use for the function execution
     * @param fee_proving_key (optional) Provide a proving key to use for the fee execution
     * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
     * @returns {Transaction | Error}
     * @param {PrivateKey} private_key
-    * @param {number} amount_credits
-    * @param {string} recipient
-    * @param {string} transfer_type
-    * @param {RecordPlaintext | undefined} amount_record
+    * @param {string} program
+    * @param {string} _function
+    * @param {Array<any>} inputs
     * @param {number} fee_credits
     * @param {RecordPlaintext | undefined} [fee_record]
     * @param {string | undefined} [url]
-    * @param {ProvingKey | undefined} [transfer_proving_key]
-    * @param {VerifyingKey | undefined} [transfer_verifying_key]
+    * @param {object | undefined} [imports]
+    * @param {ProvingKey | undefined} [proving_key]
+    * @param {VerifyingKey | undefined} [verifying_key]
     * @param {ProvingKey | undefined} [fee_proving_key]
     * @param {VerifyingKey | undefined} [fee_verifying_key]
     * @param {OfflineQuery | undefined} [offline_query]
     * @returns {Promise<Transaction>}
     */
-    static buildTransferTransaction(private_key, amount_credits, recipient, transfer_type, amount_record, fee_credits, fee_record, url, transfer_proving_key, transfer_verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
+    static buildExecutionTransaction(private_key, program, _function, inputs, fee_credits, fee_record, url, imports, proving_key, verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
         _assertClass(private_key, PrivateKey);
-        const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(transfer_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
         let ptr2 = 0;
-        if (!isLikeNone(amount_record)) {
-            _assertClass(amount_record, RecordPlaintext);
-            ptr2 = amount_record.__destroy_into_raw();
-        }
-        let ptr3 = 0;
         if (!isLikeNone(fee_record)) {
             _assertClass(fee_record, RecordPlaintext);
-            ptr3 = fee_record.__destroy_into_raw();
+            ptr2 = fee_record.__destroy_into_raw();
+        }
+        var ptr3 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        let ptr4 = 0;
+        if (!isLikeNone(proving_key)) {
+            _assertClass(proving_key, ProvingKey);
+            ptr4 = proving_key.__destroy_into_raw();
         }
-        var ptr4 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len4 = WASM_VECTOR_LEN;
         let ptr5 = 0;
-        if (!isLikeNone(transfer_proving_key)) {
-            _assertClass(transfer_proving_key, ProvingKey);
-            ptr5 = transfer_proving_key.__destroy_into_raw();
+        if (!isLikeNone(verifying_key)) {
+            _assertClass(verifying_key, VerifyingKey);
+            ptr5 = verifying_key.__destroy_into_raw();
         }
         let ptr6 = 0;
-        if (!isLikeNone(transfer_verifying_key)) {
-            _assertClass(transfer_verifying_key, VerifyingKey);
-            ptr6 = transfer_verifying_key.__destroy_into_raw();
-        }
-        let ptr7 = 0;
         if (!isLikeNone(fee_proving_key)) {
             _assertClass(fee_proving_key, ProvingKey);
-            ptr7 = fee_proving_key.__destroy_into_raw();
+            ptr6 = fee_proving_key.__destroy_into_raw();
         }
-        let ptr8 = 0;
+        let ptr7 = 0;
         if (!isLikeNone(fee_verifying_key)) {
             _assertClass(fee_verifying_key, VerifyingKey);
-            ptr8 = fee_verifying_key.__destroy_into_raw();
+            ptr7 = fee_verifying_key.__destroy_into_raw();
         }
-        let ptr9 = 0;
+        let ptr8 = 0;
         if (!isLikeNone(offline_query)) {
             _assertClass(offline_query, OfflineQuery);
-            ptr9 = offline_query.__destroy_into_raw();
+            ptr8 = offline_query.__destroy_into_raw();
         }
-        const ret = wasm.programmanager_buildTransferTransaction(private_key.__wbg_ptr, amount_credits, ptr0, len0, ptr1, len1, ptr2, fee_credits, ptr3, ptr4, len4, ptr5, ptr6, ptr7, ptr8, ptr9);
+        const ret = wasm.programmanager_buildExecutionTransaction(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), fee_credits, ptr2, ptr3, len3, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr4, ptr5, ptr6, ptr7, ptr8);
         return takeObject(ret);
     }
     /**
+    * Estimate Fee for Aleo function execution. Note if "cache" is set to true, the proving and
+    * verifying keys will be stored in the ProgramManager's memory and used for subsequent
+    * program executions.
+    *
+    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+    *
+    * @param private_key The private key of the sender
+    * @param program The source code of the program to estimate the execution fee for
+    * @param function The name of the function to execute
+    * @param inputs A javascript array of inputs to the function
+    * @param url The url of the Aleo network node to send the transaction to
+    * @param imports (optional) Provide a list of imports to use for the fee estimation in the
+    * form of a javascript object where the keys are a string of the program name and the values
+    * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
+    * @param proving_key (optional) Provide a verifying key to use for the fee estimation
+    * @param verifying_key (optional) Provide a verifying key to use for the fee estimation
+    * @returns {u64 | Error} Fee in microcredits
+    * @param {PrivateKey} private_key
+    * @param {string} program
+    * @param {string} _function
+    * @param {Array<any>} inputs
+    * @param {string | undefined} [url]
+    * @param {object | undefined} [imports]
+    * @param {ProvingKey | undefined} [proving_key]
+    * @param {VerifyingKey | undefined} [verifying_key]
+    * @param {OfflineQuery | undefined} [offline_query]
+    * @returns {Promise<bigint>}
+    */
+    static estimateExecutionFee(private_key, program, _function, inputs, url, imports, proving_key, verifying_key, offline_query) {
+        _assertClass(private_key, PrivateKey);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        let ptr3 = 0;
+        if (!isLikeNone(proving_key)) {
+            _assertClass(proving_key, ProvingKey);
+            ptr3 = proving_key.__destroy_into_raw();
+        }
+        let ptr4 = 0;
+        if (!isLikeNone(verifying_key)) {
+            _assertClass(verifying_key, VerifyingKey);
+            ptr4 = verifying_key.__destroy_into_raw();
+        }
+        let ptr5 = 0;
+        if (!isLikeNone(offline_query)) {
+            _assertClass(offline_query, OfflineQuery);
+            ptr5 = offline_query.__destroy_into_raw();
+        }
+        const ret = wasm.programmanager_estimateExecutionFee(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr3, ptr4, ptr5);
+        return takeObject(ret);
+    }
+    /**
+    * Estimate the finalize fee component for executing a function. This fee is additional to the
+    * size of the execution of the program in bytes. If the function does not have a finalize
+    * step, then the finalize fee is 0.
+    *
+    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+    *
+    * @param program The program containing the function to estimate the finalize fee for
+    * @param function The function to estimate the finalize fee for
+    * @returns {u64 | Error} Fee in microcredits
+    * @param {string} program
+    * @param {string} _function
+    * @returns {bigint}
+    */
+    static estimateFinalizeFee(program, _function) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.programmanager_estimateFinalizeFee(retptr, ptr0, len0, ptr1, len1);
+            var r0 = getBigInt64Memory0()[retptr / 8 + 0];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            return BigInt.asUintN(64, r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Deploy an Aleo program
     *
     * @param private_key The private key of the sender
@@ -2090,124 +2190,83 @@ export class ProgramManager {
         }
     }
     /**
-    * @param {string} program
-    * @param {string} function_id
-    * @param {Array<any>} inputs_str
-    * @param {string} private_key
-    * @param {object | undefined} [imports]
-    * @returns {Promise<string>}
-    */
-    static authExecute(program, function_id, inputs_str, private_key, imports) {
-        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(function_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(private_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.programmanager_authExecute(ptr0, len0, ptr1, len1, addHeapObject(inputs_str), ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports));
-        return takeObject(ret);
-    }
-    /**
-    * Execute an arbitrary function locally
+    * Split an Aleo credits record into two separate records. This function does not require a fee.
     *
-    * @param {PrivateKey} private_key The private key of the sender
-    * @param {string} program The source code of the program being executed
-    * @param {string} function The name of the function to execute
-    * @param {Array} inputs A javascript array of inputs to the function
-    * @param {boolean} prove_execution If true, the execution will be proven and an execution object
-    * containing the proof and the encrypted inputs and outputs needed to verify the proof offline
-    * will be returned.
-    * @param {boolean} cache Cache the proving and verifying keys in the Execution response.
-    * If this is set to 'true' the keys synthesized will be stored in the Execution Response
-    * and the `ProvingKey` and `VerifyingKey` can be retrieved from the response via the `.getKeys()`
-    * method.
-    * @param {Object | undefined} imports (optional) Provide a list of imports to use for the function execution in the
-    * form of a javascript object where the keys are a string of the program name and the values
-    * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
-    * @param {ProvingKey | undefined} proving_key (optional) Provide a verifying key to use for the function execution
-    * @param {VerifyingKey | undefined} verifying_key (optional) Provide a verifying key to use for the function execution
+    * @param private_key The private key of the sender
+    * @param split_amount The amount of the credit split. This amount will be subtracted from the
+    * value of the record and two new records will be created with the split amount and the remainder
+    * @param amount_record The record to split
+    * @param url The url of the Aleo network node to send the transaction to
+    * @param split_proving_key (optional) Provide a proving key to use for the split function
+    * @param split_verifying_key (optional) Provide a verifying key to use for the split function
+    * @returns {Transaction | Error} Transaction object
     * @param {PrivateKey} private_key
-    * @param {string} program
-    * @param {string} _function
-    * @param {Array<any>} inputs
-    * @param {boolean} prove_execution
-    * @param {boolean} cache
-    * @param {object | undefined} [imports]
-    * @param {ProvingKey | undefined} [proving_key]
-    * @param {VerifyingKey | undefined} [verifying_key]
+    * @param {number} split_amount
+    * @param {RecordPlaintext} amount_record
     * @param {string | undefined} [url]
+    * @param {ProvingKey | undefined} [split_proving_key]
+    * @param {VerifyingKey | undefined} [split_verifying_key]
     * @param {OfflineQuery | undefined} [offline_query]
-    * @returns {Promise<ExecutionResponse>}
+    * @returns {Promise<Transaction>}
     */
-    static executeFunctionOffline(private_key, program, _function, inputs, prove_execution, cache, imports, proving_key, verifying_key, url, offline_query) {
+    static buildSplitTransaction(private_key, split_amount, amount_record, url, split_proving_key, split_verifying_key, offline_query) {
         _assertClass(private_key, PrivateKey);
-        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
+        _assertClass(amount_record, RecordPlaintext);
+        var ptr0 = amount_record.__destroy_into_raw();
+        var ptr1 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
         let ptr2 = 0;
-        if (!isLikeNone(proving_key)) {
-            _assertClass(proving_key, ProvingKey);
-            ptr2 = proving_key.__destroy_into_raw();
+        if (!isLikeNone(split_proving_key)) {
+            _assertClass(split_proving_key, ProvingKey);
+            ptr2 = split_proving_key.__destroy_into_raw();
         }
         let ptr3 = 0;
-        if (!isLikeNone(verifying_key)) {
-            _assertClass(verifying_key, VerifyingKey);
-            ptr3 = verifying_key.__destroy_into_raw();
+        if (!isLikeNone(split_verifying_key)) {
+            _assertClass(split_verifying_key, VerifyingKey);
+            ptr3 = split_verifying_key.__destroy_into_raw();
         }
-        var ptr4 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len4 = WASM_VECTOR_LEN;
-        let ptr5 = 0;
+        let ptr4 = 0;
         if (!isLikeNone(offline_query)) {
             _assertClass(offline_query, OfflineQuery);
-            ptr5 = offline_query.__destroy_into_raw();
+            ptr4 = offline_query.__destroy_into_raw();
         }
-        const ret = wasm.programmanager_executeFunctionOffline(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), prove_execution, cache, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr2, ptr3, ptr4, len4, ptr5);
+        const ret = wasm.programmanager_buildSplitTransaction(private_key.__wbg_ptr, split_amount, ptr0, ptr1, len1, ptr2, ptr3, ptr4);
         return takeObject(ret);
     }
     /**
-    * Execute Aleo function and create an Aleo execution transaction
+    * Join two records together to create a new record with an amount of credits equal to the sum
+    * of the credits of the two original records
     *
     * @param private_key The private key of the sender
-    * @param program The source code of the program being executed
-    * @param function The name of the function to execute
-    * @param inputs A javascript array of inputs to the function
+    * @param record_1 The first record to combine
+    * @param record_2 The second record to combine
     * @param fee_credits The amount of credits to pay as a fee
     * @param fee_record The record to spend the fee from
     * @param url The url of the Aleo network node to send the transaction to
-    * If this is set to 'true' the keys synthesized (or passed in as optional parameters via the
-    * `proving_key` and `verifying_key` arguments) will be stored in the ProgramManager's memory
-    * and used for subsequent transactions. If this is set to 'false' the proving and verifying
-    * keys will be deallocated from memory after the transaction is executed.
-    * @param imports (optional) Provide a list of imports to use for the function execution in the
-    * form of a javascript object where the keys are a string of the program name and the values
-    * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
-    * @param proving_key (optional) Provide a verifying key to use for the function execution
-    * @param verifying_key (optional) Provide a verifying key to use for the function execution
+    * @param join_proving_key (optional) Provide a proving key to use for the join function
+    * @param join_verifying_key (optional) Provide a verifying key to use for the join function
     * @param fee_proving_key (optional) Provide a proving key to use for the fee execution
     * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
-    * @returns {Transaction | Error}
+    * @returns {Transaction | Error} Transaction object
     * @param {PrivateKey} private_key
-    * @param {string} program
-    * @param {string} _function
-    * @param {Array<any>} inputs
+    * @param {RecordPlaintext} record_1
+    * @param {RecordPlaintext} record_2
     * @param {number} fee_credits
     * @param {RecordPlaintext | undefined} [fee_record]
     * @param {string | undefined} [url]
-    * @param {object | undefined} [imports]
-    * @param {ProvingKey | undefined} [proving_key]
-    * @param {VerifyingKey | undefined} [verifying_key]
+    * @param {ProvingKey | undefined} [join_proving_key]
+    * @param {VerifyingKey | undefined} [join_verifying_key]
     * @param {ProvingKey | undefined} [fee_proving_key]
     * @param {VerifyingKey | undefined} [fee_verifying_key]
     * @param {OfflineQuery | undefined} [offline_query]
     * @returns {Promise<Transaction>}
     */
-    static buildExecutionTransaction(private_key, program, _function, inputs, fee_credits, fee_record, url, imports, proving_key, verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
+    static buildJoinTransaction(private_key, record_1, record_2, fee_credits, fee_record, url, join_proving_key, join_verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
         _assertClass(private_key, PrivateKey);
-        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
+        _assertClass(record_1, RecordPlaintext);
+        var ptr0 = record_1.__destroy_into_raw();
+        _assertClass(record_2, RecordPlaintext);
+        var ptr1 = record_2.__destroy_into_raw();
         let ptr2 = 0;
         if (!isLikeNone(fee_record)) {
             _assertClass(fee_record, RecordPlaintext);
@@ -2216,14 +2275,14 @@ export class ProgramManager {
         var ptr3 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len3 = WASM_VECTOR_LEN;
         let ptr4 = 0;
-        if (!isLikeNone(proving_key)) {
-            _assertClass(proving_key, ProvingKey);
-            ptr4 = proving_key.__destroy_into_raw();
+        if (!isLikeNone(join_proving_key)) {
+            _assertClass(join_proving_key, ProvingKey);
+            ptr4 = join_proving_key.__destroy_into_raw();
         }
         let ptr5 = 0;
-        if (!isLikeNone(verifying_key)) {
-            _assertClass(verifying_key, VerifyingKey);
-            ptr5 = verifying_key.__destroy_into_raw();
+        if (!isLikeNone(join_verifying_key)) {
+            _assertClass(join_verifying_key, VerifyingKey);
+            ptr5 = join_verifying_key.__destroy_into_raw();
         }
         let ptr6 = 0;
         if (!isLikeNone(fee_proving_key)) {
@@ -2240,96 +2299,108 @@ export class ProgramManager {
             _assertClass(offline_query, OfflineQuery);
             ptr8 = offline_query.__destroy_into_raw();
         }
-        const ret = wasm.programmanager_buildExecutionTransaction(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), fee_credits, ptr2, ptr3, len3, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr4, ptr5, ptr6, ptr7, ptr8);
+        const ret = wasm.programmanager_buildJoinTransaction(private_key.__wbg_ptr, ptr0, ptr1, fee_credits, ptr2, ptr3, len3, ptr4, ptr5, ptr6, ptr7, ptr8);
         return takeObject(ret);
     }
     /**
-    * Estimate Fee for Aleo function execution. Note if "cache" is set to true, the proving and
-    * verifying keys will be stored in the ProgramManager's memory and used for subsequent
-    * program executions.
-    *
-    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+    * Send credits from one Aleo account to another
     *
     * @param private_key The private key of the sender
-    * @param program The source code of the program to estimate the execution fee for
-    * @param function The name of the function to execute
-    * @param inputs A javascript array of inputs to the function
+    * @param amount_credits The amount of credits to send
+    * @param recipient The recipient of the transaction
+    * @param transfer_type The type of the transfer (options: "private", "public", "private_to_public", "public_to_private")
+    * @param amount_record The record to fund the amount from
+    * @param fee_credits The amount of credits to pay as a fee
+    * @param fee_record The record to spend the fee from
     * @param url The url of the Aleo network node to send the transaction to
-    * @param imports (optional) Provide a list of imports to use for the fee estimation in the
-    * form of a javascript object where the keys are a string of the program name and the values
-    * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
-    * @param proving_key (optional) Provide a verifying key to use for the fee estimation
-    * @param verifying_key (optional) Provide a verifying key to use for the fee estimation
-    * @returns {u64 | Error} Fee in microcredits
+    * @param transfer_verifying_key (optional) Provide a verifying key to use for the transfer
+    * function
+    * @param fee_proving_key (optional) Provide a proving key to use for the fee execution
+    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
+    * @returns {Transaction | Error}
     * @param {PrivateKey} private_key
-    * @param {string} program
-    * @param {string} _function
-    * @param {Array<any>} inputs
+    * @param {number} amount_credits
+    * @param {string} recipient
+    * @param {string} transfer_type
+    * @param {RecordPlaintext | undefined} amount_record
+    * @param {number} fee_credits
+    * @param {RecordPlaintext | undefined} [fee_record]
     * @param {string | undefined} [url]
-    * @param {object | undefined} [imports]
-    * @param {ProvingKey | undefined} [proving_key]
-    * @param {VerifyingKey | undefined} [verifying_key]
+    * @param {ProvingKey | undefined} [transfer_proving_key]
+    * @param {VerifyingKey | undefined} [transfer_verifying_key]
+    * @param {ProvingKey | undefined} [fee_proving_key]
+    * @param {VerifyingKey | undefined} [fee_verifying_key]
     * @param {OfflineQuery | undefined} [offline_query]
-    * @returns {Promise<bigint>}
+    * @returns {Promise<Transaction>}
     */
-    static estimateExecutionFee(private_key, program, _function, inputs, url, imports, proving_key, verifying_key, offline_query) {
+    static buildTransferTransaction(private_key, amount_credits, recipient, transfer_type, amount_record, fee_credits, fee_record, url, transfer_proving_key, transfer_verifying_key, fee_proving_key, fee_verifying_key, offline_query) {
         _assertClass(private_key, PrivateKey);
-        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(transfer_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len2 = WASM_VECTOR_LEN;
-        let ptr3 = 0;
-        if (!isLikeNone(proving_key)) {
-            _assertClass(proving_key, ProvingKey);
-            ptr3 = proving_key.__destroy_into_raw();
+        let ptr2 = 0;
+        if (!isLikeNone(amount_record)) {
+            _assertClass(amount_record, RecordPlaintext);
+            ptr2 = amount_record.__destroy_into_raw();
         }
-        let ptr4 = 0;
-        if (!isLikeNone(verifying_key)) {
-            _assertClass(verifying_key, VerifyingKey);
-            ptr4 = verifying_key.__destroy_into_raw();
+        let ptr3 = 0;
+        if (!isLikeNone(fee_record)) {
+            _assertClass(fee_record, RecordPlaintext);
+            ptr3 = fee_record.__destroy_into_raw();
         }
+        var ptr4 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
         let ptr5 = 0;
+        if (!isLikeNone(transfer_proving_key)) {
+            _assertClass(transfer_proving_key, ProvingKey);
+            ptr5 = transfer_proving_key.__destroy_into_raw();
+        }
+        let ptr6 = 0;
+        if (!isLikeNone(transfer_verifying_key)) {
+            _assertClass(transfer_verifying_key, VerifyingKey);
+            ptr6 = transfer_verifying_key.__destroy_into_raw();
+        }
+        let ptr7 = 0;
+        if (!isLikeNone(fee_proving_key)) {
+            _assertClass(fee_proving_key, ProvingKey);
+            ptr7 = fee_proving_key.__destroy_into_raw();
+        }
+        let ptr8 = 0;
+        if (!isLikeNone(fee_verifying_key)) {
+            _assertClass(fee_verifying_key, VerifyingKey);
+            ptr8 = fee_verifying_key.__destroy_into_raw();
+        }
+        let ptr9 = 0;
         if (!isLikeNone(offline_query)) {
             _assertClass(offline_query, OfflineQuery);
-            ptr5 = offline_query.__destroy_into_raw();
+            ptr9 = offline_query.__destroy_into_raw();
         }
-        const ret = wasm.programmanager_estimateExecutionFee(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr3, ptr4, ptr5);
+        const ret = wasm.programmanager_buildTransferTransaction(private_key.__wbg_ptr, amount_credits, ptr0, len0, ptr1, len1, ptr2, fee_credits, ptr3, ptr4, len4, ptr5, ptr6, ptr7, ptr8, ptr9);
         return takeObject(ret);
     }
-    /**
-    * Estimate the finalize fee component for executing a function. This fee is additional to the
-    * size of the execution of the program in bytes. If the function does not have a finalize
-    * step, then the finalize fee is 0.
-    *
-    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+    /**
+    * Synthesize proving and verifying keys for a program
     *
-    * @param program The program containing the function to estimate the finalize fee for
-    * @param function The function to estimate the finalize fee for
-    * @returns {u64 | Error} Fee in microcredits
+    * @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 {PrivateKey} private_key
     * @param {string} program
-    * @param {string} _function
-    * @returns {bigint}
+    * @param {string} function_id
+    * @param {Array<any>} inputs
+    * @param {object | undefined} [imports]
+    * @returns {Promise<KeyPair>}
     */
-    static estimateFinalizeFee(program, _function) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.programmanager_estimateFinalizeFee(retptr, ptr0, len0, ptr1, len1);
-            var r0 = getBigInt64Memory0()[retptr / 8 + 0];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            var r3 = getInt32Memory0()[retptr / 4 + 3];
-            if (r3) {
-                throw takeObject(r2);
-            }
-            return BigInt.asUintN(64, r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    static synthesizeKeyPair(private_key, program, function_id, inputs, imports) {
+        _assertClass(private_key, PrivateKey);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(function_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.programmanager_synthesizeKeyPair(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), isLikeNone(imports) ? 0 : addHeapObject(imports));
+        return takeObject(ret);
     }
 }
 
@@ -2361,133 +2432,6 @@ export class ProvingKey {
         wasm.__wbg_provingkey_free(ptr);
     }
     /**
-    * Return the checksum of the proving key
-    *
-    * @returns {string} Checksum of the proving key
-    * @returns {string}
-    */
-    checksum() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.provingkey_checksum(retptr, this.__wbg_ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-    * Create a copy of the proving key
-    *
-    * @returns {ProvingKey} A copy of the proving key
-    * @returns {ProvingKey}
-    */
-    copy() {
-        const ret = wasm.provingkey_copy(this.__wbg_ptr);
-        return ProvingKey.__wrap(ret);
-    }
-    /**
-    * Construct a new proving key from a byte array
-    *
-    * @param {Uint8Array} bytes Byte array representation of a proving key
-    * @returns {ProvingKey | Error}
-    * @param {Uint8Array} bytes
-    * @returns {ProvingKey}
-    */
-    static fromBytes(bytes) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.provingkey_fromBytes(retptr, ptr0, len0);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return ProvingKey.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Create a proving key from string
-    *
-    * @param {string | Error} String representation of the proving key
-    * @param {string} string
-    * @returns {ProvingKey}
-    */
-    static fromString(string) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.provingkey_fromString(retptr, ptr0, len0);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return ProvingKey.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Return the byte representation of a proving key
-    *
-    * @returns {Uint8Array | Error} Byte array representation of a proving key
-    * @returns {Uint8Array}
-    */
-    toBytes() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.provingkey_toBytes(retptr, this.__wbg_ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            var r3 = getInt32Memory0()[retptr / 4 + 3];
-            if (r3) {
-                throw takeObject(r2);
-            }
-            var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1, 1);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Get a string representation of the proving key
-    *
-    * @returns {string} String representation of the proving key
-    * @returns {string}
-    */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.provingkey_toString(retptr, this.__wbg_ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
     * Verify if the proving key is for the bond_public function
     *
     * @example
@@ -2642,46 +2586,173 @@ export class ProvingKey {
         return ret !== 0;
     }
     /**
-    * Verify if the proving key is for the transfer_public_to_private function
-    *
-    * @example
-    * const provingKey = ProvingKey.fromBytes("transfer_public_to_private_proving_key.bin");
-    * provingKey.isTransferPublicToPrivateProver() ? console.log("Key verified") : throw new Error("Invalid key");
+    * Verify if the proving key is for the transfer_public_to_private function
+    *
+    * @example
+    * const provingKey = ProvingKey.fromBytes("transfer_public_to_private_proving_key.bin");
+    * provingKey.isTransferPublicToPrivateProver() ? console.log("Key verified") : throw new Error("Invalid key");
+    *
+    * @returns {boolean} returns true if the proving key is for the transfer_public_to_private function, false if otherwise
+    * @returns {boolean}
+    */
+    isTransferPublicToPrivateProver() {
+        const ret = wasm.provingkey_isTransferPublicToPrivateProver(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Verify if the proving key is for the unbond_delegator_as_validator function
+    *
+    * @example
+    * const provingKey = ProvingKey.fromBytes("unbond_delegator_as_validator_proving_key.bin");
+    * provingKey.isUnbondDelegatorAsValidatorProver() ? console.log("Key verified") : throw new Error("Invalid key");
+    *
+    * @returns {boolean} returns true if the proving key is for the unbond_delegator_as_validator function, false if otherwise
+    * @returns {boolean}
+    */
+    isUnbondDelegatorAsValidatorProver() {
+        const ret = wasm.provingkey_isUnbondDelegatorAsValidatorProver(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Verify if the proving key is for the unbond_delegator_as_delegator function
+    *
+    * @example
+    * const provingKey = ProvingKey.fromBytes("unbond_delegator_as_delegator_proving_key.bin");
+    * provingKey.isUnbondDelegatorAsDelegatorProver() ? console.log("Key verified") : throw new Error("Invalid key");
+    *
+    * @returns {boolean} returns true if the proving key is for the unbond_delegator_as_delegator function, false if otherwise
+    * @returns {boolean}
+    */
+    isUnbondPublicProver() {
+        const ret = wasm.provingkey_isUnbondPublicProver(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Return the checksum of the proving key
+    *
+    * @returns {string} Checksum of the proving key
+    * @returns {string}
+    */
+    checksum() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.provingkey_checksum(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Create a copy of the proving key
+    *
+    * @returns {ProvingKey} A copy of the proving key
+    * @returns {ProvingKey}
+    */
+    copy() {
+        const ret = wasm.provingkey_copy(this.__wbg_ptr);
+        return ProvingKey.__wrap(ret);
+    }
+    /**
+    * Construct a new proving key from a byte array
+    *
+    * @param {Uint8Array} bytes Byte array representation of a proving key
+    * @returns {ProvingKey | Error}
+    * @param {Uint8Array} bytes
+    * @returns {ProvingKey}
+    */
+    static fromBytes(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.provingkey_fromBytes(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return ProvingKey.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Create a proving key from string
     *
-    * @returns {boolean} returns true if the proving key is for the transfer_public_to_private function, false if otherwise
-    * @returns {boolean}
+    * @param {string | Error} String representation of the proving key
+    * @param {string} string
+    * @returns {ProvingKey}
     */
-    isTransferPublicToPrivateProver() {
-        const ret = wasm.provingkey_isTransferPublicToPrivateProver(this.__wbg_ptr);
-        return ret !== 0;
+    static fromString(string) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.provingkey_fromString(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return ProvingKey.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-    * Verify if the proving key is for the unbond_delegator_as_validator function
-    *
-    * @example
-    * const provingKey = ProvingKey.fromBytes("unbond_delegator_as_validator_proving_key.bin");
-    * provingKey.isUnbondDelegatorAsValidatorProver() ? console.log("Key verified") : throw new Error("Invalid key");
+    * Return the byte representation of a proving key
     *
-    * @returns {boolean} returns true if the proving key is for the unbond_delegator_as_validator function, false if otherwise
-    * @returns {boolean}
+    * @returns {Uint8Array | Error} Byte array representation of a proving key
+    * @returns {Uint8Array}
     */
-    isUnbondDelegatorAsValidatorProver() {
-        const ret = wasm.provingkey_isUnbondDelegatorAsValidatorProver(this.__wbg_ptr);
-        return ret !== 0;
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.provingkey_toBytes(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-    * Verify if the proving key is for the unbond_delegator_as_delegator function
-    *
-    * @example
-    * const provingKey = ProvingKey.fromBytes("unbond_delegator_as_delegator_proving_key.bin");
-    * provingKey.isUnbondDelegatorAsDelegatorProver() ? console.log("Key verified") : throw new Error("Invalid key");
+    * Get a string representation of the proving key
     *
-    * @returns {boolean} returns true if the proving key is for the unbond_delegator_as_delegator function, false if otherwise
-    * @returns {boolean}
+    * @returns {string} String representation of the proving key
+    * @returns {string}
     */
-    isUnbondPublicProver() {
-        const ret = wasm.provingkey_isUnbondPublicProver(this.__wbg_ptr);
-        return ret !== 0;
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.provingkey_toString(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
     }
 }
 
@@ -3122,91 +3193,248 @@ export class Transaction {
         wasm.__wbg_transaction_free(ptr);
     }
     /**
-    * Create a transaction from a string
+    * Create a transaction from a string
+    *
+    * @param {string} transaction String representation of a transaction
+    * @returns {Transaction | Error}
+    * @param {string} transaction
+    * @returns {Transaction}
+    */
+    static fromString(transaction) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(transaction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.transaction_fromString(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Transaction.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Get the transaction as a string. If you want to submit this transaction to the Aleo Network
+    * this function will create the string that should be submitted in the `POST` data.
+    *
+    * @returns {string} String representation of the transaction
+    * @returns {string}
+    */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_toString(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Get the id of the transaction. This is the merkle root of the transaction's inclusion proof.
+    *
+    * This value can be used to query the status of the transaction on the Aleo Network to see
+    * if it was successful. If successful, the transaction will be included in a block and this
+    * value can be used to lookup the transaction data on-chain.
+    *
+    * @returns {string} Transaction id
+    * @returns {string}
+    */
+    transactionId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_transactionId(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Get the type of the transaction (will return "deploy" or "execute")
+    *
+    * @returns {string} Transaction type
+    * @returns {string}
+    */
+    transactionType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_transactionType(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const VerifyingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_verifyingkey_free(ptr >>> 0));
+/**
+* Verifying key for a function within an Aleo program
+*/
+export class VerifyingKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(VerifyingKey.prototype);
+        obj.__wbg_ptr = ptr;
+        VerifyingKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VerifyingKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_verifyingkey_free(ptr);
+    }
+    /**
+    * Get the checksum of the verifying key
+    *
+    * @returns {string} Checksum of the verifying key
+    * @returns {string}
+    */
+    checksum() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.verifyingkey_checksum(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Create a copy of the verifying key
+    *
+    * @returns {VerifyingKey} A copy of the verifying key
+    * @returns {VerifyingKey}
+    */
+    copy() {
+        const ret = wasm.verifyingkey_copy(this.__wbg_ptr);
+        return VerifyingKey.__wrap(ret);
+    }
+    /**
+    * Construct a new verifying key from a byte array
     *
-    * @param {string} transaction String representation of a transaction
-    * @returns {Transaction | Error}
-    * @param {string} transaction
-    * @returns {Transaction}
+    * @param {Uint8Array} bytes Byte representation of a verifying key
+    * @returns {VerifyingKey | Error}
+    * @param {Uint8Array} bytes
+    * @returns {VerifyingKey}
     */
-    static fromString(transaction) {
+    static fromBytes(bytes) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(transaction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
             const len0 = WASM_VECTOR_LEN;
-            wasm.transaction_fromString(retptr, ptr0, len0);
+            wasm.verifyingkey_fromBytes(retptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
             if (r2) {
                 throw takeObject(r1);
             }
-            return Transaction.__wrap(r0);
+            return VerifyingKey.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-    * Get the transaction as a string. If you want to submit this transaction to the Aleo Network
-    * this function will create the string that should be submitted in the `POST` data.
+    * Create a verifying key from string
     *
-    * @returns {string} String representation of the transaction
-    * @returns {string}
+    * @param {String} string String representation of a verifying key
+    * @returns {VerifyingKey | Error}
+    * @param {string} string
+    * @returns {VerifyingKey}
     */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
+    static fromString(string) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.transaction_toString(retptr, this.__wbg_ptr);
+            const ptr0 = passStringToWasm0(string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.verifyingkey_fromString(retptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return VerifyingKey.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * Get the id of the transaction. This is the merkle root of the transaction's inclusion proof.
-    *
-    * This value can be used to query the status of the transaction on the Aleo Network to see
-    * if it was successful. If successful, the transaction will be included in a block and this
-    * value can be used to lookup the transaction data on-chain.
+    * Create a byte array from a verifying key
     *
-    * @returns {string} Transaction id
-    * @returns {string}
+    * @returns {Uint8Array | Error} Byte representation of a verifying key
+    * @returns {Uint8Array}
     */
-    transactionId() {
-        let deferred1_0;
-        let deferred1_1;
+    toBytes() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.transaction_transactionId(retptr, this.__wbg_ptr);
+            wasm.verifyingkey_toBytes(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 1, 1);
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * Get the type of the transaction (will return "deploy" or "execute")
+    * Get a string representation of the verifying key
     *
-    * @returns {string} Transaction type
+    * @returns {String} String representation of the verifying key
     * @returns {string}
     */
-    transactionType() {
+    toString() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.transaction_transactionType(retptr, this.__wbg_ptr);
+            wasm.verifyingkey_toString(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -3217,35 +3445,6 @@ export class Transaction {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-}
-
-const VerifyingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_verifyingkey_free(ptr >>> 0));
-/**
-* Verifying key for a function within an Aleo program
-*/
-export class VerifyingKey {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(VerifyingKey.prototype);
-        obj.__wbg_ptr = ptr;
-        VerifyingKeyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        VerifyingKeyFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_verifyingkey_free(ptr);
-    }
     /**
     * Returns the verifying key for the bond_public function
     *
@@ -3526,134 +3725,6 @@ export class VerifyingKey {
         const ret = wasm.verifyingkey_isUnbondPublicVerifier(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-    * Get the checksum of the verifying key
-    *
-    * @returns {string} Checksum of the verifying key
-    * @returns {string}
-    */
-    checksum() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.verifyingkey_checksum(retptr, this.__wbg_ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-    * Create a copy of the verifying key
-    *
-    * @returns {VerifyingKey} A copy of the verifying key
-    * @returns {VerifyingKey}
-    */
-    copy() {
-        const ret = wasm.verifyingkey_copy(this.__wbg_ptr);
-        return VerifyingKey.__wrap(ret);
-    }
-    /**
-    * Construct a new verifying key from a byte array
-    *
-    * @param {Uint8Array} bytes Byte representation of a verifying key
-    * @returns {VerifyingKey | Error}
-    * @param {Uint8Array} bytes
-    * @returns {VerifyingKey}
-    */
-    static fromBytes(bytes) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.verifyingkey_fromBytes(retptr, ptr0, len0);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return VerifyingKey.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Create a verifying key from string
-    *
-    * @param {String} string String representation of a verifying key
-    * @returns {VerifyingKey | Error}
-    * @param {string} string
-    * @returns {VerifyingKey}
-    */
-    static fromString(string) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.verifyingkey_fromString(retptr, ptr0, len0);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return VerifyingKey.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Create a byte array from a verifying key
-    *
-    * @returns {Uint8Array | Error} Byte representation of a verifying key
-    * @returns {Uint8Array}
-    */
-    toBytes() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.verifyingkey_toBytes(retptr, this.__wbg_ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            var r3 = getInt32Memory0()[retptr / 4 + 3];
-            if (r3) {
-                throw takeObject(r2);
-            }
-            var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1, 1);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Get a string representation of the verifying key
-    *
-    * @returns {String} String representation of the verifying key
-    * @returns {string}
-    */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.verifyingkey_toString(retptr, this.__wbg_ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
 }
 
 const ViewKeyFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3854,11 +3925,11 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_log_3413689d1412c4f7 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_0159ca40cddf5b15 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        const ret = getStringFromWasm0(arg0, arg1);
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
@@ -3869,6 +3940,14 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
+    imports.wbg.__wbg_authorizationresponse_new = function(arg0) {
+        const ret = AuthorizationResponse.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_transaction_new = function(arg0) {
         const ret = Transaction.__wrap(arg0);
         return addHeapObject(ret);
@@ -3877,19 +3956,15 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_keypair_new = function(arg0) {
-        const ret = KeyPair.__wrap(arg0);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_executionresponse_new = function(arg0) {
         const ret = ExecutionResponse.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        const ret = getObject(arg0);
+    imports.wbg.__wbg_keypair_new = function(arg0) {
+        const ret = KeyPair.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_af517e8ec087a35a = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_f6acaddb2e29dc4a = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -4163,7 +4238,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_291(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_295(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -4243,8 +4318,8 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper6140 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 868, __wbg_adapter_32);
+    imports.wbg.__wbindgen_closure_wrapper6115 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 862, __wbg_adapter_32);
         return addHeapObject(ret);
     };