@provablehq/sdk 0.6.13 → 0.7.1

package/dist/{index.js → testnet/program-manager-97ade0e6.js}

@@ -1,197 +1,20 @@
-import { ViewKey, Address, PrivateKeyCiphertext, PrivateKey, RecordCiphertext, Program, Transaction, ProvingKey, VerifyingKey, ProgramManager as ProgramManager$1, RecordPlaintext, verifyFunctionExecution, Metadata } from '@provablehq/wasm';
-export { Address, ExecutionResponse, Field, Execution as FunctionExecution, OfflineQuery, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, RecordCiphertext, RecordPlaintext, Signature, Transaction, VerifyingKey, ViewKey, initThreadPool, verifyFunctionExecution } from '@provablehq/wasm';
-import { wrap } from 'comlink';
+import { PrivateKey, RecordCiphertext, Program, Transaction, Metadata, VerifyingKey, ProvingKey, ProgramManager as ProgramManager$1, RecordPlaintext, verifyFunctionExecution } from '@provablehq/wasm/testnet.js';
 
-/**
- * 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)
- */
-class Account {
-    _privateKey;
-    _viewKey;
-    _address;
-    constructor(params = {}) {
-        try {
-            this._privateKey = this.privateKeyFromParams(params);
-        }
-        catch (e) {
-            console.error("Wrong parameter", e);
-            throw new Error("Wrong Parameter");
-        }
-        this._viewKey = ViewKey.from_private_key(this._privateKey);
-        this._address = Address.from_private_key(this._privateKey);
-    }
-    /**
-     * Attempts to create an account from a private key ciphertext
-     * @param {PrivateKeyCiphertext | string} ciphertext
-     * @param {string} password
-     * @returns {PrivateKey | Error}
-     *
-     * @example
-     * const ciphertext = PrivateKey.newEncrypted("password");
-     * const account = Account.fromCiphertext(ciphertext, "password");
-     */
-    static fromCiphertext(ciphertext, password) {
-        try {
-            ciphertext = (typeof ciphertext === "string") ? PrivateKeyCiphertext.fromString(ciphertext) : ciphertext;
-            const _privateKey = PrivateKey.fromPrivateKeyCiphertext(ciphertext, password);
-            return new Account({ privateKey: _privateKey.to_string() });
-        }
-        catch (e) {
-            throw new Error("Wrong password or invalid ciphertext");
-        }
-    }
-    privateKeyFromParams(params) {
-        if (params.seed) {
-            return PrivateKey.from_seed_unchecked(params.seed);
-        }
-        if (params.privateKey) {
-            return PrivateKey.from_string(params.privateKey);
-        }
-        return new PrivateKey();
-    }
-    privateKey() {
-        return this._privateKey;
-    }
-    viewKey() {
-        return this._viewKey;
-    }
-    address() {
-        return this._address;
-    }
-    toString() {
-        return this.address().to_string();
-    }
-    /**
-     * 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) {
-        return this._privateKey.toCiphertext(password);
-    }
-    /**
-     * 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) {
-        return this._viewKey.decrypt(ciphertext);
-    }
-    /**
-     * 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) {
-        return ciphertexts.map((ciphertext) => this._viewKey.decrypt(ciphertext));
-    }
-    /**
-     * 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 NodeConnection("vm.aleo.org/api");
-     * 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) {
-        if (typeof ciphertext === 'string') {
-            try {
-                const ciphertextObject = RecordCiphertext.fromString(ciphertext);
-                return ciphertextObject.isOwner(this._viewKey);
-            }
-            catch (e) {
-                return false;
-            }
+function logAndThrow(message) {
+    console.error(message);
+    throw new Error(message);
+}
+function parseJSON(json) {
+    function revive(key, value, context) {
+        if (Number.isInteger(value)) {
+            return BigInt(context.source);
         }
         else {
-            return ciphertext.isOwner(this._viewKey);
+            return value;
         }
     }
-    /**
-     * 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) {
-        return this._privateKey.sign(message);
-    }
-    /**
-     * 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, signature) {
-        return this._address.verify(message, signature);
-    }
+    return JSON.parse(json, revive);
 }
-
 async function get(url, options) {
     const response = await fetch(url, options);
     if (!response.ok) {
@@ -218,7 +41,7 @@ async function post(url, options) {
  * const localNetworkClient = new AleoNetworkClient("http://localhost:3030");
  *
  * // Connection to a public beacon node
- * const publicnetworkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+ * const publicnetworkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
  */
 class AleoNetworkClient {
     host;
@@ -232,7 +55,7 @@ class AleoNetworkClient {
         else {
             this.headers = {
                 // This is replaced by the actual version by a Rollup plugin
-                "X-Aleo-SDK-Version": "0.6.12",
+                "X-Aleo-SDK-Version": "0.7.0",
             };
         }
     }
@@ -270,7 +93,8 @@ class AleoNetworkClient {
             const response = await get(this.host + url, {
                 headers: this.headers
             });
-            return await response.json();
+            const text = await response.text();
+            return parseJSON(text);
         }
         catch (error) {
             throw new Error("Error fetching data.");
@@ -365,49 +189,63 @@ class AleoNetworkClient {
                 // Get 50 blocks (or the difference between the start and end if less than 50)
                 const blocks = await this.getBlockRange(start, end);
                 end = start;
-                if (!(blocks instanceof Error)) {
-                    // Iterate through blocks to find unspent records
-                    for (let i = 0; i < blocks.length; i++) {
-                        const block = blocks[i];
-                        const transactions = block.transactions;
-                        if (!(typeof transactions === "undefined")) {
-                            for (let j = 0; j < transactions.length; j++) {
-                                const confirmedTransaction = transactions[j];
-                                // Search for unspent records in execute transactions of credits.aleo
-                                if (confirmedTransaction.type == "execute") {
-                                    const transaction = confirmedTransaction.transaction;
-                                    if (transaction.execution && !(typeof transaction.execution.transitions == "undefined")) {
-                                        for (let k = 0; k < transaction.execution.transitions.length; k++) {
-                                            const transition = transaction.execution.transitions[k];
-                                            // Only search for unspent records in credits.aleo (for now)
-                                            if (transition.program !== "credits.aleo") {
-                                                continue;
-                                            }
-                                            if (!(typeof transition.outputs == "undefined")) {
-                                                for (let l = 0; l < transition.outputs.length; l++) {
-                                                    const output = transition.outputs[l];
-                                                    if (output.type === "record") {
-                                                        try {
-                                                            // Create a wasm record ciphertext object from the found output
-                                                            const record = RecordCiphertext.fromString(output.value);
-                                                            // Determine if the record is owned by the specified view key
-                                                            if (record.isOwner(viewKey)) {
-                                                                // Decrypt the record and get the serial number
-                                                                const recordPlaintext = record.decrypt(viewKey);
-                                                                // If the record has already been found, skip it
-                                                                const nonce = recordPlaintext.nonce();
-                                                                if (nonces.includes(nonce)) {
-                                                                    continue;
-                                                                }
-                                                                // Otherwise record the nonce that has been found
-                                                                const serialNumber = recordPlaintext.serialNumberString(resolvedPrivateKey, "credits.aleo", "credits");
-                                                                // Attempt to see if the serial number is spent
-                                                                try {
-                                                                    await this.getTransitionId(serialNumber);
+                // Iterate through blocks to find unspent records
+                for (let i = 0; i < blocks.length; i++) {
+                    const block = blocks[i];
+                    const transactions = block.transactions;
+                    if (!(typeof transactions === "undefined")) {
+                        for (let j = 0; j < transactions.length; j++) {
+                            const confirmedTransaction = transactions[j];
+                            // Search for unspent records in execute transactions of credits.aleo
+                            if (confirmedTransaction.type == "execute") {
+                                const transaction = confirmedTransaction.transaction;
+                                if (transaction.execution && !(typeof transaction.execution.transitions == "undefined")) {
+                                    for (let k = 0; k < transaction.execution.transitions.length; k++) {
+                                        const transition = transaction.execution.transitions[k];
+                                        // Only search for unspent records in credits.aleo (for now)
+                                        if (transition.program !== "credits.aleo") {
+                                            continue;
+                                        }
+                                        if (!(typeof transition.outputs == "undefined")) {
+                                            for (let l = 0; l < transition.outputs.length; l++) {
+                                                const output = transition.outputs[l];
+                                                if (output.type === "record") {
+                                                    try {
+                                                        // Create a wasm record ciphertext object from the found output
+                                                        const record = RecordCiphertext.fromString(output.value);
+                                                        // Determine if the record is owned by the specified view key
+                                                        if (record.isOwner(viewKey)) {
+                                                            // Decrypt the record and get the serial number
+                                                            const recordPlaintext = record.decrypt(viewKey);
+                                                            // If the record has already been found, skip it
+                                                            const nonce = recordPlaintext.nonce();
+                                                            if (nonces.includes(nonce)) {
+                                                                continue;
+                                                            }
+                                                            // Otherwise record the nonce that has been found
+                                                            const serialNumber = recordPlaintext.serialNumberString(resolvedPrivateKey, "credits.aleo", "credits");
+                                                            // Attempt to see if the serial number is spent
+                                                            try {
+                                                                await this.getTransitionId(serialNumber);
+                                                            }
+                                                            catch (error) {
+                                                                // If it's not found, add it to the list of unspent records
+                                                                if (!amounts) {
+                                                                    records.push(recordPlaintext);
+                                                                    // If the user specified a maximum number of microcredits, check if the search has found enough
+                                                                    if (typeof maxMicrocredits === "number") {
+                                                                        totalRecordValue += recordPlaintext.microcredits();
+                                                                        // Exit if the search has found the amount specified
+                                                                        if (totalRecordValue >= BigInt(maxMicrocredits)) {
+                                                                            return records;
+                                                                        }
+                                                                    }
                                                                 }
-                                                                catch (error) {
-                                                                    // If it's not found, add it to the list of unspent records
-                                                                    if (!amounts) {
+                                                                // If the user specified a list of amounts, check if the search has found them
+                                                                if (!(typeof amounts === "undefined") && amounts.length > 0) {
+                                                                    let amounts_found = 0;
+                                                                    if (recordPlaintext.microcredits() > amounts[amounts_found]) {
+                                                                        amounts_found += 1;
                                                                         records.push(recordPlaintext);
                                                                         // If the user specified a maximum number of microcredits, check if the search has found enough
                                                                         if (typeof maxMicrocredits === "number") {
@@ -417,31 +255,15 @@ class AleoNetworkClient {
                                                                                 return records;
                                                                             }
                                                                         }
-                                                                    }
-                                                                    // If the user specified a list of amounts, check if the search has found them
-                                                                    if (!(typeof amounts === "undefined") && amounts.length > 0) {
-                                                                        let amounts_found = 0;
-                                                                        if (recordPlaintext.microcredits() > amounts[amounts_found]) {
-                                                                            amounts_found += 1;
-                                                                            records.push(recordPlaintext);
-                                                                            // If the user specified a maximum number of microcredits, check if the search has found enough
-                                                                            if (typeof maxMicrocredits === "number") {
-                                                                                totalRecordValue += recordPlaintext.microcredits();
-                                                                                // Exit if the search has found the amount specified
-                                                                                if (totalRecordValue >= BigInt(maxMicrocredits)) {
-                                                                                    return records;
-                                                                                }
-                                                                            }
-                                                                            if (records.length >= amounts.length) {
-                                                                                return records;
-                                                                            }
+                                                                        if (records.length >= amounts.length) {
+                                                                            return records;
                                                                         }
                                                                     }
                                                                 }
                                                             }
                                                         }
-                                                        catch (error) {
-                                                        }
+                                                    }
+                                                    catch (error) {
                                                     }
                                                 }
                                             }
@@ -495,7 +317,7 @@ class AleoNetworkClient {
             return await this.fetchData("/blocks?start=" + start + "&end=" + end);
         }
         catch (error) {
-            const errorMessage = "Error fetching blocks between " + start + " and " + end + ".";
+            const errorMessage = `Error fetching blocks between ${start} and ${end}.`;
             throw new Error(errorMessage);
         }
     }
@@ -503,7 +325,7 @@ class AleoNetworkClient {
      * Returns the deployment transaction id associated with the specified program
      *
      * @param {Program | string} program
-     * @returns {TransactionModel | Error}
+     * @returns {TransactionModel}
      */
     async getDeploymentTransactionIDForProgram(program) {
         if (program instanceof Program) {
@@ -521,7 +343,7 @@ class AleoNetworkClient {
      * Returns the deployment transaction associated with a specified program
      *
      * @param {Program | string} program
-     * @returns {TransactionModel | Error}
+     * @returns {TransactionModel}
      */
     async getDeploymentTransactionForProgram(program) {
         try {
@@ -540,7 +362,7 @@ class AleoNetworkClient {
      */
     async getLatestBlock() {
         try {
-            return await this.fetchData("/latest/block");
+            return await this.fetchData("/block/latest");
         }
         catch (error) {
             throw new Error("Error fetching latest block.");
@@ -567,7 +389,7 @@ class AleoNetworkClient {
      */
     async getLatestHeight() {
         try {
-            return await this.fetchData("/latest/height");
+            return Number(await this.fetchData("/block/height/latest"));
         }
         catch (error) {
             throw new Error("Error fetching latest height.");
@@ -596,7 +418,7 @@ class AleoNetworkClient {
      * Returns a program object from a program ID or program source code
      *
      * @param {string} inputProgram The program ID or program source code of a program deployed to the Aleo Network
-     * @return {Promise<Program | Error>} Source code of the program
+     * @return {Promise<Program>} Source code of the program
      *
      * @example
      * const programID = "hello_hello.aleo";
@@ -671,7 +493,7 @@ class AleoNetworkClient {
             return imports;
         }
         catch (error) {
-            throw logAndThrow("Error fetching program imports: " + error);
+            logAndThrow("Error fetching program imports: " + error.message);
         }
     }
     /**
@@ -691,7 +513,7 @@ class AleoNetworkClient {
             return program.getImports();
         }
         catch (error) {
-            throw new Error("Error fetching program imports with error: " + error);
+            throw new Error("Error fetching program imports with error: " + error.message);
         }
     }
     /**
@@ -741,7 +563,7 @@ class AleoNetworkClient {
      */
     async getStateRoot() {
         try {
-            return await this.fetchData("/latest/stateRoot");
+            return await this.fetchData("/stateRoot/latest");
         }
         catch (error) {
             throw new Error("Error fetching Aleo state root");
@@ -810,7 +632,7 @@ class AleoNetworkClient {
      * Submit an execute or deployment transaction to the Aleo network
      *
      * @param {Transaction | string} transaction  - The transaction to submit to the network
-     * @returns {string | Error} - The transaction id of the submitted transaction or the resulting error
+     * @returns {string} - The transaction id of the submitted transaction or the resulting error
      */
     async submitTransaction(transaction) {
         const transaction_string = transaction instanceof Transaction ? transaction.toString() : transaction;
@@ -822,7 +644,8 @@ class AleoNetworkClient {
                 }),
             });
             try {
-                return await response.json();
+                const text = await response.text();
+                return parseJSON(text);
             }
             catch (error) {
                 throw new Error(`Error posting transaction. Aleo network response: ${error.message}`);
@@ -834,6 +657,100 @@ class AleoNetworkClient {
     }
 }
 
+const KEY_STORE = Metadata.baseUrl();
+function convert(metadata) {
+    // This looks up the method name in VerifyingKey
+    const verifyingKey = VerifyingKey[metadata.verifyingKey];
+    if (!verifyingKey) {
+        throw new Error("Invalid method name: " + metadata.verifyingKey);
+    }
+    return {
+        name: metadata.name,
+        locator: metadata.locator,
+        prover: metadata.prover,
+        verifier: metadata.verifier,
+        verifyingKey,
+    };
+}
+const CREDITS_PROGRAM_KEYS = {
+    bond_public: convert(Metadata.bond_public()),
+    bond_validator: convert(Metadata.bond_validator()),
+    claim_unbond_public: convert(Metadata.claim_unbond_public()),
+    fee_private: convert(Metadata.fee_private()),
+    fee_public: convert(Metadata.fee_public()),
+    inclusion: convert(Metadata.inclusion()),
+    join: convert(Metadata.join()),
+    set_validator_state: convert(Metadata.set_validator_state()),
+    split: convert(Metadata.split()),
+    transfer_private: convert(Metadata.transfer_private()),
+    transfer_private_to_public: convert(Metadata.transfer_private_to_public()),
+    transfer_public: convert(Metadata.transfer_public()),
+    transfer_public_as_signer: convert(Metadata.transfer_public_as_signer()),
+    transfer_public_to_private: convert(Metadata.transfer_public_to_private()),
+    unbond_public: convert(Metadata.unbond_public()),
+    getKey: function (key) {
+        if (this.hasOwnProperty(key)) {
+            return this[key];
+        }
+        else {
+            throw new Error(`Key "${key}" not found.`);
+        }
+    }
+};
+const PRIVATE_TRANSFER_TYPES = new Set([
+    "transfer_private",
+    "private",
+    "transferPrivate",
+    "transfer_private_to_public",
+    "privateToPublic",
+    "transferPrivateToPublic",
+]);
+const VALID_TRANSFER_TYPES = new Set([
+    "transfer_private",
+    "private",
+    "transferPrivate",
+    "transfer_private_to_public",
+    "privateToPublic",
+    "transferPrivateToPublic",
+    "transfer_public",
+    "transfer_public_as_signer",
+    "public",
+    "public_as_signer",
+    "transferPublic",
+    "transferPublicAsSigner",
+    "transfer_public_to_private",
+    "publicToPrivate",
+    "publicAsSigner",
+    "transferPublicToPrivate",
+]);
+const PRIVATE_TRANSFER = new Set([
+    "private",
+    "transfer_private",
+    "transferPrivate",
+]);
+const PRIVATE_TO_PUBLIC_TRANSFER = new Set([
+    "private_to_public",
+    "privateToPublic",
+    "transfer_private_to_public",
+    "transferPrivateToPublic",
+]);
+const PUBLIC_TRANSFER = new Set([
+    "public",
+    "transfer_public",
+    "transferPublic",
+]);
+const PUBLIC_TRANSFER_AS_SIGNER = new Set([
+    "public_as_signer",
+    "transfer_public_as_signer",
+    "transferPublicAsSigner",
+]);
+const PUBLIC_TO_PRIVATE_TRANSFER = new Set([
+    "public_to_private",
+    "publicToPrivate",
+    "transfer_public_to_private",
+    "transferPublicToPrivate",
+]);
+
 /**
  * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
  * verifierUri to fetch keys via HTTP from a remote resource as well as a unique cacheKey to store the keys in memory.
@@ -874,7 +791,7 @@ class AleoKeyProvider {
             return new Uint8Array(data);
         }
         catch (error) {
-            throw new Error("Error fetching data." + error);
+            throw new Error("Error fetching data." + error.message);
         }
     }
     constructor() {
@@ -929,7 +846,7 @@ class AleoKeyProvider {
      * Get a set of keys from the cache
      * @param keyId keyId of a proving and verifying key pair
      *
-     * @returns {FunctionKeyPair | Error} Proving and verifying keys for the specified program
+     * @returns {FunctionKeyPair} Proving and verifying keys for the specified program
      */
     getKeys(keyId) {
         console.debug(`Checking if key exists in cache. KeyId: ${keyId}`);
@@ -938,23 +855,23 @@ class AleoKeyProvider {
             return [ProvingKey.fromBytes(provingKeyBytes), VerifyingKey.fromBytes(verifyingKeyBytes)];
         }
         else {
-            return new Error("Key not found in cache.");
+            throw new Error("Key not found in cache.");
         }
     }
     /**
      * Get arbitrary function keys from a provider
      *
      * @param {KeySearchParams} params parameters for the key search in form of: {proverUri: string, verifierUri: string, cacheKey: string}
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified program
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the specified program
      *
      * @example
      * // Create a new object which implements the KeyProvider interface
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
      *
      * // Keys can also be fetched manually using the key provider
@@ -968,9 +885,7 @@ class AleoKeyProvider {
             let cacheKey;
             if ("name" in params && typeof params["name"] == "string") {
                 let key = CREDITS_PROGRAM_KEYS.getKey(params["name"]);
-                if (!(key instanceof Error)) {
-                    return this.fetchCreditsKeys(key);
-                }
+                return this.fetchCreditsKeys(key);
             }
             if ("proverUri" in params && typeof params["proverUri"] == "string") {
                 proverUrl = params["proverUri"];
@@ -988,7 +903,7 @@ class AleoKeyProvider {
                 return this.getKeys(cacheKey);
             }
         }
-        throw Error("Invalid parameters provided, must provide either a cacheKey and/or a proverUrl and a verifierUrl");
+        throw new Error("Invalid parameters provided, must provide either a cacheKey and/or a proverUrl and a verifierUrl");
     }
     /**
      * Returns the proving and verifying keys for a specified program from a specified url.
@@ -997,16 +912,16 @@ class AleoKeyProvider {
      * @param {string} proverUrl Url the verifying key
      * @param {string} cacheKey Key to store the keys in the cache
      *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified program
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the specified program
      *
      * @example
      * // Create a new AleoKeyProvider object
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
      *
      * // Keys can also be fetched manually
@@ -1043,7 +958,7 @@ class AleoKeyProvider {
             }
         }
         catch (error) {
-            throw new Error(`Error: ${error} fetching fee proving and verifying keys from ${proverUrl} and ${verifierUrl}.`);
+            throw new Error(`Error: ${error.message} fetching fee proving and verifying keys from ${proverUrl} and ${verifierUrl}.`);
         }
     }
     /***
@@ -1052,7 +967,7 @@ class AleoKeyProvider {
      * @param proverUrl
      * @param cacheKey
      *
-     * @returns {Promise<ProvingKey | Error>} Proving key for the specified program
+     * @returns {Promise<ProvingKey>} Proving key for the specified program
      */
     async fetchProvingKey(proverUrl, cacheKey) {
         try {
@@ -1077,7 +992,7 @@ class AleoKeyProvider {
             }
         }
         catch (error) {
-            throw new Error(`Error: ${error} fetching fee proving keys from ${proverUrl}`);
+            throw new Error(`Error: ${error.message} fetching fee proving keys from ${proverUrl}`);
         }
     }
     async fetchCreditsKeys(key) {
@@ -1092,882 +1007,153 @@ class AleoKeyProvider {
             }
             else {
                 const keyPair = this.cache.get(key.locator);
-                return [ProvingKey.fromBytes(keyPair[0]), VerifyingKey.fromBytes(keyPair[1])];
-            }
-        }
-        catch (error) {
-            throw new Error(`Error: fetching credits.aleo keys: ${error}`);
-        }
-    }
-    async bondPublicKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_public);
-    }
-    bondValidatorKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_validator);
-    }
-    claimUnbondPublicKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.claim_unbond_public);
-    }
-    /**
-     * Returns the proving and verifying keys for the transfer functions in the credits.aleo program
-     * @param {string} visibility Visibility of the transfer function
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the transfer functions
-     *
-     * @example
-     * // Create a new AleoKeyProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
-     *
-     * // Keys can also be fetched manually
-     * const [transferPublicProvingKey, transferPublicVerifyingKey] = await keyProvider.transferKeys("public");
-     */
-    async transferKeys(visibility) {
-        if (PRIVATE_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private);
-        }
-        else if (PRIVATE_TO_PUBLIC_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private_to_public);
-        }
-        else if (PUBLIC_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public);
-        }
-        else if (PUBLIC_TRANSFER_AS_SIGNER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_as_signer);
-        }
-        else if (PUBLIC_TO_PRIVATE_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_to_private);
-        }
-        else {
-            throw new Error("Invalid visibility type");
-        }
-    }
-    /**
-     * Returns the proving and verifying keys for the join function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
-     */
-    async joinKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.join);
-    }
-    /**
-     * Returns the proving and verifying keys for the split function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the split function
-     * */
-    async splitKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.split);
-    }
-    /**
-     * Returns the proving and verifying keys for the fee_private function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the fee function
-     */
-    async feePrivateKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.fee_private);
-    }
-    /**
-     * Returns the proving and verifying keys for the fee_public function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the fee function
-     */
-    async feePublicKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.fee_public);
-    }
-    /**
-     * Gets a verifying key. If the verifying key is for a credits.aleo function, get it from the wasm cache otherwise
-     *
-     * @returns {Promise<VerifyingKey | Error>} Verifying key for the function
-     */
-    // attempt to fetch it from the network
-    async getVerifyingKey(verifierUri) {
-        switch (verifierUri) {
-            case CREDITS_PROGRAM_KEYS.bond_public.verifier:
-                return CREDITS_PROGRAM_KEYS.bond_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.bond_validator.verifier:
-                return CREDITS_PROGRAM_KEYS.bond_validator.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.claim_unbond_public.verifier:
-                return CREDITS_PROGRAM_KEYS.claim_unbond_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.fee_private.verifier:
-                return CREDITS_PROGRAM_KEYS.fee_private.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.fee_public.verifier:
-                return CREDITS_PROGRAM_KEYS.fee_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.inclusion.verifier:
-                return CREDITS_PROGRAM_KEYS.inclusion.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.join.verifier:
-                return CREDITS_PROGRAM_KEYS.join.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.set_validator_state.verifier:
-                return CREDITS_PROGRAM_KEYS.set_validator_state.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.split.verifier:
-                return CREDITS_PROGRAM_KEYS.split.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_private.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_private.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_private_to_public.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_private_to_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_public.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_public_as_signer.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_public_as_signer.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_public_to_private.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_public_to_private.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.unbond_public.verifier:
-                return CREDITS_PROGRAM_KEYS.unbond_public.verifyingKey();
-            default:
-                try {
-                    /// Try to fetch the verifying key from the network as a string
-                    const response = await get(verifierUri);
-                    const text = await response.text();
-                    return VerifyingKey.fromString(text);
-                }
-                catch (e) {
-                    /// If that fails, try to fetch the verifying key from the network as bytes
-                    try {
-                        return VerifyingKey.fromBytes(await this.fetchBytes(verifierUri));
-                    }
-                    catch (inner) {
-                        return new Error("Invalid verifying key. Error: " + inner);
-                    }
-                }
-        }
-    }
-    unBondPublicKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.unbond_public);
-    }
-}
-
-/**
- * Search parameters for the offline key provider. This class implements the KeySearchParams interface and includes
- * a convenience method for creating a new instance of this class for each function of the credits.aleo program.
- *
- * @example
- * // If storing a key for a custom program function
- * offlineSearchParams = new OfflineSearchParams("myprogram.aleo/myfunction");
- *
- * // If storing a key for a credits.aleo program function
- * bondPublicKeyParams = OfflineSearchParams.bondPublicKeyParams();
- */
-class OfflineSearchParams {
-    cacheKey;
-    verifyCreditsKeys;
-    /**
-     * Create a new OfflineSearchParams instance.
-     *
-     * @param {string} cacheKey - Key used to store the local function proving & verifying keys. This should be stored
-     * under the naming convention "programName/functionName" (i.e. "myprogram.aleo/myfunction")
-     * @param {boolean} verifyCreditsKeys - Whether to verify the keys against the credits.aleo program,
-     * defaults to false, but should be set to true if using keys from the credits.aleo program
-     */
-    constructor(cacheKey, verifyCreditsKeys = false) {
-        this.cacheKey = cacheKey;
-        this.verifyCreditsKeys = verifyCreditsKeys;
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the bond_public function of the credits.aleo program.
-     */
-    static bondPublicKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.bond_public.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the bond_validator function of the credits.aleo program.
-     */
-    static bondValidatorKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.bond_validator.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the claim_unbond_public function of the
-     */
-    static claimUnbondPublicKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.claim_unbond_public.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the fee_private function of the credits.aleo program.
-     */
-    static feePrivateKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.fee_private.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the fee_public function of the credits.aleo program.
-     */
-    static feePublicKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.fee_public.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the inclusion prover function.
-     */
-    static inclusionKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.inclusion.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the join function of the credits.aleo program.
-     */
-    static joinKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.join.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the set_validator_state function of the credits.aleo program.
-     */
-    static setValidatorStateKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.set_validator_state.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the split function of the credits.aleo program.
-     */
-    static splitKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.split.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the transfer_private function of the credits.aleo program.
-     */
-    static transferPrivateKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.transfer_private.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the transfer_private_to_public function of the credits.aleo program.
-     */
-    static transferPrivateToPublicKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.transfer_private_to_public.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the transfer_public function of the credits.aleo program.
-     */
-    static transferPublicKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.transfer_public.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the transfer_public_as_signer function of the credits.aleo program.
-     */
-    static transferPublicAsSignerKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.transfer_public_as_signer.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the transfer_public_to_private function of the credits.aleo program.
-     */
-    static transferPublicToPrivateKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.transfer_public_to_private.locator, true);
-    }
-    /**
-     * Create a new OfflineSearchParams instance for the unbond_public function of the credits.aleo program.
-     */
-    static unbondPublicKeyParams() {
-        return new OfflineSearchParams(CREDITS_PROGRAM_KEYS.unbond_public.locator, true);
-    }
-}
-/**
- * A key provider meant for building transactions offline on devices such as hardware wallets. This key provider is not
- * able to contact the internet for key material and instead relies on the user to insert Aleo function proving &
- * verifying keys from local storage prior to usage.
- *
- * @example
- * // Create an offline program manager
- * const programManager = new ProgramManager();
- *
- * // Create a temporary account for the execution of the program
- * const account = new Account();
- * programManager.setAccount(account);
- *
- * // Create the proving keys from the key bytes on the offline machine
- * console.log("Creating proving keys from local key files");
- * const program = "program hello_hello.aleo; function hello: input r0 as u32.public; input r1 as u32.private; add r0 r1 into r2; output r2 as u32.private;";
- * const myFunctionProver = await getLocalKey("/path/to/my/function/hello_hello.prover");
- * const myFunctionVerifier = await getLocalKey("/path/to/my/function/hello_hello.verifier");
- * const feePublicProvingKeyBytes = await getLocalKey("/path/to/credits.aleo/feePublic.prover");
- *
- * myFunctionProvingKey = ProvingKey.fromBytes(myFunctionProver);
- * myFunctionVerifyingKey = VerifyingKey.fromBytes(myFunctionVerifier);
- * const feePublicProvingKey = ProvingKey.fromBytes(feePublicKeyBytes);
- *
- * // Create an offline key provider
- * console.log("Creating offline key provider");
- * const offlineKeyProvider = new OfflineKeyProvider();
- *
- * // Cache the keys
- * // Cache the proving and verifying keys for the custom hello function
- * OfflineKeyProvider.cacheKeys("hello_hello.aleo/hello", myFunctionProvingKey, myFunctionVerifyingKey);
- *
- * // Cache the proving key for the fee_public function (the verifying key is automatically cached)
- * OfflineKeyProvider.insertFeePublicKey(feePublicProvingKey);
- *
- * // Create an offline query using the latest state root in order to create the inclusion proof
- * const offlineQuery = new OfflineQuery("latestStateRoot");
- *
- * // Insert the key provider into the program manager
- * programManager.setKeyProvider(offlineKeyProvider);
- *
- * // Create the offline search params
- * const offlineSearchParams = new OfflineSearchParams("hello_hello.aleo/hello");
- *
- * // Create the offline transaction
- * const offlineExecuteTx = <Transaction>await this.buildExecutionTransaction("hello_hello.aleo", "hello", 1, false, ["5u32", "5u32"], undefined, offlineSearchParams, undefined, undefined, undefined, undefined, offlineQuery, program);
- *
- * // Broadcast the transaction later on a machine with internet access
- * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
- * const txId = await networkClient.broadcastTransaction(offlineExecuteTx);
- */
-class OfflineKeyProvider {
-    cache;
-    constructor() {
-        this.cache = new Map();
-    }
-    /**
-     * Get bond_public function keys from the credits.aleo program. The keys must be cached prior to calling this
-     * method for it to work.
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the bond_public function
-     */
-    bondPublicKeys() {
-        return this.functionKeys(OfflineSearchParams.bondPublicKeyParams());
-    }
-    ;
-    /**
-     * Get bond_validator function keys from the credits.aleo program. The keys must be cached prior to calling this
-     * method for it to work.
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the bond_public function
-     */
-    bondValidatorKeys() {
-        return this.functionKeys(OfflineSearchParams.bondValidatorKeyParams());
-    }
-    ;
-    /**
-     * Cache a set of keys. This will overwrite any existing keys with the same keyId. The user can check if a keyId
-     * exists in the cache using the containsKeys method prior to calling this method if overwriting is not desired.
-     *
-     * @param {string} keyId access key for the cache
-     * @param {FunctionKeyPair} keys keys to cache
-     */
-    cacheKeys(keyId, keys) {
-        const [provingKey, verifyingKey] = keys;
-        this.cache.set(keyId, [provingKey.toBytes(), verifyingKey.toBytes()]);
-    }
-    ;
-    /**
-     * Get unbond_public function keys from the credits.aleo program. The keys must be cached prior to calling this
-     * method for it to work.
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the unbond_public function
-     */
-    claimUnbondPublicKeys() {
-        return this.functionKeys(OfflineSearchParams.claimUnbondPublicKeyParams());
-    }
-    ;
-    /**
-     * Get arbitrary function key from the offline key provider cache.
-     *
-     * @param {KeySearchParams | undefined} params - Optional search parameters for the key provider
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified program
-     *
-     * @example
-     * /// First cache the keys from local offline resources
-     * const offlineKeyProvider = new OfflineKeyProvider();
-     * const myFunctionVerifyingKey = VerifyingKey.fromString("verifier...");
-     * const myFunctionProvingKeyBytes = await readBinaryFile('./resources/myfunction.prover');
-     * const myFunctionProvingKey = ProvingKey.fromBytes(myFunctionProvingKeyBytes);
-     *
-     * /// Cache the keys for future use with a memorable locator
-     * offlineKeyProvider.cacheKeys("myprogram.aleo/myfunction", [myFunctionProvingKey, myFunctionVerifyingKey]);
-     *
-     * /// When they're needed, retrieve the keys from the cache
-     *
-     * /// First create a search parameter object with the same locator used to cache the keys
-     * const keyParams = new OfflineSearchParams("myprogram.aleo/myfunction");
-     *
-     * /// Then retrieve the keys
-     * const [myFunctionProver, myFunctionVerifier] = await offlineKeyProvider.functionKeys(keyParams);
-     */
-    functionKeys(params) {
-        return new Promise((resolve, reject) => {
-            if (params === undefined) {
-                reject(new Error("No search parameters provided, cannot retrieve keys"));
-            }
-            else {
-                const keyId = params.cacheKey;
-                const verifyCreditsKeys = params.verifyCreditsKeys;
-                if (this.cache.has(keyId)) {
-                    const [provingKeyBytes, verifyingKeyBytes] = this.cache.get(keyId);
-                    const provingKey = ProvingKey.fromBytes(provingKeyBytes);
-                    const verifyingKey = VerifyingKey.fromBytes(verifyingKeyBytes);
-                    if (verifyCreditsKeys) {
-                        const keysMatchExpected = this.verifyCreditsKeys(keyId, provingKey, verifyingKey);
-                        if (!keysMatchExpected) {
-                            reject(new Error(`Cached keys do not match expected keys for ${keyId}`));
-                        }
-                    }
-                    resolve([provingKey, verifyingKey]);
-                }
-                else {
-                    reject(new Error("Keys not found in cache for " + keyId));
-                }
-            }
-        });
-    }
-    ;
-    /**
-     * Determines if the keys for a given credits function match the expected keys.
-     *
-     * @returns {boolean} Whether the keys match the expected keys
-     */
-    verifyCreditsKeys(locator, provingKey, verifyingKey) {
-        switch (locator) {
-            case CREDITS_PROGRAM_KEYS.bond_public.locator:
-                return provingKey.isBondPublicProver() && verifyingKey.isBondPublicVerifier();
-            case CREDITS_PROGRAM_KEYS.claim_unbond_public.locator:
-                return provingKey.isClaimUnbondPublicProver() && verifyingKey.isClaimUnbondPublicVerifier();
-            case CREDITS_PROGRAM_KEYS.fee_private.locator:
-                return provingKey.isFeePrivateProver() && verifyingKey.isFeePrivateVerifier();
-            case CREDITS_PROGRAM_KEYS.fee_public.locator:
-                return provingKey.isFeePublicProver() && verifyingKey.isFeePublicVerifier();
-            case CREDITS_PROGRAM_KEYS.inclusion.locator:
-                return provingKey.isInclusionProver() && verifyingKey.isInclusionVerifier();
-            case CREDITS_PROGRAM_KEYS.join.locator:
-                return provingKey.isJoinProver() && verifyingKey.isJoinVerifier();
-            case CREDITS_PROGRAM_KEYS.set_validator_state.locator:
-                return provingKey.isSetValidatorStateProver() && verifyingKey.isSetValidatorStateVerifier();
-            case CREDITS_PROGRAM_KEYS.split.locator:
-                return provingKey.isSplitProver() && verifyingKey.isSplitVerifier();
-            case CREDITS_PROGRAM_KEYS.transfer_private.locator:
-                return provingKey.isTransferPrivateProver() && verifyingKey.isTransferPrivateVerifier();
-            case CREDITS_PROGRAM_KEYS.transfer_private_to_public.locator:
-                return provingKey.isTransferPrivateToPublicProver() && verifyingKey.isTransferPrivateToPublicVerifier();
-            case CREDITS_PROGRAM_KEYS.transfer_public.locator:
-                return provingKey.isTransferPublicProver() && verifyingKey.isTransferPublicVerifier();
-            case CREDITS_PROGRAM_KEYS.transfer_public_to_private.locator:
-                return provingKey.isTransferPublicToPrivateProver() && verifyingKey.isTransferPublicToPrivateVerifier();
-            case CREDITS_PROGRAM_KEYS.unbond_public.locator:
-                return provingKey.isUnbondPublicProver() && verifyingKey.isUnbondPublicVerifier();
-            default:
-                return false;
-        }
-    }
-    /**
-     * Get fee_private function keys from the credits.aleo program. The keys must be cached prior to calling this
-     * method for it to work.
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
-     */
-    feePrivateKeys() {
-        return this.functionKeys(OfflineSearchParams.feePrivateKeyParams());
-    }
-    ;
-    /**
-     * Get fee_public function keys from the credits.aleo program. The keys must be cached prior to calling this
-     * method for it to work.
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
-     */
-    feePublicKeys() {
-        return this.functionKeys(OfflineSearchParams.feePublicKeyParams());
-    }
-    ;
-    /**
-     * Get join function keys from the credits.aleo program. The keys must be cached prior to calling this
-     * method for it to work.
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
-     */
-    joinKeys() {
-        return this.functionKeys(OfflineSearchParams.joinKeyParams());
-    }
-    ;
-    /**
-     * Get split function keys from the credits.aleo program. The keys must be cached prior to calling this
-     * method for it to work.
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
-     */
-    splitKeys() {
-        return this.functionKeys(OfflineSearchParams.splitKeyParams());
-    }
-    ;
-    /**
-     * Get keys for a variant of the transfer function from the credits.aleo program.
-     *
-     *
-     * @param {string} visibility Visibility of the transfer function (private, public, privateToPublic, publicToPrivate)
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified transfer function
-     *
-     * @example
-     * // Create a new OfflineKeyProvider
-     * const offlineKeyProvider = new OfflineKeyProvider();
-     *
-     * // Cache the keys for future use with the official locator
-     * const transferPublicProvingKeyBytes = await readBinaryFile('./resources/transfer_public.prover.a74565e');
-     * const transferPublicProvingKey = ProvingKey.fromBytes(transferPublicProvingKeyBytes);
-     *
-     * // Cache the transfer_public keys for future use with the OfflinKeyProvider's convenience method for
-     * // transfer_public (the verifying key will be cached automatically)
-     * offlineKeyProvider.insertTransferPublicKeys(transferPublicProvingKey);
-     *
-     * /// When they're needed, retrieve the keys from the cache
-     * const [transferPublicProvingKey, transferPublicVerifyingKey] = await keyProvider.transferKeys("public");
-     */
-    transferKeys(visibility) {
-        if (PRIVATE_TRANSFER.has(visibility)) {
-            return this.functionKeys(OfflineSearchParams.transferPrivateKeyParams());
-        }
-        else if (PRIVATE_TO_PUBLIC_TRANSFER.has(visibility)) {
-            return this.functionKeys(OfflineSearchParams.transferPrivateToPublicKeyParams());
-        }
-        else if (PUBLIC_TRANSFER.has(visibility)) {
-            return this.functionKeys(OfflineSearchParams.transferPublicKeyParams());
-        }
-        else if (PUBLIC_TRANSFER_AS_SIGNER.has(visibility)) {
-            return this.functionKeys(OfflineSearchParams.transferPublicAsSignerKeyParams());
-        }
-        else if (PUBLIC_TO_PRIVATE_TRANSFER.has(visibility)) {
-            return this.functionKeys(OfflineSearchParams.transferPublicToPrivateKeyParams());
-        }
-        else {
-            throw new Error("Invalid visibility type");
-        }
-    }
-    ;
-    /**
-     * Get unbond_public function keys from the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
-     */
-    async unBondPublicKeys() {
-        return this.functionKeys(OfflineSearchParams.unbondPublicKeyParams());
-    }
-    ;
-    /**
-     * Insert the proving and verifying keys for the bond_public function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for bond_public before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertBondPublicKeys(provingKey) {
-        if (provingKey.isBondPublicProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.bond_public.locator, [provingKey.toBytes(), VerifyingKey.bondPublicVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for bond_public");
-        }
-    }
-    /**
-     * Insert the proving and verifying keys for the claim_unbond_public function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for claim_unbond_public before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertClaimUnbondPublicKeys(provingKey) {
-        if (provingKey.isClaimUnbondPublicProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.claim_unbond_public.locator, [provingKey.toBytes(), VerifyingKey.claimUnbondPublicVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for claim_unbond_public");
-        }
-    }
-    /**
-     * Insert the proving and verifying keys for the fee_private function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for fee_private before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertFeePrivateKeys(provingKey) {
-        if (provingKey.isFeePrivateProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.fee_private.locator, [provingKey.toBytes(), VerifyingKey.feePrivateVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for fee_private");
-        }
-    }
-    /**
-     * Insert the proving and verifying keys for the fee_public function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for fee_public before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertFeePublicKeys(provingKey) {
-        if (provingKey.isFeePublicProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.fee_public.locator, [provingKey.toBytes(), VerifyingKey.feePublicVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for fee_public");
-        }
-    }
-    /**
-     * Insert the proving and verifying keys for the join function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for join before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertJoinKeys(provingKey) {
-        if (provingKey.isJoinProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.join.locator, [provingKey.toBytes(), VerifyingKey.joinVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for join");
-        }
-    }
-    /**
-     * Insert the proving and verifying keys for the set_validator_state function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for set_validator_state before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertSetValidatorStateKeys(provingKey) {
-        if (provingKey.isSetValidatorStateProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.set_validator_state.locator, [provingKey.toBytes(), VerifyingKey.setValidatorStateVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for set_validator_state");
-        }
-    }
-    /**
-     * Insert the proving and verifying keys for the split function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for split before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertSplitKeys(provingKey) {
-        if (provingKey.isSplitProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.split.locator, [provingKey.toBytes(), VerifyingKey.splitVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for split");
-        }
-    }
-    /**
-     * Insert the proving and verifying keys for the transfer_private function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for transfer_private before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertTransferPrivateKeys(provingKey) {
-        if (provingKey.isTransferPrivateProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.transfer_private.locator, [provingKey.toBytes(), VerifyingKey.transferPrivateVerifier().toBytes()]);
+                return [ProvingKey.fromBytes(keyPair[0]), VerifyingKey.fromBytes(keyPair[1])];
+            }
         }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for transfer_private");
+        catch (error) {
+            throw new Error(`Error: fetching credits.aleo keys: ${error.message}`);
         }
     }
-    /**
-     * Insert the proving and verifying keys for the transfer_private_to_public function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for transfer_private_to_public before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertTransferPrivateToPublicKeys(provingKey) {
-        if (provingKey.isTransferPrivateToPublicProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.transfer_private_to_public.locator, [provingKey.toBytes(), VerifyingKey.transferPrivateToPublicVerifier().toBytes()]);
-        }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for transfer_private_to_public");
-        }
+    async bondPublicKeys() {
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_public);
+    }
+    bondValidatorKeys() {
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_validator);
+    }
+    claimUnbondPublicKeys() {
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.claim_unbond_public);
     }
     /**
-     * Insert the proving and verifying keys for the transfer_public function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for transfer_public before inserting them into the cache.
+     * Returns the proving and verifying keys for the transfer functions in the credits.aleo program
+     * @param {string} visibility Visibility of the transfer function
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the transfer functions
+     *
+     * @example
+     * // Create a new AleoKeyProvider
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
+     * const keyProvider = new AleoKeyProvider();
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
      *
-     * @param provingKey
+     * // Keys can also be fetched manually
+     * const [transferPublicProvingKey, transferPublicVerifyingKey] = await keyProvider.transferKeys("public");
      */
-    insertTransferPublicKeys(provingKey) {
-        if (provingKey.isTransferPublicProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.transfer_public.locator, [provingKey.toBytes(), VerifyingKey.transferPublicVerifier().toBytes()]);
+    async transferKeys(visibility) {
+        if (PRIVATE_TRANSFER.has(visibility)) {
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private);
         }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for transfer_public");
+        else if (PRIVATE_TO_PUBLIC_TRANSFER.has(visibility)) {
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private_to_public);
         }
-    }
-    /**
-     * Insert the proving and verifying keys for the transfer_public_to_private function into the cache. Only the proving key needs
-     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
-     * that the keys match the expected checksum for transfer_public_to_private before inserting them into the cache.
-     *
-     * @param provingKey
-     */
-    insertTransferPublicToPrivateKeys(provingKey) {
-        if (provingKey.isTransferPublicToPrivateProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.transfer_public_to_private.locator, [provingKey.toBytes(), VerifyingKey.transferPublicToPrivateVerifier().toBytes()]);
+        else if (PUBLIC_TRANSFER.has(visibility)) {
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public);
         }
-        else {
-            throw new Error("Attempted to insert invalid proving keys for transfer_public_to_private");
+        else if (PUBLIC_TRANSFER_AS_SIGNER.has(visibility)) {
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_as_signer);
         }
-    }
-    insertUnbondPublicKeys(provingKey) {
-        if (provingKey.isUnbondPublicProver()) {
-            this.cache.set(CREDITS_PROGRAM_KEYS.unbond_public.locator, [provingKey.toBytes(), VerifyingKey.unbondPublicVerifier().toBytes()]);
+        else if (PUBLIC_TO_PRIVATE_TRANSFER.has(visibility)) {
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_to_private);
         }
         else {
-            throw new Error("Attempted to insert invalid proving keys for unbond_public");
+            throw new Error("Invalid visibility type");
         }
     }
-}
-
-/**
- * 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.
- */
-class NetworkRecordProvider {
-    account;
-    networkClient;
-    constructor(account, networkClient) {
-        this.account = account;
-        this.networkClient = networkClient;
-    }
     /**
-     * Set the account used to search for records
+     * Returns the proving and verifying keys for the join function in the credits.aleo program
      *
-     * @param {Account} account The account to use for searching for records
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
      */
-    setAccount(account) {
-        this.account = account;
+    async joinKeys() {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.join);
     }
     /**
-     * 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 | Error>} The record if found, otherwise an error
-     *
-     * @example
-     * // Create a new NetworkRecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/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.aleo.org/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     * Returns the proving and verifying keys for the split function in the credits.aleo program
      *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the split function
      * */
-    async findCreditsRecords(microcredits, unspent, nonces, searchParameters) {
-        let startHeight = 0;
-        let endHeight = 0;
-        if (searchParameters) {
-            if ("startHeight" in searchParameters && typeof searchParameters["endHeight"] == "number") {
-                startHeight = searchParameters["startHeight"];
-            }
-            if ("endHeight" in searchParameters && typeof searchParameters["endHeight"] == "number") {
-                endHeight = searchParameters["endHeight"];
-            }
-        }
-        // If the end height is not specified, use the current block height
-        if (endHeight == 0) {
-            const end = await this.networkClient.getLatestHeight();
-            if (end instanceof Error) {
-                throw logAndThrow("Unable to get current block height from the network");
-            }
-            endHeight = end;
-        }
-        // If the start height is greater than the end height, throw an error
-        if (startHeight >= endHeight) {
-            throw logAndThrow("Start height must be less than end height");
-        }
-        return await this.networkClient.findUnspentRecords(startHeight, endHeight, this.account.privateKey(), microcredits, undefined, nonces);
+    async splitKeys() {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.split);
     }
     /**
-     * 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 | Error>} The record if found, otherwise an error
-     *
-     * @example
-     * // Create a new NetworkRecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/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()]);
+     * Returns the proving and verifying keys for the fee_private function in the credits.aleo program
      *
-     * // 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.aleo.org/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the fee function
      */
-    async findCreditsRecord(microcredits, unspent, nonces, searchParameters) {
-        const records = await this.findCreditsRecords([microcredits], unspent, nonces, searchParameters);
-        if (!(records instanceof Error) && records.length > 0) {
-            return records[0];
-        }
-        console.error("Record not found with error:", records);
-        return new Error("Record not found");
+    async feePrivateKeys() {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.fee_private);
     }
     /**
-     * Find an arbitrary record. WARNING: This function is not implemented yet and will throw an error.
+     * Returns the proving and verifying keys for the fee_public function in the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the fee function
      */
-    async findRecord(unspent, nonces, searchParameters) {
-        throw new Error("Method not implemented.");
+    async feePublicKeys() {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.fee_public);
     }
     /**
-     * Find multiple arbitrary records. WARNING: This function is not implemented yet and will throw an error.
+     * Gets a verifying key. If the verifying key is for a credits.aleo function, get it from the wasm cache otherwise
+     *
+     * @returns {Promise<VerifyingKey>} Verifying key for the function
      */
-    async findRecords(unspent, nonces, searchParameters) {
-        throw new Error("Method not implemented.");
+    // attempt to fetch it from the network
+    async getVerifyingKey(verifierUri) {
+        switch (verifierUri) {
+            case CREDITS_PROGRAM_KEYS.bond_public.verifier:
+                return CREDITS_PROGRAM_KEYS.bond_public.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.bond_validator.verifier:
+                return CREDITS_PROGRAM_KEYS.bond_validator.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.claim_unbond_public.verifier:
+                return CREDITS_PROGRAM_KEYS.claim_unbond_public.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.fee_private.verifier:
+                return CREDITS_PROGRAM_KEYS.fee_private.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.fee_public.verifier:
+                return CREDITS_PROGRAM_KEYS.fee_public.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.inclusion.verifier:
+                return CREDITS_PROGRAM_KEYS.inclusion.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.join.verifier:
+                return CREDITS_PROGRAM_KEYS.join.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.set_validator_state.verifier:
+                return CREDITS_PROGRAM_KEYS.set_validator_state.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.split.verifier:
+                return CREDITS_PROGRAM_KEYS.split.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.transfer_private.verifier:
+                return CREDITS_PROGRAM_KEYS.transfer_private.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.transfer_private_to_public.verifier:
+                return CREDITS_PROGRAM_KEYS.transfer_private_to_public.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.transfer_public.verifier:
+                return CREDITS_PROGRAM_KEYS.transfer_public.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.transfer_public_as_signer.verifier:
+                return CREDITS_PROGRAM_KEYS.transfer_public_as_signer.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.transfer_public_to_private.verifier:
+                return CREDITS_PROGRAM_KEYS.transfer_public_to_private.verifyingKey();
+            case CREDITS_PROGRAM_KEYS.unbond_public.verifier:
+                return CREDITS_PROGRAM_KEYS.unbond_public.verifyingKey();
+            default:
+                try {
+                    /// Try to fetch the verifying key from the network as a string
+                    const response = await get(verifierUri);
+                    const text = await response.text();
+                    return VerifyingKey.fromString(text);
+                }
+                catch (e) {
+                    /// If that fails, try to fetch the verifying key from the network as bytes
+                    try {
+                        return VerifyingKey.fromBytes(await this.fetchBytes(verifierUri));
+                    }
+                    catch (inner) {
+                        throw new Error("Invalid verifying key. Error: " + inner.message);
+                    }
+                }
+        }
     }
-}
-/**
- * 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.aleo.org/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);
- *
- */
-class BlockHeightSearch {
-    startHeight;
-    endHeight;
-    constructor(startHeight, endHeight) {
-        this.startHeight = startHeight;
-        this.endHeight = endHeight;
+    unBondPublicKeys() {
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.unbond_public);
     }
 }
 
-// Experimental example where SDK manages worker
-let singletonWorker = null;
-const createAleoWorker = () => {
-    if (!singletonWorker) {
-        const worker = new Worker(new URL("worker.js", import.meta.url), {
-            type: "module",
-        });
-        singletonWorker = wrap(worker);
-    }
-    return singletonWorker;
-};
-
 /**
  * The ProgramManager class is used to execute and deploy programs on the Aleo network and create value transfers.
  */
@@ -1984,7 +1170,7 @@ class ProgramManager {
      * @param { RecordProvider | undefined } recordProvider A record provider that implements {@link RecordProvider} interface
      */
     constructor(host, keyProvider, recordProvider) {
-        this.host = host ? host : 'https://api.explorer.aleo.org/v1';
+        this.host = host ? host : 'https://api.explorer.provable.com/v1';
         this.networkClient = new AleoNetworkClient(this.host);
         this.keyProvider = keyProvider ? keyProvider : new AleoKeyProvider();
         this.recordProvider = recordProvider;
@@ -2032,17 +1218,17 @@ class ProgramManager {
      * pay the deployment fee
      * @param {string | RecordPlaintext | undefined} feeRecord Optional Fee record to use for the transaction
      * @param {PrivateKey | undefined} privateKey Optional private key to use for the transaction
-     * @returns {string | Error} The transaction id of the deployed program or a failure message from the network
+     * @returns {string} The transaction id of the deployed program or a failure message from the network
      *
      * @example
      * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for deployments
      * const program = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      *
      * // Define a fee in credits
      * const fee = 1.2;
@@ -2070,7 +1256,7 @@ class ProgramManager {
             }
         }
         catch (e) {
-            throw logAndThrow(`Error validating program: ${e}`);
+            logAndThrow(`Error validating program: ${e.message}`);
         }
         // Get the private key from the account if it is not provided in the parameters
         let deploymentPrivateKey = privateKey;
@@ -2085,7 +1271,7 @@ class ProgramManager {
             feeRecord = privateFee ? await this.getCreditsRecord(fee, [], feeRecord, recordSearchParams) : undefined;
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee record. Record finder response: '${e}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
+            logAndThrow(`Error finding fee record. Record finder response: '${e.message}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
         }
         // Get the proving and verifying keys from the key provider
         let feeKeys;
@@ -2093,7 +1279,7 @@ class ProgramManager {
             feeKeys = privateFee ? await this.keyProvider.feePrivateKeys() : await this.keyProvider.feePublicKeys();
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee keys. Key finder response: '${e}'. Please ensure your key provider is configured correctly.`);
+            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
         }
         const [feeProvingKey, feeVerifyingKey] = feeKeys;
         // Resolve the program imports if they exist
@@ -2102,7 +1288,7 @@ class ProgramManager {
             imports = await this.networkClient.getProgramImports(program);
         }
         catch (e) {
-            throw logAndThrow(`Error finding program imports. Network response: '${e}'. Please ensure you're connected to a valid Aleo network and the program is deployed to the network.`);
+            logAndThrow(`Error finding program imports. Network response: '${e.message}'. Please ensure you're connected to a valid Aleo network and the program is deployed to the network.`);
         }
         // Build a deployment transaction and submit it to the network
         const tx = await ProgramManager$1.buildDeploymentTransaction(deploymentPrivateKey, program, fee, feeRecord, this.host, imports, feeProvingKey, feeVerifyingKey);
@@ -2112,17 +1298,17 @@ class ProgramManager {
      * Builds an execution transaction for submission to the Aleo network.
      *
      * @param {ExecuteOptions} options - The options for the execution transaction.
-     * @returns {Promise<Transaction | Error>} - A promise that resolves to the transaction or an error.
+     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error.
      *
      * @example
      * // Create a new NetworkClient, KeyProvider, and RecordProvider using official Aleo record, key, and network providers
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * keyProvider.useCache = true;
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      *
      * // Build and execute the transaction
      * const transaction = await programManager.buildExecutionTransaction({
@@ -2149,7 +1335,7 @@ class ProgramManager {
                 program = (await this.networkClient.getProgram(programName));
             }
             catch (e) {
-                throw logAndThrow(`Error finding ${programName}. Network response: '${e}'. Please ensure you're connected to a valid Aleo network the program is deployed to the network.`);
+                logAndThrow(`Error finding ${programName}. Network response: '${e.message}'. Please ensure you're connected to a valid Aleo network the program is deployed to the network.`);
             }
         }
         else if (program instanceof Program) {
@@ -2168,7 +1354,7 @@ class ProgramManager {
             feeRecord = privateFee ? await this.getCreditsRecord(fee, [], feeRecord, recordSearchParams) : undefined;
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee record. Record finder response: '${e}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
+            logAndThrow(`Error finding fee record. Record finder response: '${e.message}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
         }
         // Get the fee proving and verifying keys from the key provider
         let feeKeys;
@@ -2176,7 +1362,7 @@ class ProgramManager {
             feeKeys = privateFee ? await this.keyProvider.feePrivateKeys() : await this.keyProvider.feePublicKeys();
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee keys. Key finder response: '${e}'. Please ensure your key provider is configured correctly.`);
+            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
         }
         const [feeProvingKey, feeVerifyingKey] = feeKeys;
         // If the function proving and verifying keys are not provided, attempt to find them using the key provider
@@ -2195,7 +1381,7 @@ class ProgramManager {
                 imports = await this.networkClient.getProgramImports(programName);
             }
             catch (e) {
-                throw logAndThrow(`Error finding program imports. Network response: '${e}'. Please ensure you're connected to a valid Aleo network and the program is deployed to the network.`);
+                logAndThrow(`Error finding program imports. Network response: '${e.message}'. Please ensure you're connected to a valid Aleo network and the program is deployed to the network.`);
             }
         }
         // Build an execution transaction and submit it to the network
@@ -2205,17 +1391,17 @@ class ProgramManager {
      * Builds an execution transaction for submission to the Aleo network.
      *
      * @param {ExecuteOptions} options - The options for the execution transaction.
-     * @returns {Promise<Transaction | Error>} - A promise that resolves to the transaction or an error.
+     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error.
      *
      * @example
      * // Create a new NetworkClient, KeyProvider, and RecordProvider using official Aleo record, key, and network providers
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * keyProvider.useCache = true;
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      *
      * // Build and execute the transaction
      * const transaction = await programManager.execute({
@@ -2247,7 +1433,7 @@ class ProgramManager {
      * @param {VerifyingKey | undefined} verifyingKey Optional verifying key to use for the transaction
      * @param {PrivateKey | undefined} privateKey Optional private key to use for the transaction
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string | Error>}
+     * @returns {Promise<string>}
      *
      * @example
      * import { Account, Program } from '@provablehq/sdk';
@@ -2301,7 +1487,7 @@ class ProgramManager {
      * @param {RecordPlaintext | string | undefined} feeRecord Fee record to use for the join transaction
      * @param {PrivateKey | undefined} privateKey Private key to use for the join transaction
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string | Error>}
+     * @returns {Promise<string>}
      */
     async join(recordOne, recordTwo, fee, privateFee, recordSearchParams, feeRecord, privateKey, offlineQuery) {
         // Get the private key from the account if it is not provided in the parameters
@@ -2320,7 +1506,7 @@ class ProgramManager {
             joinKeys = await this.keyProvider.joinKeys();
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee keys. Key finder response: '${e}'. Please ensure your key provider is configured correctly.`);
+            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
         }
         const [feeProvingKey, feeVerifyingKey] = feeKeys;
         const [joinProvingKey, joinVerifyingKey] = joinKeys;
@@ -2329,7 +1515,7 @@ class ProgramManager {
             feeRecord = privateFee ? await this.getCreditsRecord(fee, [], feeRecord, recordSearchParams) : undefined;
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee record. Record finder response: '${e}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
+            logAndThrow(`Error finding fee record. Record finder response: '${e.message}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
         }
         // Validate the records provided are valid plaintext records
         try {
@@ -2337,7 +1523,7 @@ class ProgramManager {
             recordTwo = recordTwo instanceof RecordPlaintext ? recordTwo : RecordPlaintext.fromString(recordTwo);
         }
         catch (e) {
-            throw logAndThrow('Records provided are not valid. Please ensure they are valid plaintext records.');
+            logAndThrow('Records provided are not valid. Please ensure they are valid plaintext records.');
         }
         // Build an execution transaction and submit it to the network
         const tx = await ProgramManager$1.buildJoinTransaction(executionPrivateKey, recordOne, recordTwo, fee, feeRecord, this.host, joinProvingKey, joinVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
@@ -2350,17 +1536,17 @@ class ProgramManager {
      * @param {RecordPlaintext | string} amountRecord Amount record to use for the split transaction
      * @param {PrivateKey | undefined} privateKey Optional private key to use for the split transaction
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string | Error>}
+     * @returns {Promise<string>}
      *
      * @example
      * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for executions
      * const programName = "hello_hello.aleo";
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      * const record = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 4106205762862305308495708971985748592380064201230396559307556388725936304984group.public}"
      * const tx_id = await programManager.split(25000000, record);
      * const transaction = await programManager.networkClient.getTransaction(tx_id);
@@ -2380,7 +1566,7 @@ class ProgramManager {
             splitKeys = await this.keyProvider.splitKeys();
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee keys. Key finder response: '${e}'. Please ensure your key provider is configured correctly.`);
+            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
         }
         const [splitProvingKey, splitVerifyingKey] = splitKeys;
         // Validate the record to be split
@@ -2388,7 +1574,7 @@ class ProgramManager {
             amountRecord = amountRecord instanceof RecordPlaintext ? amountRecord : RecordPlaintext.fromString(amountRecord);
         }
         catch (e) {
-            throw logAndThrow("Record provided is not valid. Please ensure it is a valid plaintext record.");
+            logAndThrow("Record provided is not valid. Please ensure it is a valid plaintext record.");
         }
         // Build an execution transaction and submit it to the network
         const tx = await ProgramManager$1.buildSplitTransaction(executionPrivateKey, splitAmount, amountRecord, this.host, splitProvingKey, splitVerifyingKey, offlineQuery);
@@ -2402,7 +1588,7 @@ class ProgramManager {
      * @param inputs {Array<string>}  Sample inputs to the function
      * @param privateKey {PrivateKey | undefined} Optional private key to use for the key synthesis
      *
-     * @returns {Promise<FunctionKeyPair | Error>}
+     * @returns {Promise<FunctionKeyPair>}
      */
     async synthesizeKeys(program, function_id, inputs, privateKey) {
         // Resolve the program imports if they exist
@@ -2423,7 +1609,7 @@ class ProgramManager {
             return [keyPair.provingKey(), keyPair.verifyingKey()];
         }
         catch (e) {
-            throw logAndThrow(`Could not synthesize keys - error ${e}. Please ensure the program is valid and the inputs are correct.`);
+            logAndThrow(`Could not synthesize keys - error ${e.message}. Please ensure the program is valid and the inputs are correct.`);
         }
     }
     /**
@@ -2440,17 +1626,17 @@ class ProgramManager {
      * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
      * @param {PrivateKey | undefined} privateKey Optional private key to use for the transfer transaction
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string | Error>} The transaction id of the transfer transaction
+     * @returns {Promise<string>} The transaction id of the transfer transaction
      *
      * @example
      * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for executions
      * const programName = "hello_hello.aleo";
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      * await programManager.initialize();
      * const tx_id = await programManager.transfer(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "private", 0.2)
      * const transaction = await programManager.networkClient.getTransaction(tx_id);
@@ -2474,7 +1660,7 @@ class ProgramManager {
             transferKeys = await this.keyProvider.transferKeys(transferType);
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee keys. Key finder response: '${e}'. Please ensure your key provider is configured correctly.`);
+            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
         }
         const [feeProvingKey, feeVerifyingKey] = feeKeys;
         const [transferProvingKey, transferVerifyingKey] = transferKeys;
@@ -2493,7 +1679,7 @@ class ProgramManager {
             feeRecord = privateFee ? await this.getCreditsRecord(fee, nonces, feeRecord, recordSearchParams) : undefined;
         }
         catch (e) {
-            throw logAndThrow(`Error finding fee record. Record finder response: '${e}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
+            logAndThrow(`Error finding fee record. Record finder response: '${e.message}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
         }
         // Build an execution transaction and submit it to the network
         return await ProgramManager$1.buildTransferTransaction(executionPrivateKey, amount, recipient, transferType, amountRecord, fee, feeRecord, this.host, transferProvingKey, transferVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
@@ -2512,7 +1698,7 @@ class ProgramManager {
      * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
      * @param {PrivateKey | undefined} privateKey Optional private key to use for the transfer transaction
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string | Error>} The transaction id of the transfer transaction
+     * @returns {Promise<string>} The transaction id of the transfer transaction
      */
     async buildTransferPublicTransaction(amount, recipient, fee, privateKey, offlineQuery) {
         return this.buildTransferTransaction(amount, recipient, "public", fee, false, undefined, undefined, undefined, privateKey, offlineQuery);
@@ -2531,7 +1717,7 @@ class ProgramManager {
      * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
      * @param {PrivateKey | undefined} privateKey Optional private key to use for the transfer transaction
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string | Error>} The transaction id of the transfer transaction
+     * @returns {Promise<string>} The transaction id of the transfer transaction
      */
     async buildTransferPublicAsSignerTransaction(amount, recipient, fee, privateKey, offlineQuery) {
         return this.buildTransferTransaction(amount, recipient, "public", fee, false, undefined, undefined, undefined, privateKey, offlineQuery);
@@ -2550,16 +1736,16 @@ class ProgramManager {
      * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
      * @param {PrivateKey | undefined} privateKey Optional private key to use for the transfer transaction
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string | Error>} The transaction id of the transfer transaction
+     * @returns {Promise<string>} The transaction id of the transfer transaction
      *
      * @example
      * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
      * const keyProvider = new AleoKeyProvider();
      * const recordProvider = new NetworkRecordProvider(account, networkClient);
      *
      * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      * await programManager.initialize();
      * const tx_id = await programManager.transfer(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "private", 0.2)
      * const transaction = await programManager.networkClient.getTransaction(tx_id);
@@ -2577,7 +1763,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("YourPrivateKey"));
      *
      * // Create the bonding transaction object for later submission
@@ -2625,7 +1811,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("YourPrivateKey"));
      *
      * // Create the bonding transaction
@@ -2655,7 +1841,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("YourPrivateKey"));
      *
      * // Create the bond validator transaction object for later use.
@@ -2704,7 +1890,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("YourPrivateKey"));
      *
      * // Create the bonding transaction
@@ -2731,7 +1917,7 @@ class ProgramManager {
      * @param {string} staker_address - The address of the staker who is unbonding the credits.
      * @param {number} amount - The amount of credits to unbond (scaled by 1,000,000).
      * @param {Partial<ExecuteOptions>} options - Override default execution options.
-     * @returns {Promise<Transaction | Error>} - A promise that resolves to the transaction or an error message.
+     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error message.
      *
      * @example
      * // Create a keyProvider to handle key management.
@@ -2739,7 +1925,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to unbond credits.
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * const tx = await programManager.buildUnbondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", 2000000);
      * console.log(tx);
      *
@@ -2773,7 +1959,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("YourPrivateKey"));
      *
      * // Create the bonding transaction and send it to the network
@@ -2798,7 +1984,7 @@ class ProgramManager {
      *
      * @param {string} staker_address - The address of the staker who is claiming the credits.
      * @param {Partial<ExecuteOptions>} options - Override default execution options.
-     * @returns {Promise<Transaction | Error>} - A promise that resolves to the transaction or an error message.
+     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error message.
      *
      * @example
      * // Create a keyProvider to handle key management
@@ -2806,7 +1992,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to claim unbonded credits.
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      *
      * // Create the claim unbonded transaction object for later use.
      * const tx = await programManager.buildClaimUnbondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j");
@@ -2842,7 +2028,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("YourPrivateKey"));
      *
      * // Create the bonding transaction
@@ -2873,7 +2059,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("ValidatorPrivateKey"));
      *
      * // Create the bonding transaction
@@ -2920,7 +2106,7 @@ class ProgramManager {
      * keyProvider.useCache = true;
      *
      * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, undefined);
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
      * programManager.setAccount(new Account("ValidatorPrivateKey"));
      *
      * // Create the bonding transaction
@@ -2957,7 +2143,7 @@ class ProgramManager {
      * Create a program object from a program's source code
      *
      * @param {string} program Program source code
-     * @returns {Program | Error} The program object
+     * @returns {Program} The program object
      */
     createProgramFromSource(program) {
         return Program.fromString(program);
@@ -2995,7 +2181,7 @@ class ProgramManager {
                 return (await recordProvider.findCreditsRecord(amount, true, nonces, params));
             }
             catch (e) {
-                throw logAndThrow(`Error finding fee record. Record finder response: '${e}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
+                logAndThrow(`Error finding fee record. Record finder response: '${e.message}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
             }
         }
     }
@@ -3010,107 +2196,5 @@ function validateTransferType(transferType) {
         logAndThrow(`Invalid transfer type '${transferType}'. Valid transfer types are 'private', 'privateToPublic', 'public', and 'publicToPrivate'.`);
 }
 
-const KEY_STORE = Metadata.baseUrl();
-function convert(metadata) {
-    // This looks up the method name in VerifyingKey
-    const verifyingKey = VerifyingKey[metadata.verifyingKey];
-    if (!verifyingKey) {
-        throw new Error("Invalid method name: " + metadata.verifyingKey);
-    }
-    return {
-        name: metadata.name,
-        locator: metadata.locator,
-        prover: metadata.prover,
-        verifier: metadata.verifier,
-        verifyingKey,
-    };
-}
-const CREDITS_PROGRAM_KEYS = {
-    bond_public: convert(Metadata.bond_public()),
-    bond_validator: convert(Metadata.bond_validator()),
-    claim_unbond_public: convert(Metadata.claim_unbond_public()),
-    fee_private: convert(Metadata.fee_private()),
-    fee_public: convert(Metadata.fee_public()),
-    inclusion: convert(Metadata.inclusion()),
-    join: convert(Metadata.join()),
-    set_validator_state: convert(Metadata.set_validator_state()),
-    split: convert(Metadata.split()),
-    transfer_private: convert(Metadata.transfer_private()),
-    transfer_private_to_public: convert(Metadata.transfer_private_to_public()),
-    transfer_public: convert(Metadata.transfer_public()),
-    transfer_public_as_signer: convert(Metadata.transfer_public_as_signer()),
-    transfer_public_to_private: convert(Metadata.transfer_public_to_private()),
-    unbond_public: convert(Metadata.unbond_public()),
-    getKey: function (key) {
-        if (this.hasOwnProperty(key)) {
-            return this[key];
-        }
-        else {
-            return new Error(`Key "${key}" not found.`);
-        }
-    }
-};
-const PRIVATE_TRANSFER_TYPES = new Set([
-    "transfer_private",
-    "private",
-    "transferPrivate",
-    "transfer_private_to_public",
-    "privateToPublic",
-    "transferPrivateToPublic",
-]);
-const VALID_TRANSFER_TYPES = new Set([
-    "transfer_private",
-    "private",
-    "transferPrivate",
-    "transfer_private_to_public",
-    "privateToPublic",
-    "transferPrivateToPublic",
-    "transfer_public",
-    "transfer_public_as_signer",
-    "public",
-    "public_as_signer",
-    "transferPublic",
-    "transferPublicAsSigner",
-    "transfer_public_to_private",
-    "publicToPrivate",
-    "publicAsSigner",
-    "transferPublicToPrivate",
-]);
-const PRIVATE_TRANSFER = new Set([
-    "private",
-    "transfer_private",
-    "transferPrivate",
-]);
-const PRIVATE_TO_PUBLIC_TRANSFER = new Set([
-    "private_to_public",
-    "privateToPublic",
-    "transfer_private_to_public",
-    "transferPrivateToPublic",
-]);
-const PUBLIC_TRANSFER = new Set([
-    "public",
-    "transfer_public",
-    "transferPublic",
-]);
-const PUBLIC_TRANSFER_AS_SIGNER = new Set([
-    "public_as_signer",
-    "transfer_public_as_signer",
-    "transferPublicAsSigner",
-]);
-const PUBLIC_TO_PRIVATE_TRANSFER = new Set([
-    "public_to_private",
-    "publicToPrivate",
-    "transfer_public_to_private",
-    "transferPublicToPrivate",
-]);
-function logAndThrow(message) {
-    console.error(message);
-    throw message;
-}
-// @TODO: This function is no longer needed, remove it.
-async function initializeWasm() {
-    console.warn("initializeWasm is deprecated, you no longer need to use it");
-}
-
-export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoNetworkClient, BlockHeightSearch, CREDITS_PROGRAM_KEYS, KEY_STORE, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TO_PRIVATE_TRANSFER, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, ProgramManager, VALID_TRANSFER_TYPES, createAleoWorker, initializeWasm, logAndThrow };
-//# sourceMappingURL=index.js.map
+export { AleoKeyProvider as A, CREDITS_PROGRAM_KEYS as C, KEY_STORE as K, ProgramManager as P, VALID_TRANSFER_TYPES as V, AleoKeyProviderParams as a, AleoNetworkClient as b, PRIVATE_TRANSFER as c, PRIVATE_TO_PUBLIC_TRANSFER as d, PRIVATE_TRANSFER_TYPES as e, PUBLIC_TRANSFER as f, PUBLIC_TRANSFER_AS_SIGNER as g, PUBLIC_TO_PRIVATE_TRANSFER as h, logAndThrow as l };
+//# sourceMappingURL=program-manager-97ade0e6.js.map