@provablehq/sdk 0.7.3 → 0.7.5

package/dist/mainnet/record-provider.d.ts

@@ -0,0 +1,236 @@
+import { RecordPlaintext } from "./wasm";
+import { Account } from "./account";
+import { AleoNetworkClient } from "./network-client";
+/**
+ * Interface for record search parameters. This allows for arbitrary search parameters to be passed to record provider
+ * implementations.
+ */
+interface RecordSearchParams {
+    [key: string]: any;
+}
+/**
+ * Interface for a record provider. A record provider is used to find records for use in deployment and execution
+ * transactions on the Aleo Network. A default implementation is provided by the NetworkRecordProvider class. However,
+ * a custom implementation can be provided (say if records are synced locally to a database from the network) by
+ * implementing this interface.
+ */
+interface RecordProvider {
+    account: Account;
+    /**
+     * Find a credits.aleo record with a given number of microcredits from the chosen provider
+     *
+     * @param {number} microcredits The number of microcredits to search for
+     * @param {boolean} unspent Whether or not the record is unspent
+     * @param {string[]} nonces Nonces of records already found so they are not found again
+     * @param {RecordSearchParams} searchParameters Additional parameters to search for
+     * @returns {Promise<RecordPlaintext>} The record if found, otherwise an error
+     *
+     * @example
+     * // A class implementing record provider can be used to find a record with a given number of microcredits
+     * const record = await recordProvider.findCreditsRecord(5000, true, []);
+     *
+     * // When a record is found but not yet used, its nonce should be added to the nonces array so that it is not
+     * // found again if a subsequent search is performed
+     * const record2 = await recordProvider.findCreditsRecord(5000, true, [record.nonce()]);
+     *
+     * // When the program manager is initialized with the record provider it will be used to find automatically find
+     * // fee records and amount records for value transfers so that they do not need to be specified manually
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     */
+    findCreditsRecord(microcredits: number, unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext>;
+    /**
+     * Find a list of credit.aleo records with a given number of microcredits from the chosen provider
+     *
+     * @param {number} microcreditAmounts A list of separate microcredit amounts to search for (e.g. [5000, 100000])
+     * @param {boolean} unspent Whether or not the record is unspent
+     * @param {string[]} nonces Nonces of records already found so that they are not found again
+     * @param {RecordSearchParams} searchParameters Additional parameters to search for
+     * @returns {Promise<RecordPlaintext[]>} A list of records with a value greater or equal to the amounts specified if such records exist, otherwise an error
+     *
+     * @example
+     * // A class implementing record provider can be used to find a record with a given number of microcredits
+     * const records = await recordProvider.findCreditsRecords([5000, 5000], true, []);
+     *
+     * // When a record is found but not yet used, it's nonce should be added to the nonces array so that it is not
+     * // found again if a subsequent search is performed
+     * const nonces = [];
+     * records.forEach(record => { nonces.push(record.nonce()) });
+     * const records2 = await recordProvider.findCreditsRecord(5000, true, nonces);
+     *
+     * // When the program manager is initialized with the record provider it will be used to find automatically find
+     * // fee records and amount records for value transfers so that they do not need to be specified manually
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     */
+    findCreditsRecords(microcreditAmounts: number[], unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext[]>;
+    /**
+     * Find an arbitrary record
+     * @param {boolean} unspent Whether or not the record is unspent
+     * @param {string[]} nonces Nonces of records already found so that they are not found again
+     * @param {RecordSearchParams} searchParameters Additional parameters to search for
+     * @returns {Promise<RecordPlaintext>} The record if found, otherwise an error
+     *
+     * @example
+     * // The RecordSearchParams interface can be used to create parameters for custom record searches which can then
+     * // be passed to the record provider. An example of how this would be done for the credits.aleo program is shown
+     * // below.
+     *
+     * class CustomRecordSearch implements RecordSearchParams {
+     *     startHeight: number;
+     *     endHeight: number;
+     *     amount: number;
+     *     program: string;
+     *     recordName: string;
+     *     constructor(startHeight: number, endHeight: number, credits: number, maxRecords: number, programName: string, recordName: string) {
+     *         this.startHeight = startHeight;
+     *         this.endHeight = endHeight;
+     *         this.amount = amount;
+     *         this.program = programName;
+     *         this.recordName = recordName;
+     *     }
+     * }
+     *
+     * const params = new CustomRecordSearch(0, 100, 5000, "credits.aleo", "credits");
+     *
+     * const record = await recordProvider.findRecord(true, [], params);
+     */
+    findRecord(unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext>;
+    /**
+     * Find multiple records from arbitrary programs
+     *
+     * @param {boolean} unspent Whether or not the record is unspent
+     * @param {string[]} nonces Nonces of records already found so that they are not found again
+     * @param {RecordSearchParams} searchParameters Additional parameters to search for
+     * @returns {Promise<RecordPlaintext>} The record if found, otherwise an error
+     *
+     * // The RecordSearchParams interface can be used to create parameters for custom record searches which can then
+     * // be passed to the record provider. An example of how this would be done for the credits.aleo program is shown
+     * // below.
+     *
+     * class CustomRecordSearch implements RecordSearchParams {
+     *     startHeight: number;
+     *     endHeight: number;
+     *     amount: number;
+     *     maxRecords: number;
+     *     programName: string;
+     *     recordName: string;
+     *     constructor(startHeight: number, endHeight: number, credits: number, maxRecords: number, programName: string, recordName: string) {
+     *         this.startHeight = startHeight;
+     *         this.endHeight = endHeight;
+     *         this.amount = amount;
+     *         this.maxRecords = maxRecords;
+     *         this.programName = programName;
+     *         this.recordName = recordName;
+     *     }
+     * }
+     *
+     * const params = new CustomRecordSearch(0, 100, 5000, 2, "credits.aleo", "credits");
+     * const records = await recordProvider.findRecord(true, [], params);
+     */
+    findRecords(unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext[]>;
+}
+/**
+ * A record provider implementation that uses the official Aleo API to find records for usage in program execution and
+ * deployment, wallet functionality, and other use cases.
+ */
+declare class NetworkRecordProvider implements RecordProvider {
+    account: Account;
+    networkClient: AleoNetworkClient;
+    constructor(account: Account, networkClient: AleoNetworkClient);
+    /**
+     * Set the account used to search for records
+     *
+     * @param {Account} account The account to use for searching for records
+     */
+    setAccount(account: Account): void;
+    /**
+     * Find a list of credit records with a given number of microcredits by via the official Aleo API
+     *
+     * @param {number[]} microcredits The number of microcredits to search for
+     * @param {boolean} unspent Whether or not the record is unspent
+     * @param {string[]} nonces Nonces of records already found so that they are not found again
+     * @param {RecordSearchParams} searchParameters Additional parameters to search for
+     * @returns {Promise<RecordPlaintext>} The record if found, otherwise an error
+     *
+     * @example
+     * // Create a new NetworkRecordProvider
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+     * const keyProvider = new AleoKeyProvider();
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // The record provider can be used to find records with a given number of microcredits
+     * const record = await recordProvider.findCreditsRecord(5000, true, []);
+     *
+     * // When a record is found but not yet used, it's nonce should be added to the nonces parameter so that it is not
+     * // found again if a subsequent search is performed
+     * const records = await recordProvider.findCreditsRecords(5000, true, [record.nonce()]);
+     *
+     * // When the program manager is initialized with the record provider it will be used to find automatically find
+     * // fee records and amount records for value transfers so that they do not need to be specified manually
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     *
+     * */
+    findCreditsRecords(microcredits: number[], unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext[]>;
+    /**
+     * Find a credit record with a given number of microcredits by via the official Aleo API
+     *
+     * @param {number} microcredits The number of microcredits to search for
+     * @param {boolean} unspent Whether or not the record is unspent
+     * @param {string[]} nonces Nonces of records already found so that they are not found again
+     * @param {RecordSearchParams} searchParameters Additional parameters to search for
+     * @returns {Promise<RecordPlaintext>} The record if found, otherwise an error
+     *
+     * @example
+     * // Create a new NetworkRecordProvider
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+     * const keyProvider = new AleoKeyProvider();
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // The record provider can be used to find records with a given number of microcredits
+     * const record = await recordProvider.findCreditsRecord(5000, true, []);
+     *
+     * // When a record is found but not yet used, it's nonce should be added to the nonces parameter so that it is not
+     * // found again if a subsequent search is performed
+     * const records = await recordProvider.findCreditsRecords(5000, true, [record.nonce()]);
+     *
+     * // When the program manager is initialized with the record provider it will be used to find automatically find
+     * // fee records and amount records for value transfers so that they do not need to be specified manually
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     */
+    findCreditsRecord(microcredits: number, unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext>;
+    /**
+     * Find an arbitrary record. WARNING: This function is not implemented yet and will throw an error.
+     */
+    findRecord(unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext>;
+    /**
+     * Find multiple arbitrary records. WARNING: This function is not implemented yet and will throw an error.
+     */
+    findRecords(unspent: boolean, nonces?: string[], searchParameters?: RecordSearchParams): Promise<RecordPlaintext[]>;
+}
+/**
+ * BlockHeightSearch is a RecordSearchParams implementation that allows for searching for records within a given
+ * block height range.
+ *
+ * @example
+ * // Create a new BlockHeightSearch
+ * const params = new BlockHeightSearch(89995, 99995);
+ *
+ * // Create a new NetworkRecordProvider
+ * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+ * const keyProvider = new AleoKeyProvider();
+ * const recordProvider = new NetworkRecordProvider(account, networkClient);
+ *
+ * // The record provider can be used to find records with a given number of microcredits and the block height search
+ * // can be used to find records within a given block height range
+ * const record = await recordProvider.findCreditsRecord(5000, true, [], params);
+ *
+ */
+declare class BlockHeightSearch implements RecordSearchParams {
+    startHeight: number;
+    endHeight: number;
+    constructor(startHeight: number, endHeight: number);
+}
+export { BlockHeightSearch, NetworkRecordProvider, RecordProvider, RecordSearchParams };

package/dist/mainnet/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function logAndThrow(message: string): never;
+export declare function parseJSON(json: string): any;
+export declare function get(url: URL | string, options?: RequestInit): Promise<Response>;
+export declare function post(url: URL | string, options: RequestInit): Promise<Response>;

package/dist/mainnet/wasm.d.ts

@@ -0,0 +1 @@
+export { Address, Execution, ExecutionResponse, Field, OfflineQuery, Metadata, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, ProvingKey, RecordCiphertext, RecordPlaintext, Signature, Transaction, VerifyingKey, ViewKey, initThreadPool, verifyFunctionExecution, } from "@provablehq/wasm/mainnet.js";

package/dist/mainnet/worker.d.ts

@@ -0,0 +1,9 @@
+import "./polyfill/shared";
+import { PrivateKey } from "./browser";
+export interface WorkerAPI {
+    run: (localProgram: string, aleoFunction: string, inputs: string[], privateKey: string) => Promise<{
+        outputs: any;
+        execution: string;
+    } | string>;
+    getPrivateKey: () => Promise<PrivateKey>;
+}

package/dist/mainnet/worker.js

@@ -0,0 +1,78 @@
+import 'core-js/proposals/json-parse-with-source.js';
+import { initThreadPool, PrivateKey, verifyFunctionExecution } from '@provablehq/wasm/mainnet.js';
+import { P as ProgramManager, A as AleoKeyProvider, a as AleoKeyProviderParams } from './program-manager-a25c2f23.js';
+import { expose } from 'comlink';
+
+await initThreadPool();
+const defaultHost = "https://api.explorer.provable.com/v1";
+const keyProvider = new AleoKeyProvider();
+const programManager = new ProgramManager(defaultHost, keyProvider, undefined);
+keyProvider.useCache(true);
+let lastLocalProgram = "";
+async function run(localProgram, aleoFunction, inputs, privateKey, proveExecution = false) {
+    console.log("Web worker: Executing function locally...");
+    const startTime = performance.now();
+    // Ensure the program is valid and that it contains the function specified
+    let program;
+    try {
+        program = programManager.createProgramFromSource(localProgram);
+    }
+    catch (e) {
+        throw new Error("Error creating program from source");
+    }
+    const program_id = program.id();
+    if (!program.hasFunction(aleoFunction)) {
+        throw new Error(`Program ${program_id} does not contain function ${aleoFunction}`);
+    }
+    const cacheKey = `${program_id}:${aleoFunction}`;
+    // Get the program imports
+    let imports;
+    try {
+        imports = await programManager.networkClient.getProgramImports(localProgram);
+    }
+    catch (e) {
+        throw new Error("Error getting program imports");
+    }
+    // Get the proving and verifying keys for the function
+    if (lastLocalProgram !== localProgram) {
+        const keys = await programManager.synthesizeKeys(localProgram, aleoFunction, inputs, PrivateKey.from_string(privateKey));
+        programManager.keyProvider.cacheKeys(cacheKey, keys);
+        lastLocalProgram = localProgram;
+    }
+    // Pass the cache key to the execute function
+    const keyParams = new AleoKeyProviderParams({
+        cacheKey: cacheKey,
+    });
+    // Execute the function locally
+    const response = await programManager.run(localProgram, aleoFunction, inputs, proveExecution, imports, keyParams, undefined, undefined, PrivateKey.from_string(privateKey));
+    // Return the outputs to the main thread
+    console.log(`Web worker: Local execution completed in ${performance.now() - startTime} ms`);
+    const outputs = response.getOutputs();
+    const execution = response.getExecution();
+    let executionString = "";
+    let keys;
+    try {
+        keys = keyProvider.getKeys(cacheKey);
+    }
+    catch (e) {
+        throw new Error("Could not get verifying key");
+    }
+    const verifyingKey = keys[1];
+    if (execution) {
+        verifyFunctionExecution(execution, verifyingKey, program, "hello");
+        executionString = execution.toString();
+        console.log("Execution verified successfully: " + execution);
+    }
+    else {
+        executionString = "";
+    }
+    console.log(`Function execution response: ${outputs}`);
+    return { outputs: outputs, execution: executionString };
+}
+async function getPrivateKey() {
+    const privateKey = new PrivateKey();
+    return privateKey.to_string();
+}
+const workerAPI = { run, getPrivateKey };
+expose(workerAPI);
+//# sourceMappingURL=worker.js.map

package/dist/mainnet/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sources":["../../src/worker.ts"],"sourcesContent":["import \"./polyfill/shared\";\nimport {initThreadPool, ProgramManager, PrivateKey, verifyFunctionExecution, FunctionKeyPair} from \"./browser\";\nimport { AleoKeyProvider, AleoKeyProviderParams} from \"./function-key-provider\";\nimport { expose } from \"comlink\";\n\nawait initThreadPool();\n\nconst defaultHost = \"https://api.explorer.provable.com/v1\";\nconst keyProvider = new AleoKeyProvider();\nconst programManager = new ProgramManager(\n    defaultHost,\n    keyProvider,\n    undefined\n);\n\nkeyProvider.useCache(true);\n\nlet lastLocalProgram: string = \"\";\n\nexport interface WorkerAPI {\n    run: (\n        localProgram: string,\n        aleoFunction: string,\n        inputs: string[],\n        privateKey: string\n    ) => Promise<{ outputs: any; execution: string } | string>;\n\n    getPrivateKey: () => Promise<PrivateKey>;\n}\nasync function run(\n    localProgram: string,\n    aleoFunction: string,\n    inputs: string[],\n    privateKey: string,\n    proveExecution = false\n) {\n    console.log(\"Web worker: Executing function locally...\");\n    const startTime = performance.now();\n\n    // Ensure the program is valid and that it contains the function specified\n    let program;\n\n    try {\n        program = programManager.createProgramFromSource(localProgram);\n    } catch (e) {\n        throw new Error(\"Error creating program from source\");\n    }\n\n    const program_id = program.id();\n    if (!program.hasFunction(aleoFunction)) {\n        throw new Error(`Program ${program_id} does not contain function ${aleoFunction}`);\n    }\n    const cacheKey = `${program_id}:${aleoFunction}`;\n\n\n    // Get the program imports\n    let imports;\n\n    try {\n        imports = await programManager.networkClient.getProgramImports(\n            localProgram\n        );\n    } catch (e) {\n        throw new Error(\"Error getting program imports\");\n    }\n\n    // Get the proving and verifying keys for the function\n    if (lastLocalProgram !== localProgram) {\n        const keys = <FunctionKeyPair>await programManager.synthesizeKeys(\n            localProgram,\n            aleoFunction,\n            inputs,\n            PrivateKey.from_string(privateKey)\n        );\n        programManager.keyProvider.cacheKeys(cacheKey, keys);\n        lastLocalProgram = localProgram;\n    }\n\n    // Pass the cache key to the execute function\n    const keyParams = new AleoKeyProviderParams({\n        cacheKey: cacheKey,\n    });\n\n    // Execute the function locally\n    const response = await programManager.run(\n        localProgram,\n        aleoFunction,\n        inputs,\n        proveExecution,\n        imports,\n        keyParams,\n        undefined,\n        undefined,\n        PrivateKey.from_string(privateKey),\n    );\n\n    // Return the outputs to the main thread\n    console.log(\n        `Web worker: Local execution completed in ${\n            performance.now() - startTime\n        } ms`\n    );\n    const outputs = response.getOutputs();\n    const execution = response.getExecution();\n    let executionString = \"\";\n\n    let keys;\n\n    try {\n        keys = keyProvider.getKeys(cacheKey);\n    } catch (e) {\n        throw new Error(\"Could not get verifying key\");\n    }\n\n    const verifyingKey = keys[1];\n\n    if (execution) {\n        verifyFunctionExecution(\n            execution,\n            verifyingKey,\n            program,\n            \"hello\"\n        );\n        executionString = execution.toString();\n        console.log(\"Execution verified successfully: \" + execution);\n    } else {\n        executionString = \"\";\n    }\n\n    console.log(`Function execution response: ${outputs}`);\n\n    return { outputs: outputs, execution: executionString };\n}\n\nasync function getPrivateKey() {\n    const privateKey = new PrivateKey();\n    return privateKey.to_string();\n}\n\nconst workerAPI = { run, getPrivateKey };\nexpose(workerAPI);\n"],"names":[],"mappings":"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"}

package/dist/testnet/account.d.ts

@@ -0,0 +1,137 @@
+import { Address, PrivateKey, Signature, ViewKey, PrivateKeyCiphertext, RecordCiphertext } from "./wasm";
+interface AccountParam {
+    privateKey?: string;
+    seed?: Uint8Array;
+}
+/**
+ * Key Management class. Enables the creation of a new Aleo Account, importation of an existing account from
+ * an existing private key or seed, and message signing and verification functionality.
+ *
+ * An Aleo Account is generated from a randomly generated seed (number) from which an account private key, view key,
+ * and a public account address are derived. The private key lies at the root of an Aleo account. It is a highly
+ * sensitive secret and should be protected as it allows for creation of Aleo Program executions and arbitrary value
+ * transfers. The View Key allows for decryption of a user's activity on the blockchain. The Address is the public
+ * address to which other users of Aleo can send Aleo credits and other records to. This class should only be used
+ * environments where the safety of the underlying key material can be assured.
+ *
+ * @example
+ * // Create a new account
+ * const myRandomAccount = new Account();
+ *
+ * // Create an account from a randomly generated seed
+ * const seed = new Uint8Array([94, 91, 52, 251, 240, 230, 226, 35, 117, 253, 224, 210, 175, 13, 205, 120, 155, 214, 7, 169, 66, 62, 206, 50, 188, 40, 29, 122, 40, 250, 54, 18]);
+ * const mySeededAccount = new Account({seed: seed});
+ *
+ * // Create an account from an existing private key
+ * const myExistingAccount = new Account({privateKey: 'myExistingPrivateKey'})
+ *
+ * // Sign a message
+ * const hello_world = Uint8Array.from([104, 101, 108, 108, 111 119, 111, 114, 108, 100])
+ * const signature = myRandomAccount.sign(hello_world)
+ *
+ * // Verify a signature
+ * myRandomAccount.verify(hello_world, signature)
+ */
+export declare class Account {
+    _privateKey: PrivateKey;
+    _viewKey: ViewKey;
+    _address: Address;
+    constructor(params?: AccountParam);
+    /**
+     * Attempts to create an account from a private key ciphertext
+     * @param {PrivateKeyCiphertext | string} ciphertext
+     * @param {string} password
+     * @returns {PrivateKey}
+     *
+     * @example
+     * const ciphertext = PrivateKey.newEncrypted("password");
+     * const account = Account.fromCiphertext(ciphertext, "password");
+     */
+    static fromCiphertext(ciphertext: PrivateKeyCiphertext | string, password: string): Account;
+    private privateKeyFromParams;
+    privateKey(): PrivateKey;
+    viewKey(): ViewKey;
+    address(): Address;
+    toString(): any;
+    /**
+     * Encrypt the account's private key with a password
+     * @param {string} ciphertext
+     * @returns {PrivateKeyCiphertext}
+     *
+     * @example
+     * const account = new Account();
+     * const ciphertext = account.encryptAccount("password");
+     */
+    encryptAccount(password: string): any;
+    /**
+     * Decrypts a Record in ciphertext form into plaintext
+     * @param {string} ciphertext
+     * @returns {Record}
+     *
+     * @example
+     * const account = new Account();
+     * const record = account.decryptRecord("record1ciphertext");
+     */
+    decryptRecord(ciphertext: string): any;
+    /**
+     * Decrypts an array of Records in ciphertext form into plaintext
+     * @param {string[]} ciphertexts
+     * @returns {Record[]}
+     *
+     * @example
+     * const account = new Account();
+     * const record = account.decryptRecords(["record1ciphertext", "record2ciphertext"]);
+     */
+    decryptRecords(ciphertexts: string[]): any[];
+    /**
+     * Determines whether the account owns a ciphertext record
+     * @param {RecordCipherText | string} ciphertext
+     * @returns {boolean}
+     *
+     * @example
+     * // Create a connection to the Aleo network and an account
+     * const connection = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+     * const account = Account.fromCiphertext("ciphertext", "password");
+     *
+     * // Get a record from the network
+     * const record = connection.getBlock(1234);
+     * const recordCipherText = record.transactions[0].execution.transitions[0].id;
+     *
+     * // Check if the account owns the record
+     * if account.ownsRecord(recordCipherText) {
+     *     // Then one can do something like:
+     *     // Decrypt the record and check if it's spent
+     *     // Store the record in a local database
+     *     // Etc.
+     * }
+     */
+    ownsRecordCiphertext(ciphertext: RecordCiphertext | string): any;
+    /**
+     * Signs a message with the account's private key.
+     * Returns a Signature.
+     *
+     * @param {Uint8Array} message
+     * @returns {Signature}
+     *
+     * @example
+     * const account = new Account();
+     * const message = Uint8Array.from([104, 101, 108, 108, 111 119, 111, 114, 108, 100])
+     * account.sign(message);
+     */
+    sign(message: Uint8Array): any;
+    /**
+     * Verifies the Signature on a message.
+     *
+     * @param {Uint8Array} message
+     * @param {Signature} signature
+     * @returns {boolean}
+     *
+     * @example
+     * const account = new Account();
+     * const message = Uint8Array.from([104, 101, 108, 108, 111 119, 111, 114, 108, 100])
+     * const signature = account.sign(message);
+     * account.verify(message, signature);
+     */
+    verify(message: Uint8Array, signature: Signature): any;
+}
+export {};

package/dist/testnet/browser.d.ts

@@ -0,0 +1,20 @@
+import "./polyfill/shared";
+import { Account } from "./account";
+import { AleoNetworkClient, ProgramImports } from "./network-client";
+import { Block } from "./models/block";
+import { Execution } from "./models/execution";
+import { Input } from "./models/input";
+import { Output } from "./models/output";
+import { TransactionModel } from "./models/transactionModel";
+import { Transition } from "./models/transition";
+import { AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, CachedKeyPair, FunctionKeyPair, FunctionKeyProvider, KeySearchParams } from "./function-key-provider";
+import { OfflineKeyProvider, OfflineSearchParams } from "./offline-key-provider";
+import { BlockHeightSearch, NetworkRecordProvider, RecordProvider, RecordSearchParams } from "./record-provider";
+declare function initializeWasm(): Promise<void>;
+export { createAleoWorker } from "./managed-worker";
+export { ProgramManager } from "./program-manager";
+export { logAndThrow } from "./utils";
+export { Address, Execution as FunctionExecution, ExecutionResponse, Field, OfflineQuery, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, RecordCiphertext, RecordPlaintext, Signature, Transaction, VerifyingKey, ViewKey, initThreadPool, verifyFunctionExecution, } from "./wasm";
+export { initializeWasm };
+export { Key, CREDITS_PROGRAM_KEYS, KEY_STORE, PRIVATE_TRANSFER, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, PUBLIC_TO_PRIVATE_TRANSFER, VALID_TRANSFER_TYPES, } from "./constants";
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, Block, BlockHeightSearch, CachedKeyPair, Execution, FunctionKeyPair, FunctionKeyProvider, Input, KeySearchParams, NetworkRecordProvider, ProgramImports, OfflineKeyProvider, OfflineSearchParams, Output, RecordProvider, RecordSearchParams, TransactionModel, Transition, };