@provablehq/sdk 0.8.8 → 0.9.1

package/dist/testnet/{program-manager-BuK9g9xJ.js → program-manager-BTHjM8b7.js}

@@ -1,5 +1,38 @@
 import { PrivateKey, RecordCiphertext, Program, Plaintext, Address, Transaction, Metadata, VerifyingKey, ProvingKey, ProgramManager as ProgramManager$1, RecordPlaintext, verifyFunctionExecution } from '@provablehq/wasm/testnet.js';
 
+function detectBrowser() {
+    const userAgent = navigator.userAgent;
+    if (/chrome|crios|crmo/i.test(userAgent) && !/edge|edg|opr/i.test(userAgent)) {
+        return "chrome";
+    }
+    else if (/firefox|fxios/i.test(userAgent)) {
+        return "firefox";
+    }
+    else if (/safari/i.test(userAgent) && !/chrome|crios|crmo|android/i.test(userAgent)) {
+        return "safari";
+    }
+    else if (/edg/i.test(userAgent)) {
+        return "edge";
+    }
+    else if (/opr\//i.test(userAgent)) {
+        return "opera";
+    }
+    else {
+        return "browser";
+    }
+}
+function environment() {
+    if ((typeof process !== 'undefined') &&
+        (process.release?.name === 'node')) {
+        return 'node';
+    }
+    else if (typeof window !== 'undefined') {
+        return detectBrowser();
+    }
+    else {
+        return 'unknown';
+    }
+}
 function logAndThrow(message) {
     console.error(message);
     throw new Error(message);
@@ -30,6 +63,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
@@ -48,15 +112,20 @@ class AleoNetworkClient {
     host;
     headers;
     account;
+    ctx;
+    network;
     constructor(host, options) {
         this.host = host + "/testnet";
+        this.network = "testnet";
+        this.ctx = {};
         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.8",
+                "X-Aleo-SDK-Version": "0.9.1",
+                "X-Aleo-environment": environment(),
             };
         }
     }
@@ -101,6 +170,41 @@ class AleoNetworkClient {
     setHost(host) {
         this.host = host + "/testnet";
     }
+    /**
+     * 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.
      *
@@ -108,7 +212,8 @@ class AleoNetworkClient {
      */
     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}`);
@@ -124,15 +229,31 @@ class AleoNetworkClient {
      */
     async fetchRaw(url = "/") {
         try {
-            const response = await get(this.host + url, {
-                headers: this.headers
+            const ctx = { ...this.ctx };
+            return await retryWithBackoff(async () => {
+                const response = await get(this.host + url, {
+                    headers: {
+                        ...this.headers,
+                        ...ctx,
+                    },
+                });
+                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.
      *
@@ -190,7 +311,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.");
@@ -241,8 +365,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")) {
@@ -250,7 +378,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") {
@@ -271,7 +400,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) {
@@ -282,37 +411,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) { }
                                                 }
                                             }
                                         }
@@ -325,7 +464,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) {
@@ -368,7 +510,16 @@ class AleoNetworkClient {
      * const records = networkClient.findUnspentRecords(startHeight, undefined, ["credits.aleo"], undefined, maxMicrocredits);
      */
     async findUnspentRecords(startHeight, endHeight, programs, amounts, maxMicrocredits, nonces, privateKey) {
-        return await this.findRecords(startHeight, endHeight, true, programs, amounts, maxMicrocredits, nonces, privateKey);
+        try {
+            this.ctx = { "X-ALEO-METHOD": "findUnspentRecords" };
+            return await this.findRecords(startHeight, endHeight, true, programs, amounts, maxMicrocredits, nonces, privateKey);
+        }
+        catch (error) {
+            throw new Error("Error finding unspent records: " + error);
+        }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the contents of the block at the specified block height.
@@ -381,12 +532,16 @@ class AleoNetworkClient {
      */
     async getBlock(blockHeight) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getBlock" };
             const block = await this.fetchData("/block/" + blockHeight);
             return block;
         }
         catch (error) {
             throw new Error(`Error fetching block ${blockHeight}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the contents of the block with the specified hash.
@@ -402,12 +557,16 @@ class AleoNetworkClient {
      */
     async getBlockByHash(blockHash) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getBlockByHash" };
             const block = await this.fetchData(`/block/${blockHash}`);
             return block;
         }
         catch (error) {
             throw new Error(`Error fetching block ${blockHash}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns a range of blocks between the specified block heights. A maximum of 50 blocks can be fetched at a time.
@@ -431,11 +590,15 @@ class AleoNetworkClient {
      */
     async getBlockRange(start, end) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getBlockRange" };
             return await this.fetchData("/blocks?start=" + start + "&end=" + end);
         }
         catch (error) {
             throw new Error(`Error fetching blocks between ${start} and ${end}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the deployment transaction id associated with the specified program.
@@ -457,16 +620,20 @@ class AleoNetworkClient {
      * const verifyingKeys = transaction.verifyingKeys();
      */
     async getDeploymentTransactionIDForProgram(program) {
+        this.ctx = { "X-ALEO-METHOD": "getDeploymentTransactionIDForProgram" };
         if (program instanceof Program) {
             program = program.id();
         }
         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}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the deployment transaction associated with a specified program as a JSON object.
@@ -490,12 +657,16 @@ class AleoNetworkClient {
             program = program.id();
         }
         try {
-            const transaction_id = await this.getDeploymentTransactionIDForProgram(program);
+            this.ctx = { "X-ALEO-METHOD": "getDeploymentTransactionForProgram" };
+            const transaction_id = (await this.getDeploymentTransactionIDForProgram(program));
             return await this.getTransaction(transaction_id);
         }
         catch (error) {
             throw new Error(`Error fetching deployment transaction for program ${program}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the deployment transaction associated with a specified program as a wasm object.
@@ -518,12 +689,16 @@ class AleoNetworkClient {
      */
     async getDeploymentTransactionObjectForProgram(program) {
         try {
-            const transaction_id = await this.getDeploymentTransactionIDForProgram(program);
+            this.ctx = { "X-ALEO-METHOD": "getDeploymentTransactionObjectForProgram" };
+            const transaction_id = (await this.getDeploymentTransactionIDForProgram(program));
             return await this.getTransactionObject(transaction_id);
         }
         catch (error) {
             throw new Error(`Error fetching deployment transaction for program ${program}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the contents of the latest block as JSON.
@@ -540,11 +715,15 @@ class AleoNetworkClient {
      */
     async getLatestBlock() {
         try {
-            return await this.fetchData("/block/latest");
+            this.ctx = { "X-ALEO-METHOD": "getLatestBlock" };
+            return (await this.fetchData("/block/latest"));
         }
         catch (error) {
             throw new Error(`Error fetching latest block: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the latest committee.
@@ -563,11 +742,15 @@ class AleoNetworkClient {
      */
     async getLatestCommittee() {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getLatestCommittee" };
             return await this.fetchData("/committee/latest");
         }
         catch (error) {
             throw new Error(`Error fetching latest committee: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the committee at the specified block height.
@@ -587,11 +770,15 @@ class AleoNetworkClient {
      */
     async getCommitteeByBlockHeight(blockHeight) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getCommitteeByBlockHeight" };
             return await this.fetchData(`/committee/${blockHeight}`);
         }
         catch (error) {
             throw new Error(`Error fetching committee at height ${blockHeight}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the latest block height.
@@ -608,11 +795,15 @@ class AleoNetworkClient {
      */
     async getLatestHeight() {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getLatestHeight" };
             return Number(await this.fetchData("/block/height/latest"));
         }
         catch (error) {
             throw new Error(`Error fetching latest height: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the latest block hash.
@@ -630,11 +821,15 @@ class AleoNetworkClient {
      */
     async getLatestBlockHash() {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getLatestBlockHash" };
             return String(await this.fetchData("/block/hash/latest"));
         }
         catch (error) {
             throw new Error(`Error fetching latest hash: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the source code of a program given a program ID.
@@ -654,11 +849,15 @@ class AleoNetworkClient {
      */
     async getProgram(programId) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getProgram" };
             return await this.fetchData("/program/" + programId);
         }
         catch (error) {
             throw new Error(`Error fetching program ${programId}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns a program object from a program ID or program source code.
@@ -684,16 +883,20 @@ class AleoNetworkClient {
      */
     async getProgramObject(inputProgram) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getProgramObject" };
             return Program.fromString(inputProgram);
         }
         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}`);
             }
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      *  Returns an object containing the source code of a program and the source code of all programs it imports
@@ -727,17 +930,20 @@ class AleoNetworkClient {
      */
     async getProgramImports(inputProgram) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getProgramImports" };
             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];
@@ -751,6 +957,9 @@ class AleoNetworkClient {
         catch (error) {
             logAndThrow("Error fetching program imports: " + error.message);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Get a list of the program names that a program imports.
@@ -770,12 +979,18 @@ class AleoNetworkClient {
      */
     async getProgramImportNames(inputProgram) {
         try {
-            const program = inputProgram instanceof Program ? inputProgram : (await this.getProgramObject(inputProgram));
+            this.ctx = { "X-ALEO-METHOD": "getProgramImportNames" };
+            const program = inputProgram instanceof Program
+                ? inputProgram
+                : await this.getProgramObject(inputProgram);
             return program.getImports();
         }
         catch (error) {
             throw new Error(`Error fetching imports for program ${inputProgram instanceof Program ? inputProgram.id() : inputProgram}: ${error.message}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the names of the mappings of a program.
@@ -803,11 +1018,15 @@ class AleoNetworkClient {
      */
     async getProgramMappingNames(programId) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getProgramMappingNames" };
             return await this.fetchData(`/program/${programId}/mappings`);
         }
         catch (error) {
             throw new Error(`Error fetching mappings for program ${programId} - ensure the program exists on chain before trying again`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the value of a program's mapping for a specific key.
@@ -830,12 +1049,16 @@ class AleoNetworkClient {
      */
     async getProgramMappingValue(programId, mappingName, key) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getProgramMappingValue" };
             const keyString = key instanceof Plaintext ? key.toString() : key;
             return await this.fetchData(`/program/${programId}/mapping/${mappingName}/${keyString}`);
         }
         catch (error) {
             throw new Error(`Error fetching value for key '${key}' in mapping '${mappingName}' in program '${programId}' - ensure the mapping exists and the key is correct`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * 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.
@@ -873,6 +1096,7 @@ class AleoNetworkClient {
      */
     async getProgramMappingPlaintext(programId, mappingName, key) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getProgramMappingPlaintext" };
             const keyString = key instanceof Plaintext ? key.toString() : key;
             const value = await this.fetchRaw(`/program/${programId}/mapping/${mappingName}/${keyString}`);
             return Plaintext.fromString(JSON.parse(value));
@@ -880,6 +1104,9 @@ class AleoNetworkClient {
         catch (error) {
             throw new Error("Failed to fetch mapping value." + error);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the public balance of an address from the account mapping in credits.aleo
@@ -901,13 +1128,17 @@ class AleoNetworkClient {
      */
     async getPublicBalance(address) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getPublicBalance" };
             const addressString = address instanceof Address ? address.to_string() : address;
-            const balanceStr = await this.getProgramMappingValue('credits.aleo', 'account', addressString);
+            const balanceStr = await this.getProgramMappingValue("credits.aleo", "account", addressString);
             return balanceStr ? parseInt(balanceStr) : 0;
         }
         catch (error) {
             throw new Error(`Error fetching public balance for ${address}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the latest state/merkle root of the Aleo blockchain.
@@ -925,11 +1156,15 @@ class AleoNetworkClient {
      */
     async getStateRoot() {
         try {
-            return await this.fetchData('/stateRoot/latest');
+            this.ctx = { "X-ALEO-METHOD": "getStateRoot" };
+            return await this.fetchData("/stateRoot/latest");
         }
         catch (error) {
             throw new Error(`Error fetching latest state root: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns a transaction by its unique identifier.
@@ -947,11 +1182,15 @@ class AleoNetworkClient {
      */
     async getTransaction(transactionId) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getTransaction" };
             return await this.fetchData("/transaction/" + transactionId);
         }
         catch (error) {
             throw new Error(`Error fetching transaction ${transactionId}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns a confirmed transaction by its unique identifier.
@@ -970,11 +1209,15 @@ class AleoNetworkClient {
      */
     async getConfirmedTransaction(transactionId) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getConfirmedTransaction" };
             return await this.fetchData(`/transaction/confirmed/${transactionId}`);
         }
         catch (error) {
             throw new Error(`Error fetching confirmed transaction ${transactionId}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns a transaction as a wasm object. Getting a transaction of this type will allow the ability for the inputs,
@@ -1003,12 +1246,16 @@ class AleoNetworkClient {
      */
     async getTransactionObject(transactionId) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getTransactionObject" };
             const transaction = await this.fetchRaw("/transaction/" + transactionId);
             return Transaction.fromString(transaction);
         }
         catch (error) {
             throw new Error(`Error fetching transaction object ${transactionId}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the transactions present at the specified block height.
@@ -1026,11 +1273,15 @@ class AleoNetworkClient {
      */
     async getTransactions(blockHeight) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getTransactions" };
             return await this.fetchData("/block/" + blockHeight.toString() + "/transactions");
         }
         catch (error) {
             throw new Error(`Error fetching transactions: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the confirmed transactions present in the block with the specified block hash.
@@ -1048,6 +1299,7 @@ class AleoNetworkClient {
      */
     async getTransactionsByBlockHash(blockHash) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getTransactionsByBlockHash" };
             const block = await this.fetchData(`/block/${blockHash}`);
             const height = block.header.metadata.height;
             return await this.getTransactions(Number(height));
@@ -1055,6 +1307,9 @@ class AleoNetworkClient {
         catch (error) {
             throw new Error(`Error fetching transactions for block ${blockHash}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the transactions in the memory pool. This method requires access to a validator's REST API.
@@ -1072,11 +1327,15 @@ class AleoNetworkClient {
      */
     async getTransactionsInMempool() {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getTransactionsInMempool" };
             return await this.fetchData("/memoryPool/transactions");
         }
         catch (error) {
             throw new Error(`Error fetching transactions from mempool: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Returns the transition ID of the transition corresponding to the ID of the input or output.
@@ -1088,11 +1347,15 @@ class AleoNetworkClient {
      */
     async getTransitionId(inputOrOutputID) {
         try {
+            this.ctx = { "X-ALEO-METHOD": "getTransitionId" };
             return await this.fetchData("/find/transitionID/" + inputOrOutputID);
         }
         catch (error) {
             throw new Error(`Error fetching transition ID for input/output ${inputOrOutputID}: ${error}`);
         }
+        finally {
+            this.ctx = {};
+        }
     }
     /**
      * Submit an execute or deployment transaction to the Aleo network.
@@ -1101,14 +1364,16 @@ class AleoNetworkClient {
      * @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 transactionString = transaction instanceof Transaction
+            ? transaction.toString()
+            : transaction;
         try {
-            const response = await post(this.host + "/transaction/broadcast", {
-                body: transaction_string,
-                headers: Object.assign({}, this.headers, {
+            const response = await retryWithBackoff(() => this._sendPost(this.host + "/transaction/broadcast", {
+                body: transactionString,
+                headers: Object.assign({}, { ...this.headers, "X-ALEO-METHOD": "submitTransaction" }, {
                     "Content-Type": "application/json",
                 }),
-            });
+            }));
             try {
                 const text = await response.text();
                 return parseJSON(text);
@@ -1129,22 +1394,22 @@ class AleoNetworkClient {
      */
     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, {
+                headers: Object.assign({}, { ...this.headers, "X-ALEO-METHOD": "submitSolution" }, {
                     "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}`);
         }
     }
     /**
@@ -1174,23 +1439,55 @@ class AleoNetworkClient {
      * // 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,
+                            "X-ALEO-METHOD": "waitForTransactionConfirmation",
+                        },
+                    });
+                    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);
         });
@@ -1709,9 +2006,9 @@ 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) {
+    constructor(host, keyProvider, recordProvider, networkClientOptions) {
         this.host = host ? host : "https://api.explorer.provable.com/v1";
-        this.networkClient = new AleoNetworkClient(this.host);
+        this.networkClient = new AleoNetworkClient(this.host, networkClientOptions);
         this.keyProvider = keyProvider ? keyProvider : new AleoKeyProvider();
         this.recordProvider = recordProvider;
     }
@@ -1757,6 +2054,41 @@ 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.
      *
@@ -3018,18 +3350,44 @@ class ProgramManager {
         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 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");
@@ -3097,4 +3455,4 @@ function validateTransferType(transferType) {
 }
 
 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-BuK9g9xJ.js.map
+//# sourceMappingURL=program-manager-BTHjM8b7.js.map