@puzzlehq/aleo-wasm-web 0.6.14 → 0.6.16

package/{dist/worker.js → aleo_wasm.js}

@@ -1,33 +1,4 @@
-function spawnWorker(url, module, memory, address) {
-        return new Promise((resolve) => {
-            const worker = new Worker(url, {
-                type: "module",
-            });
-
-            worker.addEventListener("message", (event) => {
-                // This is needed in Node to wait one extra tick, so that way
-                // the Worker can fully initialize before we return.
-                setTimeout(() => {
-                    resolve(worker);
-
-                    // When running in Node, this allows the process to exit
-                    // even though the Worker is still running.
-                    if (worker.unref) {
-                        worker.unref();
-                    }
-                }, 0);
-            }, {
-                capture: true,
-                once: true,
-            });
-
-            worker.postMessage({
-                module,
-                memory,
-                address,
-            });
-        });
-    }
+import { spawnWorker } from './snippets/aleo-wasm-917a63011190b7ca/inline0.js';
 
 let wasm;
 
@@ -53,11 +24,12 @@ function takeObject(idx) {
 
 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(); }
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
 let cachedUint8Memory0 = null;
 
 function getUint8Memory0() {
-    if (cachedUint8Memory0 === null || cachedUint8Memory0.buffer !== wasm.memory.buffer) {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
         cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
     }
     return cachedUint8Memory0;
@@ -65,7 +37,7 @@ function getUint8Memory0() {
 
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8Memory0().slice(ptr, ptr + len));
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 
 function addHeapObject(obj) {
@@ -81,14 +53,18 @@ let WASM_VECTOR_LEN = 0;
 
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
-const encodeString = function (arg, view) {
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
     const buf = cachedTextEncoder.encode(arg);
     view.set(buf);
     return {
         read: arg.length,
         written: buf.length
     };
-};
+});
 
 function passStringToWasm0(arg, malloc, realloc) {
 
@@ -136,7 +112,7 @@ function isLikeNone(x) {
 let cachedInt32Memory0 = null;
 
 function getInt32Memory0() {
-    if (cachedInt32Memory0 === null || cachedInt32Memory0.buffer !== wasm.memory.buffer) {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
         cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
     }
     return cachedInt32Memory0;
@@ -210,7 +186,7 @@ function debugString(val) {
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => {
-    wasm.__wbindgen_export_3.get(state.dtor)(state.a, state.b);
+    wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b)
 });
 
 function makeMutClosure(arg0, arg1, dtor, f) {
@@ -226,7 +202,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
             return f(a, state.b, ...args);
         } finally {
             if (--state.cnt === 0) {
-                wasm.__wbindgen_export_3.get(state.dtor)(a, state.b);
+                wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
                 CLOSURE_DTORS.unregister(state);
             } else {
                 state.a = a;
@@ -237,8 +213,15 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
-function __wbg_adapter_34(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0d5bc0f77f63013f(arg0, arg1, addHeapObject(arg2));
+function __wbg_adapter_32(arg0, arg1, arg2) {
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hdf1d9b89567002b9(arg0, arg1, addHeapObject(arg2));
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
 }
 
 function _assertClass(instance, klass) {
@@ -248,12 +231,33 @@ function _assertClass(instance, klass) {
     return instance.ptr;
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8Memory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+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
@@ -270,7 +274,7 @@ function passArray8ToWasm0(arg, malloc) {
 * @param {string} function_id
 * @returns {boolean}
 */
-function verifyFunctionExecution(execution, verifying_key, program, function_id) {
+export function verifyFunctionExecution(execution, verifying_key, program, function_id) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         _assertClass(execution, Execution);
@@ -294,39 +298,12 @@ function verifyFunctionExecution(execution, verifying_key, program, function_id)
 let cachedBigInt64Memory0 = null;
 
 function getBigInt64Memory0() {
-    if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.buffer !== wasm.memory.buffer) {
+    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
-*/
-function runRayonThread(receiver) {
-    wasm.runRayonThread(receiver);
-}
-
-/**
-*/
-function init_panic_hook() {
-    wasm.init_panic_hook();
-}
-
-/**
-* @param {URL} url
-* @param {number} num_threads
-* @returns {Promise<void>}
-*/
-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);
@@ -334,8 +311,8 @@ function handleError(f, args) {
         wasm.__wbindgen_exn_store(addHeapObject(e));
     }
 }
-function __wbg_adapter_290(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures__invoke2_mut__h630419b3c55d46e4(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_327(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__h69b3d6b389ddc7fb(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const AddressFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -344,7 +321,7 @@ const AddressFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
 * Public address of an Aleo account
 */
-class Address {
+export class Address {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -451,7 +428,7 @@ const AuthorizationResponseFinalization = (typeof FinalizationRegistry === 'unde
     : new FinalizationRegistry(ptr => wasm.__wbg_authorizationresponse_free(ptr >>> 0));
 /**
 */
-class AuthorizationResponse {
+export class AuthorizationResponse {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -480,7 +457,7 @@ class AuthorizationResponse {
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.__wbg_get_metadata_locator(retptr, this.__wbg_ptr);
+            wasm.authorizationresponse_authorization(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -499,7 +476,7 @@ class AuthorizationResponse {
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.__wbg_get_metadata_prover(retptr, this.__wbg_ptr);
+            wasm.authorizationresponse_fee_authorization(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -518,7 +495,7 @@ const ExecutionFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
 * Execution of an Aleo program.
 */
-class Execution {
+export class Execution {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -592,7 +569,7 @@ const ExecutionResponseFinalization = (typeof FinalizationRegistry === 'undefine
 * This object is returned by the execution of an Aleo function off-chain. It provides methods for
 * retrieving the outputs of the function execution.
 */
-class ExecutionResponse {
+export class ExecutionResponse {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -709,7 +686,7 @@ const FieldFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(ptr => wasm.__wbg_field_free(ptr >>> 0));
 /**
 */
-class Field {
+export class Field {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -777,7 +754,7 @@ const JsFieldFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(ptr => wasm.__wbg_jsfield_free(ptr >>> 0));
 /**
 */
-class JsField {
+export class JsField {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -852,7 +829,7 @@ const KeyPairFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
 * Key pair object containing both the function proving and verifying keys
 */
-class KeyPair {
+export class KeyPair {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -940,7 +917,7 @@ const MetadataFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(ptr => wasm.__wbg_metadata_free(ptr >>> 0));
 /**
 */
-class Metadata {
+export class Metadata {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -964,6 +941,33 @@ class Metadata {
     /**
     * @returns {string}
     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_metadata_name(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);
+        }
+    }
+    /**
+    * @param {string} arg0
+    */
+    set name(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_metadata_name(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    * @returns {string}
+    */
     get locator() {
         let deferred1_0;
         let deferred1_1;
@@ -1202,7 +1206,7 @@ const OfflineQueryFinalization = (typeof FinalizationRegistry === 'undefined')
 * An offline query object used to insert the global state root and state paths needed to create
 * a valid inclusion proof offline.
 */
-class OfflineQuery {
+export class OfflineQuery {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -1314,13 +1318,108 @@ class OfflineQuery {
     }
 }
 
+const PlaintextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_plaintext_free(ptr >>> 0));
+/**
+*/
+export class Plaintext {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Plaintext.prototype);
+        obj.__wbg_ptr = ptr;
+        PlaintextFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PlaintextFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_plaintext_free(ptr);
+    }
+    /**
+    * @returns {string}
+    */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_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);
+        }
+    }
+    /**
+    * @param {string} plaintext
+    * @returns {Plaintext}
+    */
+    static fromString(plaintext) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.plaintext_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 Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    hashBhp256() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_hashBhp256(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];
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+
 const PrivateKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_privatekey_free(ptr >>> 0));
 /**
 * Private key of an Aleo account
 */
-class PrivateKey {
+export class PrivateKey {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -1558,7 +1657,7 @@ const PrivateKeyCiphertextFinalization = (typeof FinalizationRegistry === 'undef
 /**
 * Private Key in ciphertext form
 */
-class PrivateKeyCiphertext {
+export class PrivateKeyCiphertext {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -1596,7 +1695,7 @@ class PrivateKeyCiphertext {
             _assertClass(private_key, PrivateKey);
             const ptr0 = passStringToWasm0(secret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len0 = WASM_VECTOR_LEN;
-            wasm.privatekey_toCiphertext(retptr, private_key.__wbg_ptr, ptr0, len0);
+            wasm.privatekeyciphertext_encryptPrivateKey(retptr, private_key.__wbg_ptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1689,7 +1788,7 @@ const ProgramFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
 * Webassembly Representation of an Aleo program
 */
-class Program {
+export class Program {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -2106,7 +2205,7 @@ const ProgramManagerFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(ptr => wasm.__wbg_programmanager_free(ptr >>> 0));
 /**
 */
-class ProgramManager {
+export class ProgramManager {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2120,76 +2219,289 @@ class ProgramManager {
         wasm.__wbg_programmanager_free(ptr);
     }
     /**
-    * Deploy an Aleo program
+    * 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));
+        return takeObject(ret);
+    }
+    /**
+    * 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 deployed
-    * @param imports A javascript object holding the source code of any imported programs in the
-    * form \{"program_name1": "program_source_code", "program_name2": "program_source_code", ..\}.
-    * Note that all imported programs must be deployed on chain before the main program in order
-    * for the deployment to succeed
+    * @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 imports (optional) Provide a list of imports to use for the program deployment 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 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 {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} [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 buildDeploymentTransaction(private_key, program, fee_credits, fee_record, url, imports, 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;
-        let ptr1 = 0;
+        _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);
-            ptr1 = fee_record.__destroy_into_raw();
+            ptr2 = fee_record.__destroy_into_raw();
         }
-        var ptr2 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len2 = WASM_VECTOR_LEN;
-        let ptr3 = 0;
+        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 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);
-            ptr3 = fee_proving_key.__destroy_into_raw();
+            ptr6 = fee_proving_key.__destroy_into_raw();
         }
-        let ptr4 = 0;
+        let ptr7 = 0;
         if (!isLikeNone(fee_verifying_key)) {
             _assertClass(fee_verifying_key, VerifyingKey);
-            ptr4 = fee_verifying_key.__destroy_into_raw();
+            ptr7 = fee_verifying_key.__destroy_into_raw();
         }
-        let ptr5 = 0;
+        let ptr8 = 0;
         if (!isLikeNone(offline_query)) {
             _assertClass(offline_query, OfflineQuery);
-            ptr5 = offline_query.__destroy_into_raw();
+            ptr8 = offline_query.__destroy_into_raw();
         }
-        const ret = wasm.programmanager_buildDeploymentTransaction(private_key.__wbg_ptr, ptr0, len0, fee_credits, ptr1, ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr3, ptr4, ptr5);
+        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 the fee for a program deployment
-    *
-    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+    * Split an Aleo credits record into two separate records. This function does not require a fee.
     *
-    * @param program The source code of the program being deployed
-    * @param imports (optional) Provide a list of imports to use for the deployment 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" \}
-    * @returns {u64 | Error}
-    * @param {string} program
-    * @param {object | undefined} [imports]
-    * @returns {Promise<bigint>}
+    * @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);
+    }
+    /**
+    * Send credits from one Aleo account to another
+    *
+    * @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 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
+    * @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 {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 {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) {
+        _assertClass(private_key, PrivateKey);
+        const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(transfer_type, 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();
+        }
+        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);
+            ptr9 = 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);
+        return takeObject(ret);
+    }
+    /**
+    * Deploy an Aleo program
+    *
+    * @param private_key The private key of the sender
+    * @param program The source code of the program being deployed
+    * @param imports A javascript object holding the source code of any imported programs in the
+    * form \{"program_name1": "program_source_code", "program_name2": "program_source_code", ..\}.
+    * Note that all imported programs must be deployed on chain before the main program in order
+    * for the deployment to succeed
+    * @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 program deployment 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 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 {number} fee_credits
+    * @param {RecordPlaintext | undefined} [fee_record]
+    * @param {string | undefined} [url]
+    * @param {object | undefined} [imports]
+    * @param {ProvingKey | undefined} [fee_proving_key]
+    * @param {VerifyingKey | undefined} [fee_verifying_key]
+    * @param {OfflineQuery | undefined} [offline_query]
+    * @returns {Promise<Transaction>}
+    */
+    static buildDeploymentTransaction(private_key, program, fee_credits, fee_record, url, imports, 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;
+        let ptr1 = 0;
+        if (!isLikeNone(fee_record)) {
+            _assertClass(fee_record, RecordPlaintext);
+            ptr1 = fee_record.__destroy_into_raw();
+        }
+        var ptr2 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        let ptr3 = 0;
+        if (!isLikeNone(fee_proving_key)) {
+            _assertClass(fee_proving_key, ProvingKey);
+            ptr3 = fee_proving_key.__destroy_into_raw();
+        }
+        let ptr4 = 0;
+        if (!isLikeNone(fee_verifying_key)) {
+            _assertClass(fee_verifying_key, VerifyingKey);
+            ptr4 = fee_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_buildDeploymentTransaction(private_key.__wbg_ptr, ptr0, len0, fee_credits, ptr1, ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr3, ptr4, ptr5);
+        return takeObject(ret);
+    }
+    /**
+    * Estimate the fee for a program deployment
+    *
+    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+    *
+    * @param program The source code of the program being deployed
+    * @param imports (optional) Provide a list of imports to use for the deployment 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" \}
+    * @returns {u64 | Error}
+    * @param {string} program
+    * @param {object | undefined} [imports]
+    * @returns {Promise<bigint>}
     */
     static estimateDeploymentFee(program, imports) {
         const ptr0 = passStringToWasm0(program, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -2472,260 +2784,44 @@ class ProgramManager {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+}
+
+const ProvingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_provingkey_free(ptr >>> 0));
+/**
+* Proving key for a function within an Aleo program
+*/
+export class ProvingKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ProvingKey.prototype);
+        obj.__wbg_ptr = ptr;
+        ProvingKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProvingKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_provingkey_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
+    * Verify if the proving key is for the bond_public function
     *
-    * @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
-    * @param {RecordPlaintext} record_1
-    * @param {RecordPlaintext} record_2
-    * @param {number} fee_credits
-    * @param {RecordPlaintext | undefined} [fee_record]
-    * @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>}
-    */
-    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);
-        _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);
-            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(join_proving_key)) {
-            _assertClass(join_proving_key, ProvingKey);
-            ptr4 = join_proving_key.__destroy_into_raw();
-        }
-        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();
-        }
-        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);
-    }
-    /**
-    * Send credits from one Aleo account to another
-    *
-    * @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 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
-    * @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 {string | undefined} caller
-    * @param {RecordPlaintext | undefined} amount_record
-    * @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 {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, caller, 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(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(transfer_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(caller) ? 0 : passStringToWasm0(caller, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len2 = WASM_VECTOR_LEN;
-        let ptr3 = 0;
-        if (!isLikeNone(amount_record)) {
-            _assertClass(amount_record, RecordPlaintext);
-            ptr3 = amount_record.__destroy_into_raw();
-        }
-        let ptr4 = 0;
-        if (!isLikeNone(fee_record)) {
-            _assertClass(fee_record, RecordPlaintext);
-            ptr4 = fee_record.__destroy_into_raw();
-        }
-        var ptr5 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len5 = WASM_VECTOR_LEN;
-        let ptr6 = 0;
-        if (!isLikeNone(transfer_proving_key)) {
-            _assertClass(transfer_proving_key, ProvingKey);
-            ptr6 = transfer_proving_key.__destroy_into_raw();
-        }
-        let ptr7 = 0;
-        if (!isLikeNone(transfer_verifying_key)) {
-            _assertClass(transfer_verifying_key, VerifyingKey);
-            ptr7 = transfer_verifying_key.__destroy_into_raw();
-        }
-        let ptr8 = 0;
-        if (!isLikeNone(fee_proving_key)) {
-            _assertClass(fee_proving_key, ProvingKey);
-            ptr8 = fee_proving_key.__destroy_into_raw();
-        }
-        let ptr9 = 0;
-        if (!isLikeNone(fee_verifying_key)) {
-            _assertClass(fee_verifying_key, VerifyingKey);
-            ptr9 = fee_verifying_key.__destroy_into_raw();
-        }
-        let ptr10 = 0;
-        if (!isLikeNone(offline_query)) {
-            _assertClass(offline_query, OfflineQuery);
-            ptr10 = offline_query.__destroy_into_raw();
-        }
-        const ret = wasm.programmanager_buildTransferTransaction(private_key.__wbg_ptr, amount_credits, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, fee_credits, ptr4, ptr5, len5, ptr6, ptr7, ptr8, ptr9, ptr10);
-        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));
-        return takeObject(ret);
-    }
-}
-
-const ProvingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_provingkey_free(ptr >>> 0));
-/**
-* Proving key for a function within an Aleo program
-*/
-class ProvingKey {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ProvingKey.prototype);
-        obj.__wbg_ptr = ptr;
-        ProvingKeyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ProvingKeyFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_provingkey_free(ptr);
-    }
-    /**
-    * Verify if the proving key is for the bond_public function
-    *
-    * @example
-    * const provingKey = ProvingKey.fromBytes("bond_public_proving_key.bin");
-    * provingKey.isBondPublicProver() ? console.log("Key verified") : throw new Error("Invalid key");
-    *
-    * @returns {boolean} returns true if the proving key is for the bond_public function, false if otherwise
-    * @returns {boolean}
+    * @example
+    * const provingKey = ProvingKey.fromBytes("bond_public_proving_key.bin");
+    * provingKey.isBondPublicProver() ? console.log("Key verified") : throw new Error("Invalid key");
+    *
+    * @returns {boolean} returns true if the proving key is for the bond_public function, false if otherwise
+    * @returns {boolean}
     */
     isBondPublicProver() {
         const ret = wasm.provingkey_isBondPublicProver(this.__wbg_ptr);
@@ -3062,7 +3158,7 @@ const RecordCiphertextFinalization = (typeof FinalizationRegistry === 'undefined
 /**
 * Encrypted Aleo record
 */
-class RecordCiphertext {
+export class RecordCiphertext {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -3176,7 +3272,7 @@ const RecordPlaintextFinalization = (typeof FinalizationRegistry === 'undefined'
 /**
 * Plaintext representation of an Aleo record
 */
-class RecordPlaintext {
+export class RecordPlaintext {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -3349,7 +3445,7 @@ const SignatureFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
 * Cryptographic signature of a message signed by an Aleo account
 */
-class Signature {
+export class Signature {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -3384,7 +3480,7 @@ class Signature {
         _assertClass(private_key, PrivateKey);
         const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.privatekey_sign(private_key.__wbg_ptr, ptr0, len0);
+        const ret = wasm.signature_sign(private_key.__wbg_ptr, ptr0, len0);
         return Signature.__wrap(ret);
     }
     /**
@@ -3471,7 +3567,7 @@ const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
 * This object is created when generating an on-chain function deployment or execution and is the
 * object that should be submitted to the Aleo Network in order to deploy or execute a function.
 */
-class Transaction {
+export class Transaction {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -3596,7 +3692,7 @@ const VerifyingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
 * Verifying key for a function within an Aleo program
 */
-class VerifyingKey {
+export class VerifyingKey {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -3618,39 +3714,167 @@ class VerifyingKey {
         wasm.__wbg_verifyingkey_free(ptr);
     }
     /**
-    * Returns the verifying key for the bond_public function
+    * Get the checksum of the verifying key
     *
-    * @returns {VerifyingKey} Verifying key for the bond_public function
-    * @returns {VerifyingKey}
+    * @returns {string} Checksum of the verifying key
+    * @returns {string}
     */
-    static bondPublicVerifier() {
-        const ret = wasm.verifyingkey_bondPublicVerifier();
-        return VerifyingKey.__wrap(ret);
+    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);
+        }
     }
     /**
-    * Returns the verifying key for the bond_validator function
+    * Create a copy of the verifying key
     *
-    * @returns {VerifyingKey} Verifying key for the bond_validator function
+    * @returns {VerifyingKey} A copy of the verifying key
     * @returns {VerifyingKey}
     */
-    static bondValidatorVerifier() {
-        const ret = wasm.verifyingkey_bondValidatorVerifier();
+    copy() {
+        const ret = wasm.verifyingkey_copy(this.__wbg_ptr);
         return VerifyingKey.__wrap(ret);
     }
     /**
-    * Returns the verifying key for the claim_delegator function
+    * Construct a new verifying key from a byte array
     *
-    * @returns {VerifyingKey} Verifying key for the claim_unbond_public function
+    * @param {Uint8Array} bytes Byte representation of a verifying key
+    * @returns {VerifyingKey | Error}
+    * @param {Uint8Array} bytes
     * @returns {VerifyingKey}
     */
-    static claimUnbondPublicVerifier() {
-        const ret = wasm.verifyingkey_claimUnbondPublicVerifier();
-        return VerifyingKey.__wrap(ret);
+    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);
+        }
     }
     /**
-    * Returns the verifying key for the fee_private function
+    * Create a verifying key from string
     *
-    * @returns {VerifyingKey} Verifying key for the fee_private function
+    * @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);
+        }
+    }
+    /**
+    * Returns the verifying key for the bond_public function
+    *
+    * @returns {VerifyingKey} Verifying key for the bond_public function
+    * @returns {VerifyingKey}
+    */
+    static bondPublicVerifier() {
+        const ret = wasm.verifyingkey_bondPublicVerifier();
+        return VerifyingKey.__wrap(ret);
+    }
+    /**
+    * Returns the verifying key for the bond_validator function
+    *
+    * @returns {VerifyingKey} Verifying key for the bond_validator function
+    * @returns {VerifyingKey}
+    */
+    static bondValidatorVerifier() {
+        const ret = wasm.verifyingkey_bondValidatorVerifier();
+        return VerifyingKey.__wrap(ret);
+    }
+    /**
+    * Returns the verifying key for the claim_delegator function
+    *
+    * @returns {VerifyingKey} Verifying key for the claim_unbond_public function
+    * @returns {VerifyingKey}
+    */
+    static claimUnbondPublicVerifier() {
+        const ret = wasm.verifyingkey_claimUnbondPublicVerifier();
+        return VerifyingKey.__wrap(ret);
+    }
+    /**
+    * Returns the verifying key for the fee_private function
+    *
+    * @returns {VerifyingKey} Verifying key for the fee_private function
     * @returns {VerifyingKey}
     */
     static feePrivateVerifier() {
@@ -3917,134 +4141,6 @@ 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')
@@ -4052,7 +4148,7 @@ const ViewKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(ptr => wasm.__wbg_viewkey_free(ptr >>> 0));
 /**
 */
-class ViewKey {
+export class ViewKey {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -4083,7 +4179,7 @@ class ViewKey {
     */
     static from_private_key(private_key) {
         _assertClass(private_key, PrivateKey);
-        const ret = wasm.privatekey_to_view_key(private_key.__wbg_ptr);
+        const ret = wasm.viewkey_from_private_key(private_key.__wbg_ptr);
         return ViewKey.__wrap(ret);
     }
     /**
@@ -4129,7 +4225,7 @@ class ViewKey {
     * @returns {Address}
     */
     to_address() {
-        const ret = wasm.address_from_view_key(this.__wbg_ptr);
+        const ret = wasm.viewkey_to_address(this.__wbg_ptr);
         return Address.__wrap(ret);
     }
     /**
@@ -4245,127 +4341,21 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_new_71801a555ad9f2aa = function() { return handleError(function () {
-        const ret = new XMLHttpRequest();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_overrideMimeType_ee9c51919ceb418b = function() { return handleError(function (arg0, arg1, arg2) {
-        getObject(arg0).overrideMimeType(getStringFromWasm0(arg1, arg2));
-    }, arguments) };
-    imports.wbg.__wbg_open_c9eb0cf2c9d95679 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-        getObject(arg0).open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
-    }, arguments) };
-    imports.wbg.__wbg_send_80d29985093c1ec5 = function() { return handleError(function (arg0) {
-        getObject(arg0).send();
-    }, arguments) };
-    imports.wbg.__wbg_response_7c2e2759084f7279 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).response;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_status_d485fb5a478426fb = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).status;
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
-        const ret = new Object();
+    imports.wbg.__wbg_executionresponse_new = function(arg0) {
+        const ret = ExecutionResponse.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_1f9b04f170055d33 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbg_new_ab6fd82b10560829 = function() { return handleError(function () {
-        const ret = new Headers();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        const ret = getObject(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_0d76b0581eca6298 = function() { return handleError(function () {
-        const ret = new AbortController();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_signal_a61f78a3478fd9bc = function(arg0) {
-        const ret = getObject(arg0).signal;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_append_7bfcb4937d1d5e29 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-        getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-    }, arguments) };
-    imports.wbg.__wbg_instanceof_Response_849eb93e75734b6e = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Response;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_status_61a01141acd3cf74 = function(arg0) {
-        const ret = getObject(arg0).status;
-        return ret;
-    };
-    imports.wbg.__wbg_url_5f6dc4009ac5f99d = function(arg0, arg1) {
-        const ret = getObject(arg1).url;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len1;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
-    };
-    imports.wbg.__wbg_headers_9620bfada380764a = function(arg0) {
-        const ret = getObject(arg0).headers;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
-        const ret = Symbol.iterator;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_get_e3c254076557e348 = function() { return handleError(function (arg0, arg1) {
-        const ret = Reflect.get(getObject(arg0), getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbindgen_is_function = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'function';
-        return ret;
-    };
-    imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).call(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbindgen_is_object = function(arg0) {
-        const val = getObject(arg0);
-        const ret = typeof(val) === 'object' && val !== null;
-        return ret;
-    };
-    imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
-        const ret = getObject(arg0).next;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).next();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
-        const ret = getObject(arg0).done;
-        return ret;
-    };
-    imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
-        const ret = getObject(arg0).value;
+    imports.wbg.__wbg_transaction_new = function(arg0) {
+        const ret = Transaction.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_abort_2aa7521d5690750e = function(arg0) {
-        getObject(arg0).abort();
+    imports.wbg.__wbg_log_b46ba1e74db5adee = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() { return handleError(function (arg0) {
-        const ret = JSON.stringify(getObject(arg0));
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -4374,49 +4364,23 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbg_log_f3433265eb640baa = function(arg0, arg1) {
-        console.log(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbg_newwithlength_66ae46612e7f0234 = function(arg0) {
-        const ret = new Array(arg0 >>> 0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
-        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-    };
-    imports.wbg.__wbg_transaction_new = function(arg0) {
-        const ret = Transaction.__wrap(arg0);
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_keypair_new = function(arg0) {
         const ret = KeyPair.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
-        const ret = BigInt.asUintN(64, arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_executionresponse_new = function(arg0) {
-        const ret = ExecutionResponse.__wrap(arg0);
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_authorizationresponse_new = function(arg0) {
         const ret = AuthorizationResponse.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_module = function() {
-        const ret = __wbg_init.__wbindgen_wasm_module;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_memory = function() {
-        const ret = wasm.memory;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_spawnWorker_1bc5a4548b5096bf = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_d4740fc67f78311c = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -4429,44 +4393,6 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbg_new_16b304a2cfa7ff4a = function() {
-        const ret = new Array();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
-        const ret = getObject(arg0).push(getObject(arg1));
-        return ret;
-    };
-    imports.wbg.__wbg_arrayBuffer_29931d52c7206b02 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).arrayBuffer();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
-        const ret = new Uint8Array(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
-        try {
-            var state0 = {a: arg0, b: arg1};
-            var cb0 = (arg0, arg1) => {
-                const a = state0.a;
-                state0.a = 0;
-                try {
-                    return __wbg_adapter_290(a, state0.b, arg0, arg1);
-                } finally {
-                    state0.a = a;
-                }
-            };
-            const ret = new Promise(cb0);
-            return addHeapObject(ret);
-        } finally {
-            state0.a = state0.b = 0;
-        }
-    };
     imports.wbg.__wbindgen_number_new = function(arg0) {
         const ret = arg0;
         return addHeapObject(ret);
@@ -4493,31 +4419,121 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
-        const ret = getObject(arg0).buffer;
+    imports.wbg.__wbg_fetch_bc7c8e27076a5c84 = function(arg0) {
+        const ret = fetch(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
-        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+    imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
+        queueMicrotask(getObject(arg0));
+    };
+    imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
+        const ret = getObject(arg0).queueMicrotask;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
-        getObject(arg0).randomFillSync(takeObject(arg1));
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg_navigator_6c8fa55c5cc8796e = function(arg0) {
+        const ret = getObject(arg0).navigator;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_fetch_921fad6ef9e883dd = function(arg0, arg1) {
+        const ret = getObject(arg0).fetch(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_hardwareConcurrency_cffbaa73aab5ff44 = function(arg0) {
+        const ret = getObject(arg0).hardwareConcurrency;
+        return ret;
+    };
+    imports.wbg.__wbg_newwithstrandinit_3fd6fba4083ff2d0 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+        return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+    imports.wbg.__wbg_signal_a61f78a3478fd9bc = function(arg0) {
+        const ret = getObject(arg0).signal;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
-        getObject(arg0).getRandomValues(getObject(arg1));
+    imports.wbg.__wbg_new_0d76b0581eca6298 = function() { return handleError(function () {
+        const ret = new AbortController();
+        return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
-        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+    imports.wbg.__wbg_abort_2aa7521d5690750e = function(arg0) {
+        getObject(arg0).abort();
+    };
+    imports.wbg.__wbg_new_ab6fd82b10560829 = function() { return handleError(function () {
+        const ret = new Headers();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_append_7bfcb4937d1d5e29 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+    }, arguments) };
+    imports.wbg.__wbg_instanceof_Response_849eb93e75734b6e = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Response;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_url_5f6dc4009ac5f99d = function(arg0, arg1) {
+        const ret = getObject(arg1).url;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    };
+    imports.wbg.__wbg_status_61a01141acd3cf74 = function(arg0) {
+        const ret = getObject(arg0).status;
+        return ret;
+    };
+    imports.wbg.__wbg_headers_9620bfada380764a = function(arg0) {
+        const ret = getObject(arg0).headers;
+        return addHeapObject(ret);
     };
+    imports.wbg.__wbg_arrayBuffer_29931d52c7206b02 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).arrayBuffer();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_status_d485fb5a478426fb = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).status;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_response_7c2e2759084f7279 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).response;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_responseText_c67ed2d48db10769 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg1).responseText;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    }, arguments) };
+    imports.wbg.__wbg_new_71801a555ad9f2aa = function() { return handleError(function () {
+        const ret = new XMLHttpRequest();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_open_c9eb0cf2c9d95679 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        getObject(arg0).open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
+    }, arguments) };
+    imports.wbg.__wbg_overrideMimeType_ee9c51919ceb418b = function() { return handleError(function (arg0, arg1, arg2) {
+        getObject(arg0).overrideMimeType(getStringFromWasm0(arg1, arg2));
+    }, arguments) };
+    imports.wbg.__wbg_send_80d29985093c1ec5 = function() { return handleError(function (arg0) {
+        getObject(arg0).send();
+    }, arguments) };
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_is_object = function(arg0) {
+        const val = getObject(arg0);
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
     imports.wbg.__wbg_process_4a72847cc503995b = function(arg0) {
         const ret = getObject(arg0).process;
         return addHeapObject(ret);
@@ -4542,16 +4558,58 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).msCrypto;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
-        const ret = new Uint8Array(arg0 >>> 0);
+    imports.wbg.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
+        getObject(arg0).randomFillSync(takeObject(arg1));
+    }, arguments) };
+    imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
+        getObject(arg0).getRandomValues(getObject(arg1));
+    }, arguments) };
+    imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
-        const ret = getObject(arg0)[arg1 >>> 0];
+    imports.wbg.__wbg_new_16b304a2cfa7ff4a = function() {
+        const ret = new Array();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
+        const ret = getObject(arg0).next;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).next();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
+        const ret = getObject(arg0).done;
+        return ret;
+    };
+    imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
+        const ret = getObject(arg0).value;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
+        const ret = Symbol.iterator;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_e3c254076557e348 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
+        const ret = new Object();
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
@@ -4574,122 +4632,110 @@ function __wbg_get_imports() {
         const ret = getObject(arg0) === undefined;
         return ret;
     };
-    imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
-        const ret = new Function(getStringFromWasm0(arg0, arg1));
+    imports.wbg.__wbg_newwithlength_66ae46612e7f0234 = function(arg0) {
+        const ret = new Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_has_0af94d20077affa2 = function() { return handleError(function (arg0, arg1) {
-        const ret = Reflect.has(getObject(arg0), getObject(arg1));
+    imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
         return ret;
-    }, arguments) };
-    imports.wbg.__wbg_fetch_bc7c8e27076a5c84 = function(arg0) {
-        const ret = fetch(getObject(arg0));
-        return addHeapObject(ret);
     };
-    imports.wbg.__wbg_fetch_921fad6ef9e883dd = function(arg0, arg1) {
-        const ret = getObject(arg0).fetch(getObject(arg1));
+    imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_327(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return addHeapObject(ret);
+        } finally {
+            state0.a = state0.b = 0;
+        }
     };
-    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
-        const ret = debugString(getObject(arg1));
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len1;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
-    };
-    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbindgen_rethrow = function(arg0) {
-        throw takeObject(arg0);
-    };
-    imports.wbg.__wbg_then_a73caa9a87991566 = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+    imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
         const ret = getObject(arg0).then(getObject(arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
-        queueMicrotask(getObject(arg0));
-    };
-    imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
-        const ret = getObject(arg0).queueMicrotask;
+    imports.wbg.__wbg_then_a73caa9a87991566 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
-        const ret = Promise.resolve(getObject(arg0));
+    imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
+        const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_waitAsync_5d743fc9058ba01a = function() {
-        const ret = Atomics.waitAsync;
+    imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_8cccba86b0f574cb = function(arg0) {
-        const ret = new Int32Array(getObject(arg0));
+    imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
+        const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_waitAsync_46d5c36955b71a79 = function(arg0, arg1, arg2) {
-        const ret = Atomics.waitAsync(getObject(arg0), arg1, arg2);
-        return addHeapObject(ret);
+    imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
+        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     };
-    imports.wbg.__wbg_async_19c0400d97cc72fe = function(arg0) {
-        const ret = getObject(arg0).async;
+    imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
+        const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_value_571d60108110e917 = function(arg0) {
-        const ret = getObject(arg0).value;
+    imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_link_fc1eedd35dc7e0a6 = function(arg0) {
-        const ret = "data:application/javascript," + encodeURIComponent(`onmessage = function (ev) {
-            let [ia, index, value] = ev.data;
-            ia = new Int32Array(ia.buffer);
-            let result = Atomics.wait(ia, index, value);
-            postMessage(result);
-        };
-        `);
+    imports.wbg.__wbg_has_0af94d20077affa2 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.has(getObject(arg0), getObject(arg1));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_set_1f9b04f170055d33 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() { return handleError(function (arg0) {
+        const ret = JSON.stringify(getObject(arg0));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        const ret = debugString(getObject(arg1));
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbg_new_d1187ae36d662ef9 = function() { return handleError(function (arg0, arg1) {
-        const ret = new Worker(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_setonmessage_503809e5bb51bd33 = function(arg0, arg1) {
-        getObject(arg0).onmessage = getObject(arg1);
-    };
-    imports.wbg.__wbg_of_6a70eed8d41f469c = function(arg0, arg1, arg2) {
-        const ret = Array.of(getObject(arg0), getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbg_postMessage_7380d10e8b8269df = function() { return handleError(function (arg0, arg1) {
-        getObject(arg0).postMessage(getObject(arg1));
-    }, arguments) };
-    imports.wbg.__wbg_data_3ce7c145ca4fbcdc = function(arg0) {
-        const ret = getObject(arg0).data;
+    imports.wbg.__wbindgen_module = function() {
+        const ret = __wbg_init.__wbindgen_wasm_module;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithstrandinit_3fd6fba4083ff2d0 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_responseText_c67ed2d48db10769 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg1).responseText;
-        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len1;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
-    }, arguments) };
-    imports.wbg.__wbindgen_closure_wrapper5806 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 540, __wbg_adapter_34);
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper5831 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 540, __wbg_adapter_34);
+    imports.wbg.__wbindgen_closure_wrapper6161 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 865, __wbg_adapter_32);
         return addHeapObject(ret);
     };
 
@@ -4697,7 +4743,7 @@ function __wbg_get_imports() {
 }
 
 function __wbg_init_memory(imports, maybe_memory) {
-    imports.wbg.memory = maybe_memory || new WebAssembly.Memory({initial:25,maximum:65536,shared:true});
+
 }
 
 function __wbg_finalize_init(instance, module) {
@@ -4707,16 +4753,16 @@ function __wbg_finalize_init(instance, module) {
     cachedInt32Memory0 = null;
     cachedUint8Memory0 = null;
 
-    wasm.__wbindgen_start();
+
     return wasm;
 }
 
-function initSync(module, maybe_memory) {
+function initSync(module) {
     if (wasm !== undefined) return wasm;
 
     const imports = __wbg_get_imports();
 
-    __wbg_init_memory(imports, maybe_memory);
+    __wbg_init_memory(imports);
 
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
@@ -4727,111 +4773,24 @@ function initSync(module, maybe_memory) {
     return __wbg_finalize_init(instance, module);
 }
 
-async function __wbg_init(input, maybe_memory) {
+async function __wbg_init(input) {
     if (wasm !== undefined) return wasm;
 
-
+    if (typeof input === 'undefined') {
+        input = new URL('aleo_wasm_bg.wasm', import.meta.url);
+    }
     const imports = __wbg_get_imports();
 
     if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
         input = fetch(input);
     }
 
-    __wbg_init_memory(imports, maybe_memory);
+    __wbg_init_memory(imports);
 
     const { instance, module } = await __wbg_load(await input, imports);
 
     return __wbg_finalize_init(instance, module);
 }
 
-var exports = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Address: Address,
-    AuthorizationResponse: AuthorizationResponse,
-    Execution: Execution,
-    ExecutionResponse: ExecutionResponse,
-    Field: Field,
-    JsField: JsField,
-    KeyPair: KeyPair,
-    Metadata: Metadata,
-    OfflineQuery: OfflineQuery,
-    PrivateKey: PrivateKey,
-    PrivateKeyCiphertext: PrivateKeyCiphertext,
-    Program: Program,
-    ProgramManager: ProgramManager,
-    ProvingKey: ProvingKey,
-    RecordCiphertext: RecordCiphertext,
-    RecordPlaintext: RecordPlaintext,
-    Signature: Signature,
-    Transaction: Transaction,
-    VerifyingKey: VerifyingKey,
-    ViewKey: ViewKey,
-    default: __wbg_init,
-    initSync: initSync,
-    initThreadPool: initThreadPool,
-    init_panic_hook: init_panic_hook,
-    runRayonThread: runRayonThread,
-    verifyFunctionExecution: verifyFunctionExecution
-});
-
-const wasm_path = "assets/aleo_wasm.wasm";
-
-            
-            var Cargo = async (opt = {}) => {
-                let {importHook, serverPath, initializeHook} = opt;
-
-                let final_path = wasm_path;
-
-                if (serverPath != null) {
-                    final_path = serverPath + /[^\/\\]*$/.exec(final_path)[0];
-                }
-
-                if (importHook != null) {
-                    final_path = importHook(final_path);
-                }
-
-                if (initializeHook != null) {
-                    await initializeHook(__wbg_init, final_path);
-
-                } else {
-                    await __wbg_init(final_path);
-                }
-
-                return exports;
-            };
-
-async function initializeWorker(wasm) {
-    // Wait for the main thread to send us the Module, Memory, and Rayon thread pointer.
-    function wait() {
-        return new Promise((resolve) => {
-            addEventListener("message", (event) => {
-                resolve(event.data);
-            }, {
-                capture: true,
-                once: true,
-            });
-        });
-    }
-
-    const [initWasm, { module, memory, address }] = await Promise.all([
-        wasm,
-        wait(),
-    ]);
-
-    // Runs the Wasm inside of the Worker, but using the main thread's Module and Memory.
-    const exports = await initWasm({
-        initializeHook: (init, path) => init(module, memory),
-    });
-
-    // Tells the main thread that we're finished initializing.
-    postMessage(null);
-
-    // This will hang the Worker while running the Rayon thread.
-    exports.runRayonThread(address);
-
-    // When the Rayon thread is finished, close the Worker.
-    close();
-}
-
-await initializeWorker(Cargo);
-//# sourceMappingURL=worker.js.map
+export { initSync }
+export default __wbg_init;