@puzzlehq/aleo-wasm-web 0.6.4 → 0.6.6

package/aleo_wasm.d.ts

@@ -10,10 +10,6 @@ export function init_panic_hook(): void;
 */
 export function initThreadPool(url: URL, num_threads: number): Promise<void>;
 /**
-* @param {number} receiver
-*/
-export function runRayonThread(receiver: number): void;
-/**
 * 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
 * the execution is included in the Aleo Network ledger.
@@ -31,6 +27,10 @@ export function runRayonThread(receiver: number): void;
 */
 export function verifyFunctionExecution(execution: Execution, verifying_key: VerifyingKey, program: Program, function_id: string): boolean;
 /**
+* @param {number} receiver
+*/
+export function runRayonThread(receiver: number): void;
+/**
 * Public address of an Aleo account
 */
 export class Address {
@@ -579,6 +579,34 @@ export class Program {
 export class ProgramManager {
   free(): void;
 /**
+* 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 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} 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
+* @returns {Promise<Transaction>}
+*/
+  static buildJoinTransaction(private_key: PrivateKey, record_1: RecordPlaintext, record_2: RecordPlaintext, fee_credits: number, fee_record: RecordPlaintext | undefined, url: string, join_proving_key?: ProvingKey, join_verifying_key?: VerifyingKey, fee_proving_key?: ProvingKey, fee_verifying_key?: VerifyingKey): Promise<Transaction>;
+/**
 * 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
@@ -599,13 +627,70 @@ export class ProgramManager {
 */
   static buildSplitTransaction(private_key: PrivateKey, split_amount: number, amount_record: RecordPlaintext, url: string, split_proving_key?: ProvingKey, split_verifying_key?: VerifyingKey): Promise<Transaction>;
 /**
+* 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} url
+* @param {object | undefined} imports
+* @param {ProvingKey | undefined} fee_proving_key
+* @param {VerifyingKey | undefined} fee_verifying_key
+* @returns {Promise<Transaction>}
+*/
+  static buildDeploymentTransaction(private_key: PrivateKey, program: string, fee_credits: number, fee_record: RecordPlaintext | undefined, url: string, imports?: object, fee_proving_key?: ProvingKey, fee_verifying_key?: VerifyingKey): Promise<Transaction>;
+/**
+* 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: string, imports?: object): Promise<bigint>;
+/**
+* Estimate the component of the deployment cost which comes from the fee for the program name.
+* Note that this cost does not represent the entire cost of deployment. It is additional to
+* the cost of the size (in bytes) of the deployment.
+*
+* Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+*
+* @param name The name of the program to be deployed
+* @returns {u64 | Error}
+* @param {string} name
+* @returns {bigint}
+*/
+  static estimateProgramNameCost(name: string): bigint;
+/**
 * @param {string} program_id
 * @param {string} function_id
 * @param {Array<any>} inputs_str
-* @param {PrivateKey} private_key
+* @param {string} private_key
 * @returns {Promise<string>}
 */
-  authExecute(program_id: string, function_id: string, inputs_str: Array<any>, private_key: PrivateKey): Promise<string>;
+  static authExecute(program_id: string, function_id: string, inputs_str: Array<any>, private_key: string): Promise<string>;
 /**
 * Execute an arbitrary function locally
 *
@@ -719,63 +804,6 @@ export class ProgramManager {
 */
   static estimateFinalizeFee(program: string, _function: string): bigint;
 /**
-* 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} url
-* @param {object | undefined} imports
-* @param {ProvingKey | undefined} fee_proving_key
-* @param {VerifyingKey | undefined} fee_verifying_key
-* @returns {Promise<Transaction>}
-*/
-  static buildDeploymentTransaction(private_key: PrivateKey, program: string, fee_credits: number, fee_record: RecordPlaintext | undefined, url: string, imports?: object, fee_proving_key?: ProvingKey, fee_verifying_key?: VerifyingKey): Promise<Transaction>;
-/**
-* 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: string, imports?: object): Promise<bigint>;
-/**
-* Estimate the component of the deployment cost which comes from the fee for the program name.
-* Note that this cost does not represent the entire cost of deployment. It is additional to
-* the cost of the size (in bytes) of the deployment.
-*
-* Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
-*
-* @param name The name of the program to be deployed
-* @returns {u64 | Error}
-* @param {string} name
-* @returns {bigint}
-*/
-  static estimateProgramNameCost(name: string): bigint;
-/**
 * Send credits from one Aleo account to another
 *
 * @param private_key The private key of the sender
@@ -821,34 +849,6 @@ export class ProgramManager {
 * @returns {Promise<KeyPair>}
 */
   static synthesizeKeyPair(private_key: PrivateKey, program: string, function_id: string, inputs: Array<any>, imports?: object): Promise<KeyPair>;
-/**
-* 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 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} 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
-* @returns {Promise<Transaction>}
-*/
-  static buildJoinTransaction(private_key: PrivateKey, record_1: RecordPlaintext, record_2: RecordPlaintext, fee_credits: number, fee_record: RecordPlaintext | undefined, url: string, join_proving_key?: ProvingKey, join_verifying_key?: VerifyingKey, fee_proving_key?: ProvingKey, fee_verifying_key?: VerifyingKey): Promise<Transaction>;
 }
 /**
 * Proving key for a function within an Aleo program
@@ -1174,6 +1174,38 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_address_free: (a: number) => void;
+  readonly address_from_private_key: (a: number) => number;
+  readonly address_from_view_key: (a: number) => number;
+  readonly address_from_string: (a: number, b: number) => number;
+  readonly address_to_string: (a: number, b: number) => void;
+  readonly address_verify: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbg_privatekey_free: (a: number) => void;
+  readonly privatekey_new: () => number;
+  readonly privatekey_from_seed_unchecked: (a: number, b: number) => number;
+  readonly privatekey_from_string: (a: number, b: number, c: number) => void;
+  readonly privatekey_to_string: (a: number, b: number) => void;
+  readonly privatekey_to_seed: (a: number, b: number) => void;
+  readonly privatekey_to_view_key: (a: number) => number;
+  readonly privatekey_sign: (a: number, b: number, c: number) => number;
+  readonly privatekey_newEncrypted: (a: number, b: number, c: number) => void;
+  readonly privatekey_toCiphertext: (a: number, b: number, c: number, d: number) => void;
+  readonly privatekey_fromPrivateKeyCiphertext: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbg_viewkey_free: (a: number) => void;
+  readonly viewkey_from_string: (a: number, b: number) => number;
+  readonly viewkey_to_string: (a: number, b: number) => void;
+  readonly viewkey_decrypt: (a: number, b: number, c: number, d: number) => void;
+  readonly viewkey_decrypt_ciphertext: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+  readonly programmanager_buildJoinTransaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
+  readonly __wbg_verifyingkey_free: (a: number) => void;
+  readonly verifyingkey_fromBytes: (a: number, b: number, c: number) => void;
+  readonly verifyingkey_toBytes: (a: number, b: number) => void;
+  readonly verifyingkey_fromString: (a: number, b: number, c: number) => void;
+  readonly verifyingkey_toString: (a: number, b: number) => void;
+  readonly verifyingkey_copy: (a: number) => number;
+  readonly viewkey_from_private_key: (a: number) => number;
+  readonly viewkey_to_address: (a: number) => number;
+  readonly privatekey_to_address: (a: number) => number;
   readonly __wbg_recordciphertext_free: (a: number) => void;
   readonly recordciphertext_fromString: (a: number, b: number, c: number) => void;
   readonly recordciphertext_toString: (a: number, b: number) => void;
@@ -1189,10 +1221,14 @@ export interface InitOutput {
   readonly jsfield_generate_message_leo: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly jsfield_generate_message_clients: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly programmanager_buildSplitTransaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly __wbg_provingkey_free: (a: number) => void;
-  readonly provingkey_fromBytes: (a: number, b: number, c: number) => void;
-  readonly provingkey_toBytes: (a: number, b: number) => void;
-  readonly provingkey_copy: (a: number) => number;
+  readonly __wbg_privatekeyciphertext_free: (a: number) => void;
+  readonly privatekeyciphertext_encryptPrivateKey: (a: number, b: number, c: number, d: number) => void;
+  readonly privatekeyciphertext_decryptToPrivateKey: (a: number, b: number, c: number, d: number) => void;
+  readonly privatekeyciphertext_toString: (a: number, b: number) => void;
+  readonly privatekeyciphertext_fromString: (a: number, b: number, c: number) => void;
+  readonly programmanager_buildDeploymentTransaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
+  readonly programmanager_estimateDeploymentFee: (a: number, b: number, c: number) => number;
+  readonly programmanager_estimateProgramNameCost: (a: number, b: number, c: number) => void;
   readonly programmanager_authExecute: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
   readonly programmanager_executeFunctionOffline: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
   readonly programmanager_buildExecutionTransaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number) => number;
@@ -1211,6 +1247,14 @@ export interface InitOutput {
   readonly program_id: (a: number, b: number) => void;
   readonly program_isEqual: (a: number, b: number) => number;
   readonly program_getImports: (a: number) => number;
+  readonly __wbg_execution_free: (a: number) => void;
+  readonly execution_toString: (a: number, b: number) => void;
+  readonly execution_fromString: (a: number, b: number, c: number) => void;
+  readonly verifyFunctionExecution: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly __wbg_provingkey_free: (a: number) => void;
+  readonly provingkey_fromBytes: (a: number, b: number, c: number) => void;
+  readonly provingkey_toBytes: (a: number, b: number) => void;
+  readonly provingkey_copy: (a: number) => number;
   readonly __wbg_recordplaintext_free: (a: number) => void;
   readonly recordplaintext_fromString: (a: number, b: number, c: number) => void;
   readonly recordplaintext_toString: (a: number, b: number) => void;
@@ -1218,68 +1262,24 @@ export interface InitOutput {
   readonly recordplaintext_nonce: (a: number, b: number) => void;
   readonly recordplaintext_serialNumberString: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly runRayonThread: (a: number) => void;
-  readonly __wbg_privatekeyciphertext_free: (a: number) => void;
-  readonly privatekeyciphertext_encryptPrivateKey: (a: number, b: number, c: number, d: number) => void;
-  readonly privatekeyciphertext_decryptToPrivateKey: (a: number, b: number, c: number, d: number) => void;
-  readonly privatekeyciphertext_toString: (a: number, b: number) => void;
-  readonly privatekeyciphertext_fromString: (a: number, b: number, c: number) => void;
-  readonly programmanager_buildDeploymentTransaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
-  readonly programmanager_estimateDeploymentFee: (a: number, b: number, c: number) => number;
-  readonly programmanager_estimateProgramNameCost: (a: number, b: number, c: number) => void;
-  readonly __wbg_execution_free: (a: number) => void;
-  readonly execution_toString: (a: number, b: number) => void;
-  readonly execution_fromString: (a: number, b: number, c: number) => void;
-  readonly verifyFunctionExecution: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly programmanager_buildTransferTransaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number) => number;
   readonly programmanager_synthesizeKeyPair: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly __wbg_executionresponse_free: (a: number) => void;
-  readonly executionresponse_getOutputs: (a: number) => number;
-  readonly executionresponse_getExecution: (a: number) => number;
-  readonly executionresponse_getKeys: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly __wbg_transaction_free: (a: number) => void;
   readonly transaction_fromString: (a: number, b: number, c: number) => void;
   readonly transaction_toString: (a: number, b: number) => void;
   readonly transaction_transactionId: (a: number, b: number) => void;
   readonly transaction_transactionType: (a: number, b: number) => void;
   readonly __wbg_programmanager_free: (a: number) => void;
-  readonly __wbg_privatekey_free: (a: number) => void;
-  readonly privatekey_new: () => number;
-  readonly privatekey_from_seed_unchecked: (a: number, b: number) => number;
-  readonly privatekey_from_string: (a: number, b: number, c: number) => void;
-  readonly privatekey_to_string: (a: number, b: number) => void;
-  readonly privatekey_to_seed: (a: number, b: number) => void;
-  readonly privatekey_to_view_key: (a: number) => number;
-  readonly privatekey_to_address: (a: number) => number;
-  readonly privatekey_sign: (a: number, b: number, c: number) => number;
-  readonly privatekey_newEncrypted: (a: number, b: number, c: number) => void;
-  readonly privatekey_toCiphertext: (a: number, b: number, c: number, d: number) => void;
-  readonly privatekey_fromPrivateKeyCiphertext: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbg_executionresponse_free: (a: number) => void;
+  readonly executionresponse_getOutputs: (a: number) => number;
+  readonly executionresponse_getExecution: (a: number) => number;
+  readonly executionresponse_getKeys: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly __wbg_signature_free: (a: number) => void;
+  readonly signature_sign: (a: number, b: number, c: number) => number;
   readonly signature_sign_message: (a: number, b: number, c: number, d: number, e: number) => number;
   readonly signature_verify: (a: number, b: number, c: number, d: number) => number;
   readonly signature_from_string: (a: number, b: number) => number;
   readonly signature_to_string: (a: number, b: number) => void;
-  readonly programmanager_buildJoinTransaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
-  readonly __wbg_verifyingkey_free: (a: number) => void;
-  readonly verifyingkey_fromBytes: (a: number, b: number, c: number) => void;
-  readonly verifyingkey_toBytes: (a: number, b: number) => void;
-  readonly verifyingkey_fromString: (a: number, b: number, c: number) => void;
-  readonly verifyingkey_toString: (a: number, b: number) => void;
-  readonly verifyingkey_copy: (a: number) => number;
-  readonly signature_sign: (a: number, b: number, c: number) => number;
-  readonly __wbg_address_free: (a: number) => void;
-  readonly address_from_private_key: (a: number) => number;
-  readonly address_from_view_key: (a: number) => number;
-  readonly address_from_string: (a: number, b: number) => number;
-  readonly address_to_string: (a: number, b: number) => void;
-  readonly address_verify: (a: number, b: number, c: number, d: number) => number;
-  readonly __wbg_viewkey_free: (a: number) => void;
-  readonly viewkey_from_private_key: (a: number) => number;
-  readonly viewkey_from_string: (a: number, b: number) => number;
-  readonly viewkey_to_string: (a: number, b: number) => void;
-  readonly viewkey_decrypt: (a: number, b: number, c: number, d: number) => void;
-  readonly viewkey_decrypt_ciphertext: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
-  readonly viewkey_to_address: (a: number) => number;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_export_2: WebAssembly.Table;

package/aleo_wasm.js

@@ -1,3 +1,5 @@
+import { spawnWorker } from './snippets/aleo-wasm-91297d530eb26bda/inline0.js';
+
 let wasm;
 
 const heap = new Array(128).fill(undefined);
@@ -214,6 +216,18 @@ 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);
+}
 /**
 */
 export function init_panic_hook() {
@@ -230,18 +244,6 @@ export function initThreadPool(url, num_threads) {
     return takeObject(ret);
 }
 
-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);
-}
-
 let cachedBigInt64Memory0 = null;
 
 function getBigInt64Memory0() {
@@ -250,13 +252,6 @@ function getBigInt64Memory0() {
     }
     return cachedBigInt64Memory0;
 }
-/**
-* @param {number} receiver
-*/
-export function runRayonThread(receiver) {
-    wasm.runRayonThread(receiver);
-}
-
 /**
 * 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
@@ -294,6 +289,13 @@ export function verifyFunctionExecution(execution, verifying_key, program, funct
     }
 }
 
+/**
+* @param {number} receiver
+*/
+export function runRayonThread(receiver) {
+    wasm.runRayonThread(receiver);
+}
+
 function handleError(f, args) {
     try {
         return f.apply(this, args);
@@ -839,7 +841,7 @@ export class PrivateKey {
     * @returns {Address}
     */
     to_address() {
-        const ret = wasm.privatekey_to_address(this.__wbg_ptr);
+        const ret = wasm.address_from_private_key(this.__wbg_ptr);
         return Address.__wrap(ret);
     }
     /**
@@ -1477,6 +1479,69 @@ export class ProgramManager {
         wasm.__wbg_programmanager_free(ptr);
     }
     /**
+    * Join two records together to create a new record with an amount of credits equal to the sum
+    * of the credits of the two original records
+    *
+    * @param 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} 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
+    * @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) {
+        _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();
+        }
+        const ptr3 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const 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();
+        }
+        const ret = wasm.programmanager_buildJoinTransaction(private_key.__wbg_ptr, ptr0, ptr1, fee_credits, ptr2, ptr3, len3, ptr4, ptr5, ptr6, ptr7);
+        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
@@ -1515,20 +1580,121 @@ export class ProgramManager {
         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} url
+    * @param {object | undefined} imports
+    * @param {ProvingKey | undefined} fee_proving_key
+    * @param {VerifyingKey | undefined} fee_verifying_key
+    * @returns {Promise<Transaction>}
+    */
+    static buildDeploymentTransaction(private_key, program, fee_credits, fee_record, url, imports, fee_proving_key, fee_verifying_key) {
+        _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();
+        }
+        const ptr2 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const 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();
+        }
+        const ret = wasm.programmanager_buildDeploymentTransaction(private_key.__wbg_ptr, ptr0, len0, fee_credits, ptr1, ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr3, ptr4);
+        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);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.programmanager_estimateDeploymentFee(ptr0, len0, isLikeNone(imports) ? 0 : addHeapObject(imports));
+        return takeObject(ret);
+    }
+    /**
+    * Estimate the component of the deployment cost which comes from the fee for the program name.
+    * Note that this cost does not represent the entire cost of deployment. It is additional to
+    * the cost of the size (in bytes) of the deployment.
+    *
+    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+    *
+    * @param name The name of the program to be deployed
+    * @returns {u64 | Error}
+    * @param {string} name
+    * @returns {bigint}
+    */
+    static estimateProgramNameCost(name) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.programmanager_estimateProgramNameCost(retptr, ptr0, len0);
+            var r0 = getBigInt64Memory0()[retptr / 8 + 0];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            return BigInt.asUintN(64, r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * @param {string} program_id
     * @param {string} function_id
     * @param {Array<any>} inputs_str
-    * @param {PrivateKey} private_key
+    * @param {string} private_key
     * @returns {Promise<string>}
     */
-    authExecute(program_id, function_id, inputs_str, private_key) {
-        const ptr = this.__destroy_into_raw();
+    static authExecute(program_id, function_id, inputs_str, private_key) {
         const ptr0 = passStringToWasm0(program_id, 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;
-        _assertClass(private_key, PrivateKey);
-        const ret = wasm.programmanager_authExecute(ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs_str), private_key.__wbg_ptr);
+        const ptr2 = passStringToWasm0(private_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.programmanager_authExecute(ptr0, len0, ptr1, len1, addHeapObject(inputs_str), ptr2, len2);
         return takeObject(ret);
     }
     /**
@@ -1735,107 +1901,6 @@ export class ProgramManager {
         }
     }
     /**
-    * 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} url
-    * @param {object | undefined} imports
-    * @param {ProvingKey | undefined} fee_proving_key
-    * @param {VerifyingKey | undefined} fee_verifying_key
-    * @returns {Promise<Transaction>}
-    */
-    static buildDeploymentTransaction(private_key, program, fee_credits, fee_record, url, imports, fee_proving_key, fee_verifying_key) {
-        _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();
-        }
-        const ptr2 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const 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();
-        }
-        const ret = wasm.programmanager_buildDeploymentTransaction(private_key.__wbg_ptr, ptr0, len0, fee_credits, ptr1, ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr3, ptr4);
-        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);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.programmanager_estimateDeploymentFee(ptr0, len0, isLikeNone(imports) ? 0 : addHeapObject(imports));
-        return takeObject(ret);
-    }
-    /**
-    * Estimate the component of the deployment cost which comes from the fee for the program name.
-    * Note that this cost does not represent the entire cost of deployment. It is additional to
-    * the cost of the size (in bytes) of the deployment.
-    *
-    * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
-    *
-    * @param name The name of the program to be deployed
-    * @returns {u64 | Error}
-    * @param {string} name
-    * @returns {bigint}
-    */
-    static estimateProgramNameCost(name) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.programmanager_estimateProgramNameCost(retptr, ptr0, len0);
-            var r0 = getBigInt64Memory0()[retptr / 8 + 0];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            var r3 = getInt32Memory0()[retptr / 4 + 3];
-            if (r3) {
-                throw takeObject(r2);
-            }
-            return BigInt.asUintN(64, r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
     * Send credits from one Aleo account to another
     *
     * @param private_key The private key of the sender
@@ -1929,69 +1994,6 @@ export class ProgramManager {
         const ret = wasm.programmanager_synthesizeKeyPair(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), isLikeNone(imports) ? 0 : addHeapObject(imports));
         return takeObject(ret);
     }
-    /**
-    * 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 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} 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
-    * @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) {
-        _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();
-        }
-        const ptr3 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const 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();
-        }
-        const ret = wasm.programmanager_buildJoinTransaction(private_key.__wbg_ptr, ptr0, ptr1, fee_credits, ptr2, ptr3, len3, ptr4, ptr5, ptr6, ptr7);
-        return takeObject(ret);
-    }
 }
 /**
 * Proving key for a function within an Aleo program
@@ -2370,7 +2372,7 @@ export 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);
     }
     /**
@@ -2735,7 +2737,7 @@ export class ViewKey {
     */
     static from_private_key(private_key) {
         _assertClass(private_key, PrivateKey);
-        const ret = wasm.viewkey_from_private_key(private_key.__wbg_ptr);
+        const ret = wasm.privatekey_to_view_key(private_key.__wbg_ptr);
         return ViewKey.__wrap(ret);
     }
     /**
@@ -3279,8 +3281,8 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper6270 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 837, __wbg_adapter_32);
+    imports.wbg.__wbindgen_closure_wrapper6539 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 879, __wbg_adapter_32);
         return addHeapObject(ret);
     };
 

package/package.json

@@ -4,7 +4,7 @@
     "The Aleo Team <hello@aleo.org>"
   ],
   "description": "WebAssembly based toolkit for developing zero knowledge applications with Aleo",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "license": "GPL-3.0",
   "repository": {
     "type": "git",
@@ -13,7 +13,8 @@
   "files": [
     "aleo_wasm_bg.wasm",
     "aleo_wasm.js",
-    "aleo_wasm.d.ts"
+    "aleo_wasm.d.ts",
+    "snippets/"
   ],
   "module": "aleo_wasm.js",
   "homepage": "https://aleo.org",
@@ -28,4 +29,4 @@
     "decentralized",
     "zero-knowledge"
   ]
-}
+}

package/snippets/aleo-wasm-91297d530eb26bda/inline0.js

@@ -0,0 +1,27 @@
+
+    export function spawnWorker(url, module, memory, address) {
+        return new Promise((resolve) => {
+            const worker = new Worker(url, {
+                type: "module",
+            });
+
+            worker.addEventListener("message", (event) => {
+                // When running in Node, this allows the process to exit
+                // even though the Worker is still running.
+                if (worker.unref) {
+                    worker.unref();
+                }
+
+                resolve(worker);
+            }, {
+                capture: true,
+                once: true,
+            });
+
+            worker.postMessage({
+                module,
+                memory,
+                address,
+            });
+        });
+    }