@provablehq/sdk 0.8.7 → 0.9.0

package/dist/mainnet/{program-manager-D0WpABBc.js → program-manager-C1m8QHkg.js}

@@ -1,4 +1,4 @@
-import { PrivateKey, RecordCiphertext, Program, Plaintext, Transaction, Metadata, VerifyingKey, ProvingKey, ProgramManager as ProgramManager$1, RecordPlaintext, verifyFunctionExecution } from '@provablehq/wasm/mainnet.js';
+import { PrivateKey, RecordCiphertext, Program, Plaintext, Address, Transaction, Metadata, VerifyingKey, ProvingKey, ProgramManager as ProgramManager$1, RecordPlaintext, verifyFunctionExecution } from '@provablehq/wasm/mainnet.js';
 
 function logAndThrow(message) {
     console.error(message);
@@ -30,6 +30,37 @@ async function post(url, options) {
     }
     return response;
 }
+async function retryWithBackoff(fn, { maxAttempts = 5, baseDelay = 100, jitter, retryOnStatus = [], shouldRetry, } = {}) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            const isLast = attempt === maxAttempts;
+            const error = err;
+            let retryable = false;
+            if (typeof error.status === "number") {
+                if (error.status >= 500) {
+                    retryable = true;
+                }
+                else if (error.status >= 400 && shouldRetry) {
+                    retryable = shouldRetry(error);
+                }
+            }
+            else if (shouldRetry) {
+                retryable = shouldRetry(error);
+            }
+            if (!retryable || isLast)
+                throw error;
+            const jitterAmount = jitter ?? baseDelay;
+            const actualJitter = Math.floor(Math.random() * jitterAmount);
+            const delay = baseDelay * 2 ** (attempt - 1) + actualJitter;
+            console.warn(`Retry ${attempt}/${maxAttempts} failed. Retrying in ${delay}ms...`);
+            await new Promise((res) => setTimeout(res, delay));
+        }
+    }
+    throw new Error("retryWithBackoff: unreachable");
+}
 
 /**
  * Client library that encapsulates REST calls to publicly exposed endpoints of Aleo nodes. The methods provided in this
@@ -37,34 +68,39 @@ async function post(url, options) {
  *
  * @param {string} host
  * @example
- * // Connection to a local node
- * const localNetworkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined, account);
+ * // Connection to a local node.
+ * const localNetworkClient = new AleoNetworkClient("http://0.0.0.0:3030", undefined, account);
  *
  * // Connection to a public beacon node
  * const account = Account.fromCiphertext(process.env.ciphertext, process.env.password);
- * const publicnetworkClient = new AleoNetworkClient("http://localhost:3030", undefined, account);
+ * const publicNetworkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined, account);
  */
 class AleoNetworkClient {
     host;
     headers;
     account;
+    network;
     constructor(host, options) {
         this.host = host + "/mainnet";
+        this.network = "mainnet";
         if (options && options.headers) {
             this.headers = options.headers;
         }
         else {
             this.headers = {
                 // This is replaced by the actual version by a Rollup plugin
-                "X-Aleo-SDK-Version": "0.8.7",
+                "X-Aleo-SDK-Version": "0.9.0",
             };
         }
     }
     /**
      * Set an account to use in networkClient calls
      *
-     * @param {Account} account
+     * @param {Account} account Set an account to use for record scanning functions.
      * @example
+     * import { Account, AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1");
      * const account = new Account();
      * networkClient.setAccount(account);
      */
@@ -85,18 +121,63 @@ class AleoNetworkClient {
      *
      * @param {string} host The address of a node hosting the Aleo API
      * @param host
+     *
+     * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a networkClient that connects to a local node.
+     * const networkClient = new AleoNetworkClient("http://0.0.0.0:3030", undefined);
+     *
+     * // Set the host to a public node.
+     * networkClient.setHost("http://api.explorer.provable.com/v1");
      */
     setHost(host) {
         this.host = host + "/mainnet";
     }
+    /**
+     * Set a header in the `AleoNetworkClient`s header map
+     *
+     * @param {string} headerName The name of the header to set
+     * @param {string} value The header value
+     *
+     * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a networkClient
+     * const networkClient = new AleoNetworkClient();
+     *
+     * // Set the value of the `Accept-Language` header to `en-US`
+     * networkClient.setHeader('Accept-Language', 'en-US');
+     */
+    setHeader(headerName, value) {
+        this.headers[headerName] = value;
+    }
+    /**
+     * Remove a header from the `AleoNetworkClient`s header map
+     *
+     * @param {string} headerName The name of the header to be removed
+     *
+     * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a networkClient
+     * const networkClient = new AleoNetworkClient();
+     *
+     * // Remove the default `X-Aleo-SDK-Version` header
+     * networkClient.removeHeader('X-Aleo-SDK-Version');
+     */
+    removeHeader(headerName) {
+        delete this.headers[headerName];
+    }
     /**
      * Fetches data from the Aleo network and returns it as a JSON object.
      *
-     * @param url
+     * @param url The URL to fetch data from.
      */
     async fetchData(url = "/") {
         try {
-            return parseJSON(await this.fetchRaw(url));
+            const raw = await this.fetchRaw(url);
+            return parseJSON(raw);
         }
         catch (error) {
             throw new Error(`Error fetching data: ${error}`);
@@ -112,15 +193,27 @@ class AleoNetworkClient {
      */
     async fetchRaw(url = "/") {
         try {
-            const response = await get(this.host + url, {
-                headers: this.headers
+            return await retryWithBackoff(async () => {
+                const response = await get(this.host + url, {
+                    headers: this.headers,
+                });
+                return await response.text();
             });
-            return await response.text();
         }
         catch (error) {
             throw new Error(`Error fetching data: ${error}`);
         }
     }
+    /**
+     * Wrapper around the POST helper to allow mocking in tests. Not meant for use in production.
+     *
+     * @param url The URL to POST to.
+     * @param options The RequestInit options for the POST request.
+     * @returns The Response object from the POST request.
+     */
+    async _sendPost(url, options) {
+        return post(url, options);
+    }
     /**
      * Attempt to find records in the Aleo blockchain.
      *
@@ -132,8 +225,18 @@ class AleoNetworkClient {
      * @param {number} maxMicrocredits - The maximum number of microcredits to search for
      * @param {string[]} nonces - The nonces of already found records to exclude from the search
      * @param {string | PrivateKey} privateKey - An optional private key to use to find unspent records.
+     * @returns {Promise<Array<RecordPlaintext>>} An array of records belonging to the account configured in the network client.
      *
      * @example
+     * import { Account, AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Import an account from a ciphertext and password.
+     * const account = Account.fromCiphertext(process.env.ciphertext, process.env.password);
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * networkClient.setAccount(account);
+     *
      * // Find specific amounts
      * const startHeight = 500000;
      * const amounts = [600000, 1000000];
@@ -168,7 +271,10 @@ class AleoNetworkClient {
         }
         else {
             try {
-                resolvedPrivateKey = privateKey instanceof PrivateKey ? privateKey : PrivateKey.from_string(privateKey);
+                resolvedPrivateKey =
+                    privateKey instanceof PrivateKey
+                        ? privateKey
+                        : PrivateKey.from_string(privateKey);
             }
             catch (error) {
                 throw new Error("Error parsing private key provided.");
@@ -219,8 +325,12 @@ class AleoNetworkClient {
                             // 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++) {
+                                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 the specified programs.
                                         if (!(typeof programs === "undefined")) {
@@ -228,7 +338,8 @@ class AleoNetworkClient {
                                                 continue;
                                             }
                                         }
-                                        if (!(typeof transition.outputs == "undefined")) {
+                                        if (!(typeof transition.outputs ==
+                                            "undefined")) {
                                             for (let l = 0; l < transition.outputs.length; l++) {
                                                 const output = transition.outputs[l];
                                                 if (output.type === "record") {
@@ -249,7 +360,7 @@ class AleoNetworkClient {
                                                                 const serialNumber = recordPlaintext.serialNumberString(resolvedPrivateKey, "credits.aleo", "credits");
                                                                 // Attempt to see if the serial number is spent
                                                                 try {
-                                                                    await this.getTransitionId(serialNumber);
+                                                                    await retryWithBackoff(() => this.getTransitionId(serialNumber));
                                                                     continue;
                                                                 }
                                                                 catch (error) {
@@ -260,37 +371,47 @@ class AleoNetworkClient {
                                                             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();
+                                                                if (typeof maxMicrocredits ===
+                                                                    "number") {
+                                                                    totalRecordValue +=
+                                                                        recordPlaintext.microcredits();
                                                                     // Exit if the search has found the amount specified
-                                                                    if (totalRecordValue >= BigInt(maxMicrocredits)) {
+                                                                    if (totalRecordValue >=
+                                                                        BigInt(maxMicrocredits)) {
                                                                         return records;
                                                                     }
                                                                 }
                                                             }
                                                             // If the user specified a list of amounts, check if the search has found them
-                                                            if (!(typeof amounts === "undefined") && amounts.length > 0) {
+                                                            if (!(typeof amounts ===
+                                                                "undefined") &&
+                                                                amounts.length >
+                                                                    0) {
                                                                 let amounts_found = 0;
-                                                                if (recordPlaintext.microcredits() > amounts[amounts_found]) {
+                                                                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();
+                                                                    if (typeof maxMicrocredits ===
+                                                                        "number") {
+                                                                        totalRecordValue +=
+                                                                            recordPlaintext.microcredits();
                                                                         // Exit if the search has found the amount specified
-                                                                        if (totalRecordValue >= BigInt(maxMicrocredits)) {
+                                                                        if (totalRecordValue >=
+                                                                            BigInt(maxMicrocredits)) {
                                                                             return records;
                                                                         }
                                                                     }
-                                                                    if (records.length >= amounts.length) {
+                                                                    if (records.length >=
+                                                                        amounts.length) {
                                                                         return records;
                                                                     }
                                                                 }
                                                             }
                                                         }
                                                     }
-                                                    catch (error) {
-                                                    }
+                                                    catch (error) { }
                                                 }
                                             }
                                         }
@@ -303,7 +424,10 @@ class AleoNetworkClient {
             }
             catch (error) {
                 // If there is an error fetching blocks, log it and keep searching
-                console.warn("Error fetching blocks in range: " + start.toString() + "-" + end.toString());
+                console.warn("Error fetching blocks in range: " +
+                    start.toString() +
+                    "-" +
+                    end.toString());
                 console.warn("Error: ", error);
                 failures += 1;
                 if (failures > 10) {
@@ -324,8 +448,17 @@ class AleoNetworkClient {
      * @param {number} maxMicrocredits - The maximum number of microcredits to search for
      * @param {string[]} nonces - The nonces of already found records to exclude from the search
      * @param {string | PrivateKey} privateKey - An optional private key to use to find unspent records.
+     * @returns {Promise<Array<RecordPlaintext>>} An array of unspent records belonging to the account configured in the network client.
      *
      * @example
+     * import { Account, AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * const account = Account.fromCiphertext(process.env.ciphertext, process.env.password);
+     *
+     * // Create a network client and set an account to search for records with.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * networkClient.setAccount(account);
+     *
      * // Find specific amounts
      * const startHeight = 500000;
      * const endHeight = 550000;
@@ -342,7 +475,9 @@ class AleoNetworkClient {
     /**
      * Returns the contents of the block at the specified block height.
      *
-     * @param {number} blockHeight
+     * @param {number} blockHeight - The height of the block to fetch
+     * @returns {Promise<BlockJSON>} A javascript object containing the block at the specified height
+     *
      * @example
      * const block = networkClient.getBlock(1234);
      */
@@ -358,8 +493,13 @@ class AleoNetworkClient {
     /**
      * Returns the contents of the block with the specified hash.
      *
-     * @param {string} blockHash
+     * @param {string} blockHash The hash of the block to fetch.
+     * @returns {Promise<BlockJSON>} A javascript object representation of the block matching the hash.
+     *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
      * const block = networkClient.getBlockByHash("ab19dklwl9vp63zu3hwg57wyhvmqf92fx5g8x0t6dr72py8r87pxupqfne5t9");
      */
     async getBlockByHash(blockHash) {
@@ -372,12 +512,24 @@ class AleoNetworkClient {
         }
     }
     /**
-     * Returns a range of blocks between the specified block heights.
+     * Returns a range of blocks between the specified block heights. A maximum of 50 blocks can be fetched at a time.
+     *
+     * @param {number} start Starting block to fetch.
+     * @param {number} end Ending block to fetch. This cannot be more than 50 blocks ahead of the start block.
+     * @returns {Promise<Array<BlockJSON>>} An array of block objects
      *
-     * @param {number} start
-     * @param {number} end
      * @example
-     * const blockRange = networkClient.getBlockRange(2050, 2100);
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Fetch 50 blocks.
+     * const (start, end) = (2050, 2100);
+     * const blockRange = networkClient.getBlockRange(start, end);
+     *
+     * let cursor = start;
+     * blockRange.forEach((block) => {
+     *   assert(block.height == cursor);
+     *   cursor += 1;
+     *  }
      */
     async getBlockRange(start, end) {
         try {
@@ -390,8 +542,21 @@ class AleoNetworkClient {
     /**
      * Returns the deployment transaction id associated with the specified program.
      *
-     * @param {Program | string} program
-     * @returns {TransactionJSON}
+     * @param {Program | string} program The name of the deployed program OR a wasm Program object.
+     * @returns {Promise<string>} The transaction ID of the deployment transaction.
+     *
+     * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/testnet.js";
+     *
+     * // Get the transaction ID of the deployment transaction for a program.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * const transactionId = networkClient.getDeploymentTransactionIDForProgram("hello_hello.aleo");
+     *
+     * // Get the transaction data for the deployment transaction.
+     * const transaction = networkClient.getTransactionObject(transactionId);
+     *
+     * // Get the verifying keys for the functions in the deployed program.
+     * const verifyingKeys = transaction.verifyingKeys();
      */
     async getDeploymentTransactionIDForProgram(program) {
         if (program instanceof Program) {
@@ -399,24 +564,35 @@ class AleoNetworkClient {
         }
         try {
             const id = await this.fetchData("/find/transactionID/deployment/" + program);
-            return id.replace("\"", "");
+            return id.replace('"', "");
         }
         catch (error) {
             throw new Error(`Error fetching deployment transaction for program ${program}: ${error}`);
         }
     }
     /**
-     * Returns the deployment transaction associated with a specified program.
+     * Returns the deployment transaction associated with a specified program as a JSON object.
+     *
+     * @param {Program | string} program The name of the deployed program OR a wasm Program object.
+     * @returns {Promise<Transaction>} JSON representation of the deployment transaction.
+     *
+     * @example
+     * import { AleoNetworkClient, DeploymentJSON } from "@provablehq/sdk/testnet.js";
+     *
+     * // Get the transaction ID of the deployment transaction for a program.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * const transaction = networkClient.getDeploymentTransactionForProgram("hello_hello.aleo");
      *
-     * @param {Program | string} program
-     * @returns {TransactionJSON}
+     * // Get the verifying keys for each function in the deployment.
+     * const deployment = <DeploymentJSON>transaction.deployment;
+     * const verifyingKeys = deployment.verifying_keys;
      */
     async getDeploymentTransactionForProgram(program) {
         if (program instanceof Program) {
             program = program.id();
         }
         try {
-            const transaction_id = await this.getDeploymentTransactionIDForProgram(program);
+            const transaction_id = (await this.getDeploymentTransactionIDForProgram(program));
             return await this.getTransaction(transaction_id);
         }
         catch (error) {
@@ -426,12 +602,25 @@ class AleoNetworkClient {
     /**
      * Returns the deployment transaction associated with a specified program as a wasm object.
      *
-     * @param {Program | string} program
-     * @returns {TransactionJSON}
+     * @param {Program | string} program The name of the deployed program OR a wasm Program object.
+     * @returns {Promise<Transaction>} Wasm object representation of the deployment transaction.
+     *
+     * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/testnet.js";
+     *
+     * // Get the transaction ID of the deployment transaction for a program.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * const transactionId = networkClient.getDeploymentTransactionIDForProgram("hello_hello.aleo");
+     *
+     * // Get the transaction data for the deployment transaction.
+     * const transaction = networkClient.getDeploymentTransactionObjectForProgram(transactionId);
+     *
+     * // Get the verifying keys for the functions in the deployed program.
+     * const verifyingKeys = transaction.verifyingKeys();
      */
     async getDeploymentTransactionObjectForProgram(program) {
         try {
-            const transaction_id = await this.getDeploymentTransactionIDForProgram(program);
+            const transaction_id = (await this.getDeploymentTransactionIDForProgram(program));
             return await this.getTransactionObject(transaction_id);
         }
         catch (error) {
@@ -439,14 +628,21 @@ class AleoNetworkClient {
         }
     }
     /**
-     * Returns the contents of the latest block.
+     * Returns the contents of the latest block as JSON.
+     *
+     * @returns {Promise<BlockJSON>} A javascript object containing the latest block
      *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/testnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const latestHeight = networkClient.getLatestBlock();
      */
     async getLatestBlock() {
         try {
-            return await this.fetchData("/block/latest");
+            return (await this.fetchData("/block/latest"));
         }
         catch (error) {
             throw new Error(`Error fetching latest block: ${error}`);
@@ -456,6 +652,16 @@ class AleoNetworkClient {
      * Returns the latest committee.
      *
      * @returns {Promise<object>} A javascript object containing the latest committee
+     *
+     * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * // Create a network client and get the latest committee.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * const latestCommittee = await networkClient.getLatestCommittee();
      */
     async getLatestCommittee() {
         try {
@@ -466,14 +672,20 @@ class AleoNetworkClient {
         }
     }
     /**
-     * Returns the committe at the specified block height.
-     *
-     * @param {number} blockHeight
+     * Returns the committee at the specified block height.
      *
+     * @param {number} blockHeight - The height of the block to fetch the committee for
      * @returns {Promise<object>} A javascript object containing the committee
      *
      * @example
-     * const committee = await networkClient.getCommitteByBlockHeight(1234);
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * // Create a network client and get the committee for a specific block.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * const committee = await networkClient.getCommitteeByBlockHeight(1234);
      */
     async getCommitteeByBlockHeight(blockHeight) {
         try {
@@ -486,7 +698,14 @@ class AleoNetworkClient {
     /**
      * Returns the latest block height.
      *
+     * @returns {Promise<number>} The latest block height.
+     *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const latestHeight = networkClient.getLatestHeight();
      */
     async getLatestHeight() {
@@ -500,8 +719,16 @@ class AleoNetworkClient {
     /**
      * Returns the latest block hash.
      *
+     * @returns {Promise<string>} The latest block hash.
+     *
      * @example
-     * const latestHash - newtworkClient.getLatestBlockHash();
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * // Get the latest block hash.
+     * const latestHash = networkClient.getLatestBlockHash();
      */
     async getLatestBlockHash() {
         try {
@@ -515,9 +742,14 @@ class AleoNetworkClient {
      * Returns the source code of a program given a program ID.
      *
      * @param {string} programId The program ID of a program deployed to the Aleo Network
-     * @return {Promise<string>} Source code of the program
+     * @returns {Promise<string>} Source code of the program
      *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const program = networkClient.getProgram("hello_hello.aleo");
      * const expectedSource = "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"
      * assert.equal(program, expectedSource);
@@ -534,9 +766,14 @@ 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>} Source code of the program
+     * @returns {Promise<Program>} Source code of the program
      *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const programID = "hello_hello.aleo";
      * const programSource = "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"
      *
@@ -545,7 +782,7 @@ class AleoNetworkClient {
      * const programObjectFromSource = await networkClient.getProgramObject(programSource);
      *
      * // Both program objects should be equal
-     * assert.equal(programObjectFromID.to_string(), programObjectFromSource.to_string());
+     * assert(programObjectFromID.to_string() === programObjectFromSource.to_string());
      */
     async getProgramObject(inputProgram) {
         try {
@@ -553,7 +790,7 @@ class AleoNetworkClient {
         }
         catch (error) {
             try {
-                return Program.fromString((await this.getProgram(inputProgram)));
+                return Program.fromString(await this.getProgram(inputProgram));
             }
             catch (error) {
                 throw new Error(`${inputProgram} is neither a program name or a valid program: ${error}`);
@@ -567,12 +804,17 @@ class AleoNetworkClient {
      * @returns {Promise<ProgramImports>} Object of the form { "program_id": "program_source", .. } containing program id & source code for all program imports
      *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
      * const double_test_source = "import multiply_test.aleo;\n\nprogram double_test.aleo;\n\nfunction double_it:\n    input r0 as u32.private;\n    call multiply_test.aleo/multiply 2u32 r0 into r1;\n    output r1 as u32.private;\n"
      * const double_test = Program.fromString(double_test_source);
      * const expectedImports = {
      *     "multiply_test.aleo": "program multiply_test.aleo;\n\nfunction multiply:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    mul r0 r1 into r2;\n    output r2 as u32.private;\n"
      * }
      *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * // Imports can be fetched using the program ID, source code, or program object
      * let programImports = await networkClient.getProgramImports("double_test.aleo");
      * assert.deepStrictEqual(programImports, expectedImports);
@@ -589,15 +831,17 @@ class AleoNetworkClient {
         try {
             const imports = {};
             // Get the program object or fail if the program is not valid or does not exist
-            const program = inputProgram instanceof Program ? inputProgram : (await this.getProgramObject(inputProgram));
+            const program = inputProgram instanceof Program
+                ? inputProgram
+                : await this.getProgramObject(inputProgram);
             // Get the list of programs that the program imports
             const importList = program.getImports();
             // Recursively get any imports that the imported programs have in a depth first search order
             for (let i = 0; i < importList.length; i++) {
                 const import_id = importList[i];
                 if (!imports.hasOwnProperty(import_id)) {
-                    const programSource = await this.getProgram(import_id);
-                    const nestedImports = await this.getProgramImports(import_id);
+                    const programSource = (await this.getProgram(import_id));
+                    const nestedImports = (await this.getProgramImports(import_id));
                     for (const key in nestedImports) {
                         if (!imports.hasOwnProperty(key)) {
                             imports[key] = nestedImports[key];
@@ -619,13 +863,20 @@ class AleoNetworkClient {
      * @returns {string[]} - The list of program names that the program imports
      *
      * @example
-     * const programImportsNames = networkClient.getProgramImports("double_test.aleo");
-     * const expectedImportsNames = ["multiply_test.aleo"];
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * const programImportsNames = networkClient.getProgramImports("wrapped_credits.aleo");
+     * const expectedImportsNames = ["credits.aleo"];
      * assert.deepStrictEqual(programImportsNames, expectedImportsNames);
      */
     async getProgramImportNames(inputProgram) {
         try {
-            const program = inputProgram instanceof Program ? inputProgram : (await this.getProgramObject(inputProgram));
+            const program = inputProgram instanceof Program
+                ? inputProgram
+                : await this.getProgramObject(inputProgram);
             return program.getImports();
         }
         catch (error) {
@@ -636,7 +887,14 @@ class AleoNetworkClient {
      * Returns the names of the mappings of a program.
      *
      * @param {string} programId - The program ID to get the mappings of (e.g. "credits.aleo")
+     * @returns {Promise<Array<string>>} - The names of the mappings of the program.
+     *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const mappings = networkClient.getProgramMappingNames("credits.aleo");
      * const expectedMappings = [
      *   "committee",
@@ -662,14 +920,19 @@ class AleoNetworkClient {
      *
      * @param {string} programId - The program ID to get the mapping value of (e.g. "credits.aleo")
      * @param {string} mappingName - The name of the mapping to get the value of (e.g. "account")
-     * @param {string | Plaintext} key - The key of the mapping to get the value of (e.g. "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px")
-     * @return {Promise<string>} String representation of the value of the mapping
+     * @param {string | Plaintext} key - The key to look up in the mapping (e.g. an address for the "account" mapping)
+     * @returns {Promise<string>} String representation of the value of the mapping
      *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * // Get public balance of an account
      * const mappingValue = networkClient.getMappingValue("credits.aleo", "account", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px");
      * const expectedValue = "0u64";
-     * assert.equal(mappingValue, expectedValue);
+     * assert(mappingValue === expectedValue);
      */
     async getProgramMappingValue(programId, mappingName, key) {
         try {
@@ -681,11 +944,19 @@ class AleoNetworkClient {
         }
     }
     /**
-     * Returns the value of a mapping as a wasm Plaintext object. Returning an
-     * object in this format allows it to be converted to a Js type and for its
-     * internal members to be inspected if it's a struct or array.
+     * Returns the value of a mapping as a wasm Plaintext object. Returning an object in this format allows it to be converted to a Js type and for its internal members to be inspected if it's a struct or array.
+     *
+     * @param {string} programId - The program ID to get the mapping value of (e.g. "credits.aleo")
+     * @param {string} mappingName - The name of the mapping to get the value of (e.g. "bonded")
+     * @param {string | Plaintext} key - The key to look up in the mapping (e.g. an address for the "bonded" mapping)
+     * @returns {Promise<Plaintext>} String representation of the value of the mapping
      *
      * @example
+     * import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * // Get the bond state as an account.
      * const unbondedState = networkClient.getMappingPlaintext("credits.aleo", "bonded", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px");
      *
@@ -702,15 +973,9 @@ class AleoNetworkClient {
      *
      * const expectedState = {
      *     validator: "aleo1u6940v5m0fzud859xx2c9tj2gjg6m5qrd28n636e6fdd2akvfcgqs34mfd",
-     *     microcredits: BigInt("9007199254740991")
+     *     microcredits: BigInt(9007199254740991)
      * };
      * assert.equal(unbondedState, expectedState);
-     *
-     * @param {string} programId - The program ID to get the mapping value of (e.g. "credits.aleo")
-     * @param {string} mappingName - The name of the mapping to get the value of (e.g. "account")
-     * @param {string | Plaintext} key - The key of the mapping to get the value of (e.g. "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px")
-     *
-     * @return {Promise<string>} String representation of the value of the mapping
      */
     async getProgramMappingPlaintext(programId, mappingName, key) {
         try {
@@ -725,15 +990,25 @@ class AleoNetworkClient {
     /**
      * Returns the public balance of an address from the account mapping in credits.aleo
      *
-     * @param {string} address
+     * @param {Address | string} address A string or wasm object representing an address.
+     * @returns {Promise<number>} The public balance of the address in microcredits.
      *
      * @example
-     * const account = new Account();
-     * const publicBalance = networkClient.getPublicBalance(account.address());
+     * import { AleoNetworkClient, Account } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * // Get the balance of an account from either an address object or address string.
+     * const account = Account.fromCiphertext(process.env.ciphertext, process.env.password);
+     * const publicBalance = await networkClient.getPublicBalance(account.address());
+     * const publicBalanceFromString = await networkClient.getPublicBalance(account.address().to_string());
+     * assert(publicBalance === publicBalanceFromString);
      */
     async getPublicBalance(address) {
         try {
-            const balanceStr = await this.getProgramMappingValue('credits.aleo', 'account', address.to_string());
+            const addressString = address instanceof Address ? address.to_string() : address;
+            const balanceStr = await this.getProgramMappingValue("credits.aleo", "account", addressString);
             return balanceStr ? parseInt(balanceStr) : 0;
         }
         catch (error) {
@@ -743,12 +1018,20 @@ class AleoNetworkClient {
     /**
      * Returns the latest state/merkle root of the Aleo blockchain.
      *
+     * @returns {Promise<string>} A string representing the latest state root of the Aleo blockchain.
+     *
      * @example
+     * import { AleoNetworkClient, Account } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * // Get the latest state root.
      * const stateRoot = networkClient.getStateRoot();
      */
     async getStateRoot() {
         try {
-            return await this.fetchData('/stateRoot/latest');
+            return await this.fetchData("/stateRoot/latest");
         }
         catch (error) {
             throw new Error(`Error fetching latest state root: ${error}`);
@@ -757,8 +1040,15 @@ class AleoNetworkClient {
     /**
      * Returns a transaction by its unique identifier.
      *
-     * @param {string} transactionId
+     * @param {string} transactionId The transaction ID to fetch.
+     * @returns {Promise<TransactionJSON>} A json representation of the transaction.
+     *
      * @example
+     * import { AleoNetworkClient, Account } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const transaction = networkClient.getTransaction("at1handz9xjrqeynjrr0xay4pcsgtnczdksz3e584vfsgaz0dh0lyxq43a4wj");
      */
     async getTransaction(transactionId) {
@@ -772,9 +1062,17 @@ class AleoNetworkClient {
     /**
      * Returns a confirmed transaction by its unique identifier.
      *
-     * @param {string} transactionId
+     * @param {string} transactionId The transaction ID to fetch.
+     * @returns {Promise<ConfirmedTransactionJSON>} A json object containing the confirmed transaction.
+     *
      * @example
+     * import { AleoNetworkClient, Account } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const transaction = networkClient.getConfirmedTransaction("at1handz9xjrqeynjrr0xay4pcsgtnczdksz3e584vfsgaz0dh0lyxq43a4wj");
+     * assert.equal(transaction.status, "confirmed");
      */
     async getConfirmedTransaction(transactionId) {
         try {
@@ -788,13 +1086,16 @@ class AleoNetworkClient {
      * Returns a transaction as a wasm object. Getting a transaction of this type will allow the ability for the inputs,
      * outputs, and records to be searched for and displayed.
      *
+     * @param {string} transactionId - The unique identifier of the transaction to fetch
+     * @returns {Promise<Transaction>} A wasm object representation of the transaction.
+     *
      * @example
      * const transactionObject = networkClient.getTransaction("at1handz9xjrqeynjrr0xay4pcsgtnczdksz3e584vfsgaz0dh0lyxq43a4wj");
      * // Get the transaction inputs as a JS array.
-     * const transactionOutputs = transactionObject.inputs(true);
+     * const transactionInputs = transactionObject.inputs(true);
      *
      * // Get the transaction outputs as a JS object.
-     * const transactionInputs = transactionObject.outputs(true);
+     * const transactionOutputs = transactionObject.outputs(true);
      *
      * // Get any records generated in transitions in the transaction as a JS object.
      * const records = transactionObject.records();
@@ -805,10 +1106,6 @@ class AleoNetworkClient {
      *
      * // Get a JS representation of all inputs, outputs, and transaction metadata.
      * const transactionSummary = transactionObject.summary();
-     *
-     * @param {string} transactionId
-     * @example
-     * const transaction = networkClient.getTransactionObject("at1handz9xjrqeynjrr0xay4pcsgtnczdksz3e584vfsgaz0dh0lyxq43a4wj");
      */
     async getTransactionObject(transactionId) {
         try {
@@ -822,8 +1119,15 @@ class AleoNetworkClient {
     /**
      * Returns the transactions present at the specified block height.
      *
-     * @param {number} blockHeight
+     * @param {number} blockHeight The block height to fetch the confirmed transactions at.
+     * @returns {Promise<Array<ConfirmedTransactionJSON>>} An array of confirmed transactions (in JSON format) for the block height.
+     *
      * @example
+     * import { AleoNetworkClient, Account } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
      * const transactions = networkClient.getTransactions(654);
      */
     async getTransactions(blockHeight) {
@@ -837,9 +1141,16 @@ class AleoNetworkClient {
     /**
      * Returns the confirmed transactions present in the block with the specified block hash.
      *
-     * @param {string} blockHash
+     * @param {string} blockHash The block hash to fetch the confirmed transactions at.
+     * @returns {Promise<Array<ConfirmedTransactionJSON>>} An array of confirmed transactions (in JSON format) for the block hash.
+     *
      * @example
-     * const transactions = networkClient.getTransactionsByHash("ab19dklwl9vp63zu3hwg57wyhvmqf92fx5g8x0t6dr72py8r87pxupqfne5t9");
+     * import { AleoNetworkClient, Account } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * const transactions = networkClient.getTransactionsByBlockHash("ab19dklwl9vp63zu3hwg57wyhvmqf92fx5g8x0t6dr72py8r87pxupqfne5t9");
      */
     async getTransactionsByBlockHash(blockHash) {
         try {
@@ -854,7 +1165,15 @@ class AleoNetworkClient {
     /**
      * Returns the transactions in the memory pool. This method requires access to a validator's REST API.
      *
+     * @returns {Promise<Array<TransactionJSON>>} An array of transactions (in JSON format) currently in the mempool.
+     *
      * @example
+     * import { AleoNetworkClient, Account } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     *
+     * // Get the current transactions in the mempool.
      * const transactions = networkClient.getTransactionsInMempool();
      */
     async getTransactionsInMempool() {
@@ -867,7 +1186,8 @@ class AleoNetworkClient {
     }
     /**
      * Returns the transition ID of the transition corresponding to the ID of the input or output.
-     * @param {string} inputOrOutputID - ID of the input or output.
+     * @param {string} inputOrOutputID - The unique identifier of the input or output to find the transition ID for
+     * @returns {Promise<string>} - The transition ID of the input or output ID.
      *
      * @example
      * const transitionId = networkClient.getTransitionId("2429232855236830926144356377868449890830704336664550203176918782554219952323field");
@@ -883,18 +1203,20 @@ 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} - The transaction id of the submitted transaction or the resulting error
+     * @param {Transaction | string} transaction - The transaction to submit, either as a Transaction object or string representation
+     * @returns {Promise<string>} - The transaction id of the submitted transaction or the resulting error
      */
     async submitTransaction(transaction) {
-        const transaction_string = transaction instanceof Transaction ? transaction.toString() : transaction;
+        const transaction_string = transaction instanceof Transaction
+            ? transaction.toString()
+            : transaction;
         try {
-            const response = await post(this.host + "/transaction/broadcast", {
+            const response = await retryWithBackoff(() => this._sendPost(this.host + "/transaction/broadcast", {
                 body: transaction_string,
                 headers: Object.assign({}, this.headers, {
                     "Content-Type": "application/json",
                 }),
-            });
+            }));
             try {
                 const text = await response.text();
                 return parseJSON(text);
@@ -910,50 +1232,102 @@ class AleoNetworkClient {
     /**
      * Submit a solution to the Aleo network.
      *
-     * @param {string} solution The string representation of the solution desired to be submitted to the network.
+     * @param {string} solution - The string representation of the solution to submit
+     * @returns {Promise<string>} The solution id of the submitted solution or the resulting error.
      */
     async submitSolution(solution) {
         try {
-            const response = await post(this.host + "/solution/broadcast", {
+            const response = await retryWithBackoff(() => post(this.host + "/solution/broadcast", {
                 body: solution,
                 headers: Object.assign({}, this.headers, {
                     "Content-Type": "application/json",
                 }),
-            });
+            }));
             try {
                 const text = await response.text();
                 return parseJSON(text);
             }
             catch (error) {
-                throw new Error(`Error posting transaction. Aleo network response: ${error.message}`);
+                throw new Error(`Error posting solution. Aleo network response: ${error.message}`);
             }
         }
         catch (error) {
-            throw new Error(`Error posting transaction: No response received: ${error.message}`);
+            throw new Error(`Error posting solution: No response received: ${error.message}`);
         }
     }
     /**
-     * Await a transaction to be confirmed on the Aleo network.
+     * Await a submitted transaction to be confirmed or rejected on the Aleo network.
+     *
+     * @param {string} transactionId - The transaction ID to wait for confirmation
+     * @param {number} checkInterval - The interval in milliseconds to check for confirmation (default: 2000)
+     * @param {number} timeout - The maximum time in milliseconds to wait for confirmation (default: 45000)
+     * @returns {Promise<Transaction>} The confirmed transaction object that returns if the transaction is confirmed.
+     *
+     * @example
+     * import { AleoNetworkClient, Account, ProgramManager } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a network client and program manager.
+     * const networkClient = new AleoNetworkClient("http://api.explorer.provable.com/v1", undefined);
+     * const programManager = new ProgramManager(networkClient);
+     *
+     * // Set the account for the program manager.
+     * programManager.setAccount(Account.fromCiphertext(process.env.ciphertext, process.env.password));
      *
-     * @param {string} solution The string representation of the solution desired to be submitted to the network.
+     * // Build a transfer transaction.
+     * const tx = await programManager.buildTransferPublicTransaction(100, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", 0);
+     *
+     * // Submit the transaction to the network.
+     * const transactionId = await networkClient.submitTransaction(tx);
+     *
+     * // Wait for the transaction to be confirmed.
+     * const transaction = await networkClient.waitForTransactionConfirmation(transactionId);
      */
-    async waitForTransactionConfirmation(transactionId, checkInterval = 2000, // Poll every 2 seconds
-    timeout = 45000 // Timeout after 45 seconds
-    ) {
+    async waitForTransactionConfirmation(transactionId, checkInterval = 2000, timeout = 45000) {
         const startTime = Date.now();
         return new Promise((resolve, reject) => {
             const interval = setInterval(async () => {
+                const elapsed = Date.now() - startTime;
+                if (elapsed > timeout) {
+                    clearInterval(interval);
+                    return reject(new Error(`Transaction ${transactionId} did not appear after the timeout period of ${interval}ms - consider resubmitting the transaction`));
+                }
                 try {
-                    // Replace with actual Aleo transaction lookup API
-                    const transaction = await this.getTransactionObject(transactionId);
-                    resolve(transaction);
-                    if (Date.now() - startTime > timeout) {
+                    const res = await fetch(`${this.host}/transaction/confirmed/${transactionId}`, {
+                        headers: this.headers,
+                    });
+                    if (!res.ok) {
+                        let text = "";
+                        try {
+                            text = await res.text();
+                            console.warn("Response text from server:", text);
+                        }
+                        catch (err) {
+                            console.warn("Failed to read response text:", err);
+                        }
+                        // If the transaction ID is malformed (e.g. invalid checksum, wrong length),
+                        // the API returns a 4XX with "Invalid URL" — we treat this as a fatal error and stop polling.
+                        if (res.status >= 400 &&
+                            res.status < 500 &&
+                            text.includes("Invalid URL")) {
+                            clearInterval(interval);
+                            return reject(new Error(`Malformed transaction ID: ${text}`));
+                        }
+                        // Log and continue polling for 404s or 5XX errors in case a tx doesn't exist yet
+                        console.warn("Non-OK response (retrying):", res.status, text);
+                        return;
+                    }
+                    const data = parseJSON(await res.text());
+                    if (data?.status === "accepted") {
                         clearInterval(interval);
-                        reject(new Error("Transaction confirmation timed out"));
+                        return resolve(data);
+                    }
+                    if (data?.status === "rejected") {
+                        clearInterval(interval);
+                        return reject(new Error(`Transaction ${transactionId} was rejected by the network. Ensure that the account paying the fee has enough credits and that the inputs to the on-chain function are valid.`));
                     }
                 }
-                catch (error) {
-                    console.error("Error checking transaction:", error);
+                catch (err) {
+                    console.error("Polling error:", err);
                 }
             }, checkInterval);
         });
@@ -1472,12 +1846,21 @@ class ProgramManager {
      * @param { FunctionKeyProvider | undefined } keyProvider A key provider that implements {@link FunctionKeyProvider} interface
      * @param { RecordProvider | undefined } recordProvider A record provider that implements {@link RecordProvider} interface
      */
-    constructor(host, keyProvider, recordProvider) {
-        this.host = host ? host : 'https://api.explorer.provable.com/v1';
-        this.networkClient = new AleoNetworkClient(this.host);
+    constructor(host, keyProvider, recordProvider, networkClientOptions) {
+        this.host = host ? host : "https://api.explorer.provable.com/v1";
+        this.networkClient = new AleoNetworkClient(this.host, networkClientOptions);
         this.keyProvider = keyProvider ? keyProvider : new AleoKeyProvider();
         this.recordProvider = recordProvider;
     }
+    /**
+     * Check if the fee is sufficient to pay for the transaction
+     */
+    async checkFee(address, feeAmount) {
+        const balance = BigInt(await this.networkClient.getPublicBalance(address));
+        if (feeAmount > balance) {
+            throw Error(`The desired execution requires a fee of ${feeAmount} microcredits, but the account paying the fee has ${balance} microcredits available.`);
+        }
+    }
     /**
      * Set the account to use for transaction submission to the Aleo network
      *
@@ -1511,11 +1894,46 @@ class ProgramManager {
     setRecordProvider(recordProvider) {
         this.recordProvider = recordProvider;
     }
+    /**
+     * Set a header in the `AleoNetworkClient`s header map
+     *
+     * @param {string} headerName The name of the header to set
+     * @param {string} value The header value
+     *
+     * @example
+     * import { ProgramManager } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a ProgramManager
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1");
+     *
+     * // Set the value of the `Accept-Language` header to `en-US`
+     * programManager.setHeader('Accept-Language', 'en-US');
+     */
+    setHeader(headerName, value) {
+        this.networkClient.headers[headerName] = value;
+    }
+    /**
+     * Remove a header from the `AleoNetworkClient`s header map
+     *
+     * @param {string} headerName The name of the header to be removed
+     *
+     * @example
+     * import { ProgramManager } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a ProgramManager
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1");
+     *
+     * // Remove the default `X-Aleo-SDK-Version` header
+     * programManager.removeHeader('X-Aleo-SDK-Version');
+     */
+    removeHeader(headerName) {
+        delete this.networkClient.headers[headerName];
+    }
     /**
      * Builds a deployment transaction for submission to the Aleo network.
      *
      * @param {string} program Program source code
-     * @param {number} fee Fee to pay for the transaction
+     * @param {number} priorityFee The optional priority fee to be paid for that transaction.
      * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
      * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for searching for a record to use pay the deployment fee
      * @param {string | RecordPlaintext | undefined} feeRecord Optional Fee record to use for the transaction
@@ -1537,7 +1955,7 @@ class ProgramManager {
      * programManager.setAccount(Account);
      *
      * // Define a fee in credits
-     * const fee = 1.2;
+     * const priorityFee = 0.0;
      *
      * // Create the deployment transaction.
      * const tx = await programManager.buildDeploymentTransaction(program, fee, false);
@@ -1549,10 +1967,17 @@ class ProgramManager {
      *  assert(transaction.id() === tx.id());
      * }, 20000);
      */
-    async buildDeploymentTransaction(program, fee, privateFee, recordSearchParams, feeRecord, privateKey) {
+    async buildDeploymentTransaction(program, priorityFee, privateFee, recordSearchParams, feeRecord, privateKey) {
+        // Ensure the program is valid.
+        let programObject;
+        try {
+            programObject = Program.fromString(program);
+        }
+        catch (e) {
+            logAndThrow(`Error parsing program: '${e.message}'. Please ensure the program is valid.`);
+        }
         // Ensure the program is valid and does not exist on the network
         try {
-            const programObject = Program.fromString(program);
             let programSource;
             try {
                 programSource = await this.networkClient.getProgram(programObject.id());
@@ -1561,8 +1986,8 @@ class ProgramManager {
                 // Program does not exist on the network, deployment can proceed
                 console.log(`Program ${programObject.id()} does not exist on the network, deploying...`);
             }
-            if (typeof programSource == "string") {
-                throw (`Program ${programObject.id()} already exists on the network, please rename your program`);
+            if (typeof programSource === "string") {
+                throw Error(`Program ${programObject.id()} already exists on the network, please rename your program`);
             }
         }
         catch (e) {
@@ -1570,15 +1995,18 @@ class ProgramManager {
         }
         // Get the private key from the account if it is not provided in the parameters
         let deploymentPrivateKey = privateKey;
-        if (typeof privateKey === "undefined" && typeof this.account !== "undefined") {
+        if (typeof privateKey === "undefined" &&
+            typeof this.account !== "undefined") {
             deploymentPrivateKey = this.account.privateKey();
         }
         if (typeof deploymentPrivateKey === "undefined") {
-            throw ("No private key provided and no private key set in the ProgramManager");
+            throw "No private key provided and no private key set in the ProgramManager";
         }
         // Get the fee record from the account if it is not provided in the parameters
         try {
-            feeRecord = privateFee ? await this.getCreditsRecord(fee, [], feeRecord, recordSearchParams) : undefined;
+            feeRecord = privateFee
+                ? (await this.getCreditsRecord(priorityFee, [], feeRecord, recordSearchParams))
+                : undefined;
         }
         catch (e) {
             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.`);
@@ -1586,7 +2014,9 @@ class ProgramManager {
         // Get the proving and verifying keys from the key provider
         let feeKeys;
         try {
-            feeKeys = privateFee ? await this.keyProvider.feePrivateKeys() : await this.keyProvider.feePublicKeys();
+            feeKeys = privateFee
+                ? await this.keyProvider.feePrivateKeys()
+                : await this.keyProvider.feePublicKeys();
         }
         catch (e) {
             logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
@@ -1600,14 +2030,14 @@ class ProgramManager {
         catch (e) {
             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
-        return await ProgramManager$1.buildDeploymentTransaction(deploymentPrivateKey, program, fee, feeRecord, this.host, imports, feeProvingKey, feeVerifyingKey);
+        // Build a deployment transaction
+        return await ProgramManager$1.buildDeploymentTransaction(deploymentPrivateKey, program, priorityFee, feeRecord, this.host, imports, feeProvingKey, feeVerifyingKey);
     }
     /**
      * Deploy an Aleo program to the Aleo network
      *
      * @param {string} program Program source code
-     * @param {number} fee Fee to pay for the transaction
+     * @param {number} priorityFee The optional fee to be paid for the transaction
      * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
      * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for searching for a record to used pay the deployment fee
      * @param {string | RecordPlaintext | undefined} feeRecord Optional Fee record to use for the transaction
@@ -1628,7 +2058,7 @@ class ProgramManager {
      * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      *
      * // Define a fee in credits
-     * const fee = 1.2;
+     * const priorityFee = 0.0;
      *
      * // Deploy the program
      * const tx_id = await programManager.deploy(program, fee, false);
@@ -1639,8 +2069,20 @@ class ProgramManager {
      *  assert(transaction.id() === tx_id);
      * }, 20000);
      */
-    async deploy(program, fee, privateFee, recordSearchParams, feeRecord, privateKey) {
-        const tx = await this.buildDeploymentTransaction(program, fee, privateFee, recordSearchParams, feeRecord, privateKey);
+    async deploy(program, priorityFee, privateFee, recordSearchParams, feeRecord, privateKey) {
+        const tx = (await this.buildDeploymentTransaction(program, priorityFee, privateFee, recordSearchParams, feeRecord, privateKey));
+        let feeAddress;
+        if (typeof privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -1665,7 +2107,7 @@ class ProgramManager {
      * const tx = await programManager.buildExecutionTransaction({
      *   programName: "hello_hello.aleo",
      *   functionName: "hello_hello",
-     *   fee: 0.020,
+     *   priorityFee: 0.0,
      *   privateFee: false,
      *   inputs: ["5u32", "5u32"],
      *   keySearchParams: { "cacheKey": "hello_hello:hello" }
@@ -1682,7 +2124,7 @@ class ProgramManager {
      */
     async buildExecutionTransaction(options) {
         // Destructure the options object to access the parameters
-        const { programName, functionName, fee, privateFee, inputs, recordSearchParams, keySearchParams, privateKey, offlineQuery } = options;
+        const { programName, functionName, priorityFee, privateFee, inputs, recordSearchParams, keySearchParams, privateKey, offlineQuery, } = options;
         let feeRecord = options.feeRecord;
         let provingKey = options.provingKey;
         let verifyingKey = options.verifyingKey;
@@ -1702,15 +2144,18 @@ class ProgramManager {
         }
         // Get the private key from the account if it is not provided in the parameters
         let executionPrivateKey = privateKey;
-        if (typeof privateKey === "undefined" && typeof this.account !== "undefined") {
+        if (typeof privateKey === "undefined" &&
+            typeof this.account !== "undefined") {
             executionPrivateKey = this.account.privateKey();
         }
         if (typeof executionPrivateKey === "undefined") {
-            throw ("No private key provided and no private key set in the ProgramManager");
+            throw "No private key provided and no private key set in the ProgramManager";
         }
         // Get the fee record from the account if it is not provided in the parameters
         try {
-            feeRecord = privateFee ? await this.getCreditsRecord(fee, [], feeRecord, recordSearchParams) : undefined;
+            feeRecord = privateFee
+                ? (await this.getCreditsRecord(priorityFee, [], feeRecord, recordSearchParams))
+                : undefined;
         }
         catch (e) {
             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.`);
@@ -1718,7 +2163,9 @@ class ProgramManager {
         // Get the fee proving and verifying keys from the key provider
         let feeKeys;
         try {
-            feeKeys = privateFee ? await this.keyProvider.feePrivateKeys() : await this.keyProvider.feePublicKeys();
+            feeKeys = privateFee
+                ? await this.keyProvider.feePrivateKeys()
+                : await this.keyProvider.feePublicKeys();
         }
         catch (e) {
             logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
@@ -1727,7 +2174,7 @@ class ProgramManager {
         // If the function proving and verifying keys are not provided, attempt to find them using the key provider
         if (!provingKey || !verifyingKey) {
             try {
-                [provingKey, verifyingKey] = await this.keyProvider.functionKeys(keySearchParams);
+                [provingKey, verifyingKey] = (await this.keyProvider.functionKeys(keySearchParams));
             }
             catch (e) {
                 console.log(`Function keys not found. Key finder response: '${e}'. The function keys will be synthesized`);
@@ -1737,14 +2184,14 @@ class ProgramManager {
         const numberOfImports = Program.fromString(program).getImports().length;
         if (numberOfImports > 0 && !imports) {
             try {
-                imports = await this.networkClient.getProgramImports(programName);
+                imports = (await this.networkClient.getProgramImports(programName));
             }
             catch (e) {
                 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
-        return await ProgramManager$1.buildExecutionTransaction(executionPrivateKey, program, functionName, inputs, fee, feeRecord, this.host, imports, provingKey, verifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
+        // Build an execution transaction
+        return await ProgramManager$1.buildExecutionTransaction(executionPrivateKey, program, functionName, inputs, priorityFee, feeRecord, this.host, imports, provingKey, verifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
     }
     /**
      * Builds an execution transaction for submission to the Aleo network.
@@ -1768,7 +2215,7 @@ class ProgramManager {
      * const tx_id = await programManager.execute({
      *   programName: "hello_hello.aleo",
      *   functionName: "hello_hello",
-     *   fee: 0.020,
+     *   priorityFee: 0.0,
      *   privateFee: false,
      *   inputs: ["5u32", "5u32"],
      *   keySearchParams: { "cacheKey": "hello_hello:hello" }
@@ -1782,6 +2229,18 @@ class ProgramManager {
      */
     async execute(options) {
         const tx = await this.buildExecutionTransaction(options);
+        let feeAddress;
+        if (typeof options.privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(options.privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -1819,16 +2278,17 @@ class ProgramManager {
     async run(program, function_name, inputs, proveExecution, imports, keySearchParams, provingKey, verifyingKey, privateKey, offlineQuery) {
         // Get the private key from the account if it is not provided in the parameters
         let executionPrivateKey = privateKey;
-        if (typeof privateKey === "undefined" && typeof this.account !== "undefined") {
+        if (typeof privateKey === "undefined" &&
+            typeof this.account !== "undefined") {
             executionPrivateKey = this.account.privateKey();
         }
         if (typeof executionPrivateKey === "undefined") {
-            throw ("No private key provided and no private key set in the ProgramManager");
+            throw "No private key provided and no private key set in the ProgramManager";
         }
         // If the function proving and verifying keys are not provided, attempt to find them using the key provider
         if (!provingKey || !verifyingKey) {
             try {
-                [provingKey, verifyingKey] = await this.keyProvider.functionKeys(keySearchParams);
+                [provingKey, verifyingKey] = (await this.keyProvider.functionKeys(keySearchParams));
             }
             catch (e) {
                 console.log(`Function keys not found. Key finder response: '${e}'. The function keys will be synthesized`);
@@ -1845,7 +2305,7 @@ class ProgramManager {
      *
      * @param {RecordPlaintext | string} recordOne First credits record to join
      * @param {RecordPlaintext | string} recordTwo Second credits record to join
-     * @param {number} fee Fee in credits pay for the join transaction
+     * @param {number} priorityFee The optional priority fee to be paid for the transaction
      * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
      * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the fee record to use to pay the fee for the join transaction
      * @param {RecordPlaintext | string | undefined} feeRecord Fee record to use for the join transaction
@@ -1874,20 +2334,28 @@ class ProgramManager {
      *  assert(transaction.id() === tx_id);
      * }, 10000);
      */
-    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
+    async join(recordOne, recordTwo, priorityFee, privateFee, recordSearchParams, feeRecord, privateKey, offlineQuery) {
+        // Get the private key from the account if it is not provided in the parameters and assign the fee address
         let executionPrivateKey = privateKey;
-        if (typeof privateKey === "undefined" && typeof this.account !== "undefined") {
+        let feeAddress;
+        if (typeof privateKey === "undefined" &&
+            typeof this.account !== "undefined") {
             executionPrivateKey = this.account.privateKey();
+            feeAddress = this.account?.address();
         }
-        if (typeof executionPrivateKey === "undefined") {
-            throw ("No private key provided and no private key set in the ProgramManager");
+        else if (typeof executionPrivateKey === "undefined") {
+            throw "No private key provided and no private key set in the ProgramManager";
+        }
+        else {
+            feeAddress = Address.from_private_key(executionPrivateKey);
         }
         // Get the proving and verifying keys from the key provider
         let feeKeys;
         let joinKeys;
         try {
-            feeKeys = privateFee ? await this.keyProvider.feePrivateKeys() : await this.keyProvider.feePublicKeys();
+            feeKeys = privateFee
+                ? await this.keyProvider.feePrivateKeys()
+                : await this.keyProvider.feePublicKeys();
             joinKeys = await this.keyProvider.joinKeys();
         }
         catch (e) {
@@ -1897,21 +2365,31 @@ class ProgramManager {
         const [joinProvingKey, joinVerifyingKey] = joinKeys;
         // Get the fee record from the account if it is not provided in the parameters
         try {
-            feeRecord = privateFee ? await this.getCreditsRecord(fee, [], feeRecord, recordSearchParams) : undefined;
+            feeRecord = privateFee
+                ? (await this.getCreditsRecord(priorityFee, [], feeRecord, recordSearchParams))
+                : undefined;
         }
         catch (e) {
             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 {
-            recordOne = recordOne instanceof RecordPlaintext ? recordOne : RecordPlaintext.fromString(recordOne);
-            recordTwo = recordTwo instanceof RecordPlaintext ? recordTwo : RecordPlaintext.fromString(recordTwo);
+            recordOne =
+                recordOne instanceof RecordPlaintext
+                    ? recordOne
+                    : RecordPlaintext.fromString(recordOne);
+            recordTwo =
+                recordTwo instanceof RecordPlaintext
+                    ? recordTwo
+                    : RecordPlaintext.fromString(recordTwo);
         }
         catch (e) {
-            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);
+        const tx = await ProgramManager$1.buildJoinTransaction(executionPrivateKey, recordOne, recordTwo, priorityFee, feeRecord, this.host, joinProvingKey, joinVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -1946,11 +2424,12 @@ class ProgramManager {
     async split(splitAmount, amountRecord, privateKey, offlineQuery) {
         // Get the private key from the account if it is not provided in the parameters
         let executionPrivateKey = privateKey;
-        if (typeof executionPrivateKey === "undefined" && typeof this.account !== "undefined") {
+        if (typeof privateKey === "undefined" &&
+            typeof this.account !== "undefined") {
             executionPrivateKey = this.account.privateKey();
         }
         if (typeof executionPrivateKey === "undefined") {
-            throw ("No private key provided and no private key set in the ProgramManager");
+            throw "No private key provided and no private key set in the ProgramManager";
         }
         // Get the split keys from the key provider
         let splitKeys;
@@ -1963,7 +2442,10 @@ class ProgramManager {
         const [splitProvingKey, splitVerifyingKey] = splitKeys;
         // Validate the record to be split
         try {
-            amountRecord = amountRecord instanceof RecordPlaintext ? amountRecord : RecordPlaintext.fromString(amountRecord);
+            amountRecord =
+                amountRecord instanceof RecordPlaintext
+                    ? amountRecord
+                    : RecordPlaintext.fromString(amountRecord);
         }
         catch (e) {
             logAndThrow("Record provided is not valid. Please ensure it is a valid plaintext record.");
@@ -1998,7 +2480,10 @@ class ProgramManager {
         try {
             imports = await this.networkClient.getProgramImports(program);
             const keyPair = await ProgramManager$1.synthesizeKeyPair(executionPrivateKey, program, function_id, inputs, imports);
-            return [keyPair.provingKey(), keyPair.verifyingKey()];
+            return [
+                keyPair.provingKey(),
+                keyPair.verifyingKey(),
+            ];
         }
         catch (e) {
             logAndThrow(`Could not synthesize keys - error ${e.message}. Please ensure the program is valid and the inputs are correct.`);
@@ -2010,7 +2495,7 @@ class ProgramManager {
      * @param {number} amount The amount of credits to transfer
      * @param {string} recipient The recipient of the transfer
      * @param {string} transferType The type of transfer to perform - options: 'private', 'privateToPublic', 'public', 'publicToPrivate'
-     * @param {number} fee The fee to pay for the transfer
+     * @param {number} priorityFee The optional priority fee to be paid for the transaction
      * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
      * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the amount and fee records for the transfer transaction
      * @param {RecordPlaintext | string} amountRecord Optional amount record to use for the transfer
@@ -2039,23 +2524,26 @@ class ProgramManager {
      *  assert(transaction.id() === tx.id());
      * }, 10000);
      */
-    async buildTransferTransaction(amount, recipient, transferType, fee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) {
+    async buildTransferTransaction(amount, recipient, transferType, priorityFee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) {
         // Validate the transfer type
         transferType = validateTransferType(transferType);
         // Get the private key from the account if it is not provided in the parameters
         let executionPrivateKey = privateKey;
-        if (typeof executionPrivateKey === "undefined" && typeof this.account !== "undefined") {
+        if (typeof executionPrivateKey === "undefined" &&
+            typeof this.account !== "undefined") {
             executionPrivateKey = this.account.privateKey();
         }
         if (typeof executionPrivateKey === "undefined") {
-            throw ("No private key provided and no private key set in the ProgramManager");
+            throw "No private key provided and no private key set in the ProgramManager";
         }
         // Get the proving and verifying keys from the key provider
         let feeKeys;
         let transferKeys;
         try {
-            feeKeys = privateFee ? await this.keyProvider.feePrivateKeys() : await this.keyProvider.feePublicKeys();
-            transferKeys = await this.keyProvider.transferKeys(transferType);
+            feeKeys = privateFee
+                ? await this.keyProvider.feePrivateKeys()
+                : await this.keyProvider.feePublicKeys();
+            transferKeys = (await this.keyProvider.transferKeys(transferType));
         }
         catch (e) {
             logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
@@ -2068,26 +2556,28 @@ class ProgramManager {
             const nonces = [];
             if (requiresAmountRecord(transferType)) {
                 // If the transfer type is private and requires an amount record, get it from the record provider
-                amountRecord = await this.getCreditsRecord(fee, [], amountRecord, recordSearchParams);
+                amountRecord = (await this.getCreditsRecord(priorityFee, [], amountRecord, recordSearchParams));
                 nonces.push(amountRecord.nonce());
             }
             else {
                 amountRecord = undefined;
             }
-            feeRecord = privateFee ? await this.getCreditsRecord(fee, nonces, feeRecord, recordSearchParams) : undefined;
+            feeRecord = privateFee
+                ? (await this.getCreditsRecord(priorityFee, nonces, feeRecord, recordSearchParams))
+                : undefined;
         }
         catch (e) {
             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);
+        // Build an execution transaction
+        return await ProgramManager$1.buildTransferTransaction(executionPrivateKey, amount, recipient, transferType, amountRecord, priorityFee, feeRecord, this.host, transferProvingKey, transferVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
     }
     /**
      * Build a transfer_public transaction to transfer credits to another account for later submission to the Aleo network
      *
      * @param {number} amount The amount of credits to transfer
      * @param {string} recipient The recipient of the transfer
-     * @param {number} fee The fee to pay for the transfer records for the transfer transaction
+     * @param {number} priorityFee The optional priority fee to be paid 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<Transaction>} The transaction object
@@ -2112,20 +2602,15 @@ class ProgramManager {
      *  assert(transaction.id() === tx.id());
      * }, 10000);
      */
-    async buildTransferPublicTransaction(amount, recipient, fee, privateKey, offlineQuery) {
-        return this.buildTransferTransaction(amount, recipient, "public", fee, false, undefined, undefined, undefined, privateKey, offlineQuery);
+    async buildTransferPublicTransaction(amount, recipient, priorityFee, privateKey, offlineQuery) {
+        return this.buildTransferTransaction(amount, recipient, "public", priorityFee, false, undefined, undefined, undefined, privateKey, offlineQuery);
     }
     /**
      * Build a transfer_public_as_signer transaction to transfer credits to another account for later submission to the Aleo network
      *
      * @param {number} amount The amount of credits to transfer
      * @param {string} recipient The recipient of the transfer
-     * @param {string} transferType The type of transfer to perform - options: 'private', 'privateToPublic', 'public', 'publicToPrivate'
-     * @param {number} fee The fee to pay for the transfer
-     * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
-     * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the amount and fee records for the transfer transaction
-     * @param {RecordPlaintext | string} amountRecord Optional amount record to use for the transfer
-     * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
+     * @param {number} priorityFee The optional priority fee to be paid 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<Transaction>} The transaction object
@@ -2150,8 +2635,8 @@ class ProgramManager {
      *  assert(transaction.id() === tx.id());
      * }, 10000);
      */
-    async buildTransferPublicAsSignerTransaction(amount, recipient, fee, privateKey, offlineQuery) {
-        return this.buildTransferTransaction(amount, recipient, "public", fee, false, undefined, undefined, undefined, privateKey, offlineQuery);
+    async buildTransferPublicAsSignerTransaction(amount, recipient, priorityFee, privateKey, offlineQuery) {
+        return this.buildTransferTransaction(amount, recipient, "public", priorityFee, false, undefined, undefined, undefined, privateKey, offlineQuery);
     }
     /**
      * Transfer credits to another account
@@ -2159,7 +2644,7 @@ class ProgramManager {
      * @param {number} amount The amount of credits to transfer
      * @param {string} recipient The recipient of the transfer
      * @param {string} transferType The type of transfer to perform - options: 'private', 'privateToPublic', 'public', 'publicToPrivate'
-     * @param {number} fee The fee to pay for the transfer
+     * @param {number} priorityFee The optional priority fee to be paid for the transfer
      * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
      * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the amount and fee records for the transfer transaction
      * @param {RecordPlaintext | string} amountRecord Optional amount record to use for the transfer
@@ -2187,8 +2672,20 @@ class ProgramManager {
      *  assert(transaction.id() === tx_id);
      * }, 10000);
      */
-    async transfer(amount, recipient, transferType, fee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) {
-        const tx = await this.buildTransferTransaction(amount, recipient, transferType, fee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery);
+    async transfer(amount, recipient, transferType, priorityFee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) {
+        const tx = (await this.buildTransferTransaction(amount, recipient, transferType, priorityFee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery));
+        let feeAddress;
+        if (typeof privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -2226,19 +2723,23 @@ class ProgramManager {
      */
     async buildBondPublicTransaction(validator_address, withdrawal_address, amount, options = {}) {
         const scaledAmount = Math.trunc(amount * 1000000);
-        const { programName = "credits.aleo", functionName = "bond_public", fee = options.fee || 0.86, privateFee = false, inputs = [validator_address, withdrawal_address, `${scaledAmount.toString()}u64`], keySearchParams = new AleoKeyProviderParams({
+        const { programName = "credits.aleo", functionName = "bond_public", priorityFee = options.priorityFee || 0, privateFee = false, inputs = [
+            validator_address,
+            withdrawal_address,
+            `${scaledAmount.toString()}u64`,
+        ], keySearchParams = new AleoKeyProviderParams({
             proverUri: CREDITS_PROGRAM_KEYS.bond_public.prover,
             verifierUri: CREDITS_PROGRAM_KEYS.bond_public.verifier,
-            cacheKey: "credits.aleo/bond_public"
+            cacheKey: "credits.aleo/bond_public",
         }), program = this.creditsProgram(), ...additionalOptions } = options;
         const executeOptions = {
             programName,
             functionName,
-            fee,
+            priorityFee,
             privateFee,
             inputs,
             keySearchParams,
-            ...additionalOptions
+            ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
     }
@@ -2272,7 +2773,19 @@ class ProgramManager {
      * }, 10000);
      */
     async bondPublic(validator_address, withdrawal_address, amount, options = {}) {
-        const tx = await this.buildBondPublicTransaction(validator_address, withdrawal_address, amount, options);
+        const tx = (await this.buildBondPublicTransaction(validator_address, withdrawal_address, amount, options));
+        let feeAddress;
+        if (typeof options.privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(options.privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -2312,19 +2825,24 @@ class ProgramManager {
     async buildBondValidatorTransaction(validator_address, withdrawal_address, amount, commission, options = {}) {
         const scaledAmount = Math.trunc(amount * 1000000);
         const adjustedCommission = Math.trunc(commission);
-        const { programName = "credits.aleo", functionName = "bond_validator", fee = options.fee || 0.86, privateFee = false, inputs = [validator_address, withdrawal_address, `${scaledAmount.toString()}u64`, `${adjustedCommission.toString()}u8`], keySearchParams = new AleoKeyProviderParams({
+        const { programName = "credits.aleo", functionName = "bond_validator", priorityFee = options.priorityFee || 0, privateFee = false, inputs = [
+            validator_address,
+            withdrawal_address,
+            `${scaledAmount.toString()}u64`,
+            `${adjustedCommission.toString()}u8`,
+        ], keySearchParams = new AleoKeyProviderParams({
             proverUri: CREDITS_PROGRAM_KEYS.bond_validator.prover,
             verifierUri: CREDITS_PROGRAM_KEYS.bond_validator.verifier,
-            cacheKey: "credits.aleo/bond_validator"
+            cacheKey: "credits.aleo/bond_validator",
         }), program = this.creditsProgram(), ...additionalOptions } = options;
         const executeOptions = {
             programName,
             functionName,
-            fee,
+            priorityFee,
             privateFee,
             inputs,
             keySearchParams,
-            ...additionalOptions
+            ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
     }
@@ -2360,7 +2878,19 @@ class ProgramManager {
      * }, 10000);
      */
     async bondValidator(validator_address, withdrawal_address, amount, commission, options = {}) {
-        const tx = await this.buildBondValidatorTransaction(validator_address, withdrawal_address, amount, commission, options);
+        const tx = (await this.buildBondValidatorTransaction(validator_address, withdrawal_address, amount, commission, options));
+        let feeAddress;
+        if (typeof options.privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(options.privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -2394,19 +2924,19 @@ class ProgramManager {
      */
     async buildUnbondPublicTransaction(staker_address, amount, options = {}) {
         const scaledAmount = Math.trunc(amount * 1000000);
-        const { programName = "credits.aleo", functionName = "unbond_public", fee = options.fee || 1.3, privateFee = false, inputs = [staker_address, `${scaledAmount.toString()}u64`], keySearchParams = new AleoKeyProviderParams({
+        const { programName = "credits.aleo", functionName = "unbond_public", priorityFee = options.priorityFee || 0, privateFee = false, inputs = [staker_address, `${scaledAmount.toString()}u64`], keySearchParams = new AleoKeyProviderParams({
             proverUri: CREDITS_PROGRAM_KEYS.unbond_public.prover,
             verifierUri: CREDITS_PROGRAM_KEYS.unbond_public.verifier,
-            cacheKey: "credits.aleo/unbond_public"
+            cacheKey: "credits.aleo/unbond_public",
         }), program = this.creditsProgram(), ...additionalOptions } = options;
         const executeOptions = {
             programName,
             functionName,
-            fee,
+            priorityFee,
             privateFee,
             inputs,
             keySearchParams,
-            ...additionalOptions
+            ...additionalOptions,
         };
         return this.buildExecutionTransaction(executeOptions);
     }
@@ -2445,7 +2975,19 @@ class ProgramManager {
      * }, 10000);
      */
     async unbondPublic(staker_address, amount, options = {}) {
-        const tx = await this.buildUnbondPublicTransaction(staker_address, amount, options);
+        const tx = (await this.buildUnbondPublicTransaction(staker_address, amount, options));
+        let feeAddress;
+        if (typeof options.privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(options.privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -2479,20 +3021,21 @@ class ProgramManager {
      * }, 10000);
      */
     async buildClaimUnbondPublicTransaction(staker_address, options = {}) {
-        const { programName = "credits.aleo", functionName = "claim_unbond_public", fee = options.fee || 2, privateFee = false, inputs = [staker_address], keySearchParams = new AleoKeyProviderParams({
+        const { programName = "credits.aleo", functionName = "claim_unbond_public", priorityFee = options.priorityFee || 0, privateFee = false, inputs = [staker_address], keySearchParams = new AleoKeyProviderParams({
             proverUri: CREDITS_PROGRAM_KEYS.claim_unbond_public.prover,
             verifierUri: CREDITS_PROGRAM_KEYS.claim_unbond_public.verifier,
-            cacheKey: "credits.aleo/claim_unbond_public"
+            cacheKey: "credits.aleo/claim_unbond_public",
         }), program = this.creditsProgram(), ...additionalOptions } = options;
         const executeOptions = {
             programName,
             functionName,
-            fee,
+            priorityFee,
             privateFee,
             inputs,
             keySearchParams,
-            ...additionalOptions
+            ...additionalOptions,
         };
+        // Check if the account has sufficient credits to pay for the transaction
         return await this.buildExecutionTransaction(executeOptions);
     }
     /**
@@ -2525,7 +3068,19 @@ class ProgramManager {
      * }, 10000);
      */
     async claimUnbondPublic(staker_address, options = {}) {
-        const tx = await this.buildClaimUnbondPublicTransaction(staker_address, options);
+        const tx = (await this.buildClaimUnbondPublicTransaction(staker_address, options));
+        let feeAddress;
+        if (typeof options.privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(options.privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return await this.networkClient.submitTransaction(tx);
     }
     /**
@@ -2567,21 +3122,21 @@ class ProgramManager {
      * }, 10000);
      */
     async buildSetValidatorStateTransaction(validator_state, options = {}) {
-        const { programName = "credits.aleo", functionName = "set_validator_state", fee = 1, privateFee = false, inputs = [validator_state.toString()], keySearchParams = new AleoKeyProviderParams({
+        const { programName = "credits.aleo", functionName = "set_validator_state", priorityFee = 0, privateFee = false, inputs = [validator_state.toString()], keySearchParams = new AleoKeyProviderParams({
             proverUri: CREDITS_PROGRAM_KEYS.set_validator_state.prover,
             verifierUri: CREDITS_PROGRAM_KEYS.set_validator_state.verifier,
-            cacheKey: "credits.aleo/set_validator_state"
+            cacheKey: "credits.aleo/set_validator_state",
         }), ...additionalOptions } = options;
         const executeOptions = {
             programName,
             functionName,
-            fee,
+            priorityFee,
             privateFee,
             inputs,
             keySearchParams,
-            ...additionalOptions
+            ...additionalOptions,
         };
-        return await this.execute(executeOptions);
+        return await this.buildExecutionTransaction(executeOptions);
     }
     /**
      * Submit a set_validator_state transaction to the Aleo Network.
@@ -2619,22 +3174,60 @@ class ProgramManager {
      * }, 10000);
      */
     async setValidatorState(validator_state, options = {}) {
-        const tx = await this.buildSetValidatorStateTransaction(validator_state, options);
+        const tx = (await this.buildSetValidatorStateTransaction(validator_state, options));
+        let feeAddress;
+        if (typeof options.privateKey !== "undefined") {
+            feeAddress = Address.from_private_key(options.privateKey);
+        }
+        else if (this.account !== undefined) {
+            feeAddress = this.account?.address();
+        }
+        else {
+            throw Error("No private key provided and no private key set in the ProgramManager. Please set an account or provide a private key.");
+        }
+        // Check if the account has sufficient credits to pay for the transaction
+        await this.checkFee(feeAddress.to_string(), tx.feeAmount());
         return this.networkClient.submitTransaction(tx);
     }
     /**
-     * Verify a proof of execution from an offline execution
+     * Verify a proof from an offline execution. This is useful when it is desired to do offchain proving and verification.
      *
-     * @param {executionResponse} executionResponse
+     * @param {executionResponse} executionResponse The response from an offline function execution (via the `programManager.run` method)
+     * @param {ImportedPrograms} imports The imported programs used in the execution. Specified as { "programName": "programSourceCode", ... }
+     * @param {ImportedVerifyingKeys} importedVerifyingKeys The verifying keys in the execution. Specified as { "programName": [["functionName", "verifyingKey"], ...], ... }
      * @returns {boolean} True if the proof is valid, false otherwise
+     *
+     * @example
+     * /// Import the mainnet version of the sdk used to build executions.
+     * import { Account, ProgramManager } from "@provablehq/sdk/mainnet.js";
+     *
+     * /// Create the source for two programs.
+     * const program = "import add_it_up.aleo; \n\n program mul_add.aleo;\n\nfunction mul_and_add:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    mul r0 r1 into r2;\n call add_it_up.aleo/add_it r1 r2 into r3;  output r3 as u32.private;\n";
+     * const program_import = "program add_it_up.aleo;\n\nfunction add_it:\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(undefined, undefined, undefined);
+     *
+     * /// Create a temporary account for the execution of the program
+     * const account = Account.fromCipherText(process.env.ciphertext, process.env.password);
+     * programManager.setAccount(account);
+     *
+     * /// Get the response and ensure that the program executed correctly
+     * const executionResponse = await programManager.run(program, "mul_and_add", ["5u32", "5u32"], true);
+     *
+     * /// Construct the imports and verifying keys
+     * const imports = { "add_it_up.aleo": program_import };
+     * const importedVerifyingKeys = { "add_it_up.aleo": [["add_it", "verifyingKey1..."]] };
+     *
+     * /// Verify the execution.
+     * const isValid = programManager.verifyExecution(executionResponse, imports, importedVerifyingKeys);
+     * assert(isValid);
      */
-    verifyExecution(executionResponse) {
+    verifyExecution(executionResponse, imports, importedVerifyingKeys) {
         try {
-            const execution = executionResponse.getExecution();
+            const execution = (executionResponse.getExecution());
             const function_id = executionResponse.getFunctionId();
             const program = executionResponse.getProgram();
             const verifyingKey = executionResponse.getVerifyingKey();
-            return verifyFunctionExecution(execution, verifyingKey, program, function_id);
+            return verifyFunctionExecution(execution, verifyingKey, program, function_id, imports, importedVerifyingKeys);
         }
         catch (e) {
             console.warn("The execution was not found in the response, cannot verify the execution");
@@ -2675,7 +3268,9 @@ class ProgramManager {
     // Internal utility function for getting a credits.aleo record
     async getCreditsRecord(amount, nonces, record, params) {
         try {
-            return record instanceof RecordPlaintext ? record : RecordPlaintext.fromString(record);
+            return record instanceof RecordPlaintext
+                ? record
+                : RecordPlaintext.fromString(record);
         }
         catch (e) {
             try {
@@ -2694,9 +3289,10 @@ function requiresAmountRecord(transferType) {
 }
 // Validate the transfer type
 function validateTransferType(transferType) {
-    return VALID_TRANSFER_TYPES.has(transferType) ? transferType :
-        logAndThrow(`Invalid transfer type '${transferType}'. Valid transfer types are 'private', 'privateToPublic', 'public', and 'publicToPrivate'.`);
+    return VALID_TRANSFER_TYPES.has(transferType)
+        ? transferType
+        : logAndThrow(`Invalid transfer type '${transferType}'. Valid transfer types are 'private', 'privateToPublic', 'public', and 'publicToPrivate'.`);
 }
 
 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-D0WpABBc.js.map
+//# sourceMappingURL=program-manager-C1m8QHkg.js.map