@provablehq/sdk 0.9.2 → 0.9.4-offline-rc

package/dist/mainnet/program-manager-B-18sj9m.js

@@ -1,3458 +0,0 @@
-import { PrivateKey, RecordCiphertext, Program, Plaintext, Address, Transaction, Metadata, VerifyingKey, ProvingKey, ProgramManager as ProgramManager$1, RecordPlaintext, verifyFunctionExecution } from '@provablehq/wasm/mainnet.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);
-}
-function parseJSON(json) {
-    function revive(key, value, context) {
-        if (Number.isInteger(value)) {
-            return BigInt(context.source);
-        }
-        else {
-            return value;
-        }
-    }
-    return JSON.parse(json, revive);
-}
-async function get(url, options) {
-    const response = await fetch(url, options);
-    if (!response.ok) {
-        throw new Error(response.status + " could not get URL " + url);
-    }
-    return response;
-}
-async function post(url, options) {
-    options.method = "POST";
-    const response = await fetch(url, options);
-    if (!response.ok) {
-        throw new Error(response.status + " could not post URL " + url);
-    }
-    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
- * allow users to query public information from the Aleo blockchain and submit transactions to the network.
- *
- * @param {string} host
- * @example
- * // 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://api.explorer.provable.com/v1", undefined, account);
- */
-class AleoNetworkClient {
-    host;
-    headers;
-    account;
-    ctx;
-    network;
-    constructor(host, options) {
-        this.host = host + "/mainnet";
-        this.network = "mainnet";
-        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.9.2",
-                "X-Aleo-environment": environment(),
-            };
-        }
-    }
-    /**
-     * Set an account to use in networkClient calls
-     *
-     * @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);
-     */
-    setAccount(account) {
-        this.account = account;
-    }
-    /**
-     * Return the Aleo account used in the networkClient
-     *
-     * @example
-     * const account = networkClient.getAccount();
-     */
-    getAccount() {
-        return this.account;
-    }
-    /**
-     * Set a new host for the networkClient
-     *
-     * @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 The URL to fetch data from.
-     */
-    async fetchData(url = "/") {
-        try {
-            const raw = await this.fetchRaw(url);
-            return parseJSON(raw);
-        }
-        catch (error) {
-            throw new Error(`Error fetching data: ${error}`);
-        }
-    }
-    /**
-     * Fetches data from the Aleo network and returns it as an unparsed string.
-     *
-     * This method should be used when it is desired to reconstitute data returned
-     * from the network into a WASM object.
-     *
-     * @param url
-     */
-    async fetchRaw(url = "/") {
-        try {
-            const ctx = { ...this.ctx };
-            return await retryWithBackoff(async () => {
-                const response = await get(this.host + url, {
-                    headers: {
-                        ...this.headers,
-                        ...ctx,
-                    },
-                });
-                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.
-     *
-     * @param {number} startHeight - The height at which to start searching for unspent records
-     * @param {number} endHeight - The height at which to stop searching for unspent records
-     * @param {boolean} unspent - Whether to search for unspent records only
-     * @param {string[]} programs - The program(s) to search for unspent records in
-     * @param {number[]} amounts - The amounts (in microcredits) to search for (eg. [100, 200, 3000])
-     * @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];
-     * const records = networkClient.findRecords(startHeight, undefined, true, ["credits.aleo"] amounts);
-     *
-     * // Find specific amounts with a maximum number of cumulative microcredits
-     * const maxMicrocredits = 100000;
-     * const records = networkClient.findRecords(startHeight, undefined, true, ["credits.aleo"] undefined, maxMicrocredits);
-     */
-    async findRecords(startHeight, endHeight, unspent = false, programs, amounts, maxMicrocredits, nonces, privateKey) {
-        nonces = nonces || [];
-        // Ensure start height is not negative
-        if (startHeight < 0) {
-            throw new Error("Start height must be greater than or equal to 0");
-        }
-        // Initialize search parameters
-        const records = new Array();
-        let start;
-        let end;
-        let resolvedPrivateKey;
-        let failures = 0;
-        let totalRecordValue = BigInt(0);
-        let latestHeight;
-        // Ensure a private key is present to find owned records
-        if (typeof privateKey === "undefined") {
-            if (typeof this.account === "undefined") {
-                throw new Error("Private key must be specified in an argument to findOwnedRecords or set in the AleoNetworkClient");
-            }
-            else {
-                resolvedPrivateKey = this.account._privateKey;
-            }
-        }
-        else {
-            try {
-                resolvedPrivateKey =
-                    privateKey instanceof PrivateKey
-                        ? privateKey
-                        : PrivateKey.from_string(privateKey);
-            }
-            catch (error) {
-                throw new Error("Error parsing private key provided.");
-            }
-        }
-        const viewKey = resolvedPrivateKey.to_view_key();
-        // Get the latest height to ensure the range being searched is valid
-        try {
-            const blockHeight = await this.getLatestHeight();
-            if (typeof blockHeight === "number") {
-                latestHeight = blockHeight;
-            }
-            else {
-                throw new Error(`Error fetching latest block height: Expected type 'number' got '${typeof blockHeight}'`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Error fetching latest block height: ${error}`);
-        }
-        // If no end height is specified or is greater than the latest height, set the end height to the latest height
-        if (typeof endHeight === "number" && endHeight <= latestHeight) {
-            end = endHeight;
-        }
-        else {
-            end = latestHeight;
-        }
-        // If the starting is greater than the ending height, return an error
-        if (startHeight > end) {
-            throw new Error("Start height must be less than or equal to end height.");
-        }
-        // Iterate through blocks in reverse order in chunks of 50
-        while (end > startHeight) {
-            start = end - 50;
-            if (start < startHeight) {
-                start = startHeight;
-            }
-            try {
-                // Get 50 blocks (or the difference between the start and end if less than 50)
-                const blocks = await this.getBlockRange(start, end);
-                end = start;
-                // Iterate through blocks to find unspent records
-                for (let i = 0; i < blocks.length; i++) {
-                    const block = blocks[i];
-                    const transactions = block.transactions;
-                    if (!(typeof transactions === "undefined")) {
-                        for (let j = 0; j < transactions.length; j++) {
-                            const confirmedTransaction = transactions[j];
-                            // Search for unspent records in execute transactions of credits.aleo
-                            if (confirmedTransaction.type == "execute") {
-                                const transaction = confirmedTransaction.transaction;
-                                if (transaction.execution &&
-                                    !(typeof transaction.execution
-                                        .transitions == "undefined")) {
-                                    for (let k = 0; k <
-                                        transaction.execution.transitions
-                                            .length; k++) {
-                                        const transition = transaction.execution.transitions[k];
-                                        // Only search for unspent records in the specified programs.
-                                        if (!(typeof programs === "undefined")) {
-                                            if (!programs.includes(transition.program)) {
-                                                continue;
-                                            }
-                                        }
-                                        if (!(typeof transition.outputs ==
-                                            "undefined")) {
-                                            for (let l = 0; l < transition.outputs.length; l++) {
-                                                const output = transition.outputs[l];
-                                                if (output.type === "record") {
-                                                    try {
-                                                        // Create a wasm record ciphertext object from the found output
-                                                        const record = RecordCiphertext.fromString(output.value);
-                                                        // Determine if the record is owned by the specified view key
-                                                        if (record.isOwner(viewKey)) {
-                                                            // Decrypt the record and get the serial number
-                                                            const recordPlaintext = record.decrypt(viewKey);
-                                                            // If the record has already been found, skip it
-                                                            const nonce = recordPlaintext.nonce();
-                                                            if (nonces.includes(nonce)) {
-                                                                continue;
-                                                            }
-                                                            if (unspent) {
-                                                                // Otherwise record the nonce that has been found
-                                                                const serialNumber = recordPlaintext.serialNumberString(resolvedPrivateKey, "credits.aleo", "credits");
-                                                                // Attempt to see if the serial number is spent
-                                                                try {
-                                                                    await retryWithBackoff(() => this.getTransitionId(serialNumber));
-                                                                    continue;
-                                                                }
-                                                                catch (error) {
-                                                                    console.log("Found unspent record!");
-                                                                }
-                                                            }
-                                                            // Add the record to the list of records if the user did not specify amounts.
-                                                            if (!amounts) {
-                                                                records.push(recordPlaintext);
-                                                                // If the user specified a maximum number of microcredits, check if the search has found enough
-                                                                if (typeof maxMicrocredits ===
-                                                                    "number") {
-                                                                    totalRecordValue +=
-                                                                        recordPlaintext.microcredits();
-                                                                    // Exit if the search has found the amount specified
-                                                                    if (totalRecordValue >=
-                                                                        BigInt(maxMicrocredits)) {
-                                                                        return records;
-                                                                    }
-                                                                }
-                                                            }
-                                                            // If the user specified a list of amounts, check if the search has found them
-                                                            if (!(typeof amounts ===
-                                                                "undefined") &&
-                                                                amounts.length >
-                                                                    0) {
-                                                                let amounts_found = 0;
-                                                                if (recordPlaintext.microcredits() >
-                                                                    amounts[amounts_found]) {
-                                                                    amounts_found += 1;
-                                                                    records.push(recordPlaintext);
-                                                                    // If the user specified a maximum number of microcredits, check if the search has found enough
-                                                                    if (typeof maxMicrocredits ===
-                                                                        "number") {
-                                                                        totalRecordValue +=
-                                                                            recordPlaintext.microcredits();
-                                                                        // Exit if the search has found the amount specified
-                                                                        if (totalRecordValue >=
-                                                                            BigInt(maxMicrocredits)) {
-                                                                            return records;
-                                                                        }
-                                                                    }
-                                                                    if (records.length >=
-                                                                        amounts.length) {
-                                                                        return records;
-                                                                    }
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                    catch (error) { }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            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: ", error);
-                failures += 1;
-                if (failures > 10) {
-                    console.warn("10 failures fetching records reached. Returning records fetched so far");
-                    return records;
-                }
-            }
-        }
-        return records;
-    }
-    /**
-     * Attempts to find unspent records in the Aleo blockchain.
-     *
-     * @param {number} startHeight - The height at which to start searching for unspent records
-     * @param {number} endHeight - The height at which to stop searching for unspent records
-     * @param {string[]} programs - The program(s) to search for unspent records in
-     * @param {number[]} amounts - The amounts (in microcredits) to search for (eg. [100, 200, 3000])
-     * @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;
-     * const amounts = [600000, 1000000];
-     * const records = networkClient.findUnspentRecords(startHeight, endHeight, ["credits.aleo"], amounts);
-     *
-     * // Find specific amounts with a maximum number of cumulative microcredits
-     * const maxMicrocredits = 100000;
-     * const records = networkClient.findUnspentRecords(startHeight, undefined, ["credits.aleo"], undefined, maxMicrocredits);
-     */
-    async findUnspentRecords(startHeight, endHeight, 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.
-     *
-     * @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);
-     */
-    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.
-     *
-     * @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) {
-        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.
-     *
-     * @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
-     *
-     * @example
-     * 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 {
-            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.
-     *
-     * @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) {
-        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('"', "");
-        }
-        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.
-     *
-     * @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");
-     *
-     * // 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 {
-            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.
-     *
-     * @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 {
-            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.
-     *
-     * @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 {
-            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.
-     *
-     * @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 {
-            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.
-     *
-     * @param {number} blockHeight - The height of the block to fetch the committee for
-     * @returns {Promise<object>} A javascript object containing the 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 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 {
-            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.
-     *
-     * @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() {
-        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.
-     *
-     * @returns {Promise<string>} The latest block hash.
-     *
-     * @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 latest block hash.
-     * const latestHash = networkClient.getLatestBlockHash();
-     */
-    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.
-     *
-     * @param {string} programId The program ID of a program deployed to the Aleo Network
-     * @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);
-     */
-    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.
-     *
-     * @param {string} inputProgram The program ID or program source code of a program deployed to the Aleo Network
-     * @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"
-     *
-     * // Get program object from program ID or program source code
-     * const programObjectFromID = await networkClient.getProgramObject(programID);
-     * const programObjectFromSource = await networkClient.getProgramObject(programSource);
-     *
-     * // Both program objects should be equal
-     * assert(programObjectFromID.to_string() === programObjectFromSource.to_string());
-     */
-    async getProgramObject(inputProgram) {
-        try {
-            this.ctx = { "X-ALEO-METHOD": "getProgramObject" };
-            return Program.fromString(inputProgram);
-        }
-        catch (error) {
-            try {
-                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
-     *
-     * @param {Program | string} inputProgram The program ID or program source code of a program deployed to the Aleo Network
-     * @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);
-     *
-     * // Using the program source code
-     * programImports = await networkClient.getProgramImports(double_test_source);
-     * assert.deepStrictEqual(programImports, expectedImports);
-     *
-     * // Using the program object
-     * programImports = await networkClient.getProgramImports(double_test);
-     * assert.deepStrictEqual(programImports, expectedImports);
-     */
-    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);
-            // 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));
-                    for (const key in nestedImports) {
-                        if (!imports.hasOwnProperty(key)) {
-                            imports[key] = nestedImports[key];
-                        }
-                    }
-                    imports[import_id] = programSource;
-                }
-            }
-            return imports;
-        }
-        catch (error) {
-            logAndThrow("Error fetching program imports: " + error.message);
-        }
-        finally {
-            this.ctx = {};
-        }
-    }
-    /**
-     * Get a list of the program names that a program imports.
-     *
-     * @param {Program | string} inputProgram - The program id or program source code to get the imports of
-     * @returns {string[]} - The list of program names that the program imports
-     *
-     * @example
-     * 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 {
-            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.
-     *
-     * @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",
-     *   "delegated",
-     *   "metadata",
-     *   "bonded",
-     *   "unbonding",
-     *   "account",
-     *   "withdraw"
-     * ];
-     * assert.deepStrictEqual(mappings, expectedMappings);
-     */
-    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.
-     *
-     * @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 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(mappingValue === expectedValue);
-     */
-    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.
-     *
-     * @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");
-     *
-     * // Get the two members of the object individually.
-     * const validator = unbondedState.getMember("validator");
-     * const microcredits = unbondedState.getMember("microcredits");
-     *
-     * // Ensure the expected values are correct.
-     * assert.equal(validator, "aleo1u6940v5m0fzud859xx2c9tj2gjg6m5qrd28n636e6fdd2akvfcgqs34mfd");
-     * assert.equal(microcredits, BigInt("9007199254740991"));
-     *
-     * // Get a JS object representation of the unbonded state.
-     * const unbondedStateObject = unbondedState.toObject();
-     *
-     * const expectedState = {
-     *     validator: "aleo1u6940v5m0fzud859xx2c9tj2gjg6m5qrd28n636e6fdd2akvfcgqs34mfd",
-     *     microcredits: BigInt(9007199254740991)
-     * };
-     * assert.equal(unbondedState, expectedState);
-     */
-    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));
-        }
-        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
-     *
-     * @param {Address | string} address A string or wasm object representing an address.
-     * @returns {Promise<number>} The public balance of the address in microcredits.
-     *
-     * @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 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 {
-            this.ctx = { "X-ALEO-METHOD": "getPublicBalance" };
-            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) {
-            throw new Error(`Error fetching public balance for ${address}: ${error}`);
-        }
-        finally {
-            this.ctx = {};
-        }
-    }
-    /**
-     * 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 {
-            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.
-     *
-     * @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) {
-        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.
-     *
-     * @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 {
-            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,
-     * 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 transactionInputs = transactionObject.inputs(true);
-     *
-     * // Get the transaction outputs as a JS object.
-     * const transactionOutputs = transactionObject.outputs(true);
-     *
-     * // Get any records generated in transitions in the transaction as a JS object.
-     * const records = transactionObject.records();
-     *
-     * // Get the transaction type.
-     * const transactionType = transactionObject.transactionType();
-     * assert.equal(transactionType, "Execute");
-     *
-     * // Get a JS representation of all inputs, outputs, and transaction metadata.
-     * const transactionSummary = transactionObject.summary();
-     */
-    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.
-     *
-     * @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) {
-        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.
-     *
-     * @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
-     * 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 {
-            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));
-        }
-        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.
-     *
-     * @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() {
-        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.
-     * @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");
-     */
-    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.
-     *
-     * @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 transactionString = transaction instanceof Transaction
-            ? transaction.toString()
-            : transaction;
-        try {
-            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);
-            }
-            catch (error) {
-                throw new Error(`Error posting transaction. Aleo network response: ${error.message}`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Error posting transaction: No response received: ${error.message}`);
-        }
-    }
-    /**
-     * Submit a solution to the Aleo 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 retryWithBackoff(() => post(this.host + "/solution/broadcast", {
-                body: solution,
-                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 solution. Aleo network response: ${error.message}`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Error posting solution: No response received: ${error.message}`);
-        }
-    }
-    /**
-     * 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));
-     *
-     * // 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, 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 {
-                    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);
-                        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 (err) {
-                    console.error("Polling error:", err);
-                }
-            }, checkInterval);
-        });
-    }
-}
-
-const KEY_STORE = Metadata.baseUrl();
-function convert(metadata) {
-    // This looks up the method name in VerifyingKey
-    const verifyingKey = VerifyingKey[metadata.verifyingKey];
-    if (!verifyingKey) {
-        throw new Error("Invalid method name: " + metadata.verifyingKey);
-    }
-    return {
-        name: metadata.name,
-        locator: metadata.locator,
-        prover: metadata.prover,
-        verifier: metadata.verifier,
-        verifyingKey,
-    };
-}
-const CREDITS_PROGRAM_KEYS = {
-    bond_public: convert(Metadata.bond_public()),
-    bond_validator: convert(Metadata.bond_validator()),
-    claim_unbond_public: convert(Metadata.claim_unbond_public()),
-    fee_private: convert(Metadata.fee_private()),
-    fee_public: convert(Metadata.fee_public()),
-    inclusion: convert(Metadata.inclusion()),
-    join: convert(Metadata.join()),
-    set_validator_state: convert(Metadata.set_validator_state()),
-    split: convert(Metadata.split()),
-    transfer_private: convert(Metadata.transfer_private()),
-    transfer_private_to_public: convert(Metadata.transfer_private_to_public()),
-    transfer_public: convert(Metadata.transfer_public()),
-    transfer_public_as_signer: convert(Metadata.transfer_public_as_signer()),
-    transfer_public_to_private: convert(Metadata.transfer_public_to_private()),
-    unbond_public: convert(Metadata.unbond_public()),
-    getKey: function (key) {
-        if (this.hasOwnProperty(key)) {
-            return this[key];
-        }
-        else {
-            throw new Error(`Key "${key}" not found.`);
-        }
-    }
-};
-const PRIVATE_TRANSFER_TYPES = new Set([
-    "transfer_private",
-    "private",
-    "transferPrivate",
-    "transfer_private_to_public",
-    "privateToPublic",
-    "transferPrivateToPublic",
-]);
-const VALID_TRANSFER_TYPES = new Set([
-    "transfer_private",
-    "private",
-    "transferPrivate",
-    "transfer_private_to_public",
-    "privateToPublic",
-    "transferPrivateToPublic",
-    "transfer_public",
-    "transfer_public_as_signer",
-    "public",
-    "public_as_signer",
-    "transferPublic",
-    "transferPublicAsSigner",
-    "transfer_public_to_private",
-    "publicToPrivate",
-    "publicAsSigner",
-    "transferPublicToPrivate",
-]);
-const PRIVATE_TRANSFER = new Set([
-    "private",
-    "transfer_private",
-    "transferPrivate",
-]);
-const PRIVATE_TO_PUBLIC_TRANSFER = new Set([
-    "private_to_public",
-    "privateToPublic",
-    "transfer_private_to_public",
-    "transferPrivateToPublic",
-]);
-const PUBLIC_TRANSFER = new Set([
-    "public",
-    "transfer_public",
-    "transferPublic",
-]);
-const PUBLIC_TRANSFER_AS_SIGNER = new Set([
-    "public_as_signer",
-    "transfer_public_as_signer",
-    "transferPublicAsSigner",
-]);
-const PUBLIC_TO_PRIVATE_TRANSFER = new Set([
-    "public_to_private",
-    "publicToPrivate",
-    "transfer_public_to_private",
-    "transferPublicToPrivate",
-]);
-
-/**
- * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
- * verifierUri to fetch keys via HTTP from a remote resource as well as a unique cacheKey to store the keys in memory.
- */
-class AleoKeyProviderParams {
-    name;
-    proverUri;
-    verifierUri;
-    cacheKey;
-    /**
-     * Create a new AleoKeyProviderParams object which implements the KeySearchParams interface. Users can optionally
-     * specify a url for the proverUri & verifierUri to fetch keys via HTTP from a remote resource as well as a unique
-     * cacheKey to store the keys in memory for future use. If no proverUri or verifierUri is specified, a cachekey must
-     * be provided.
-     *
-     * @param { AleoKeyProviderInitParams } params - Optional search parameters
-     */
-    constructor(params) {
-        this.proverUri = params.proverUri;
-        this.verifierUri = params.verifierUri;
-        this.cacheKey = params.cacheKey;
-        this.name = params.name;
-    }
-}
-/**
- * AleoKeyProvider class. Implements the KeyProvider interface. Enables the retrieval of Aleo program proving and
- * verifying keys for the credits.aleo program over http from official Aleo sources and storing and retrieving function
- * keys from a local memory cache.
- */
-class AleoKeyProvider {
-    cache;
-    cacheOption;
-    keyUris;
-    async fetchBytes(url = "/") {
-        try {
-            const response = await get(url);
-            const data = await response.arrayBuffer();
-            return new Uint8Array(data);
-        }
-        catch (error) {
-            throw new Error("Error fetching data." + error.message);
-        }
-    }
-    constructor() {
-        this.keyUris = KEY_STORE;
-        this.cache = new Map();
-        this.cacheOption = false;
-    }
-    /**
-     * Use local memory to store keys
-     *
-     * @param {boolean} useCache whether to store keys in local memory
-     */
-    useCache(useCache) {
-        this.cacheOption = useCache;
-    }
-    /**
-     * Clear the key cache
-     */
-    clearCache() {
-        this.cache.clear();
-    }
-    /**
-     * Cache a set of keys. This will overwrite any existing keys with the same keyId. The user can check if a keyId
-     * exists in the cache using the containsKeys method prior to calling this method if overwriting is not desired.
-     *
-     * @param {string} keyId access key for the cache
-     * @param {FunctionKeyPair} keys keys to cache
-     */
-    cacheKeys(keyId, keys) {
-        const [provingKey, verifyingKey] = keys;
-        this.cache.set(keyId, [provingKey.toBytes(), verifyingKey.toBytes()]);
-    }
-    /**
-     * Determine if a keyId exists in the cache
-     *
-     * @param {string} keyId keyId of a proving and verifying key pair
-     * @returns {boolean} true if the keyId exists in the cache, false otherwise
-     */
-    containsKeys(keyId) {
-        return this.cache.has(keyId);
-    }
-    /**
-     * Delete a set of keys from the cache
-     *
-     * @param {string} keyId keyId of a proving and verifying key pair to delete from memory
-     * @returns {boolean} true if the keyId exists in the cache and was deleted, false if the key did not exist
-     */
-    deleteKeys(keyId) {
-        return this.cache.delete(keyId);
-    }
-    /**
-     * Get a set of keys from the cache
-     * @param keyId keyId of a proving and verifying key pair
-     *
-     * @returns {FunctionKeyPair} Proving and verifying keys for the specified program
-     */
-    getKeys(keyId) {
-        console.debug(`Checking if key exists in cache. KeyId: ${keyId}`);
-        if (this.cache.has(keyId)) {
-            const [provingKeyBytes, verifyingKeyBytes] = this.cache.get(keyId);
-            return [ProvingKey.fromBytes(provingKeyBytes), VerifyingKey.fromBytes(verifyingKeyBytes)];
-        }
-        else {
-            throw new Error("Key not found in cache.");
-        }
-    }
-    /**
-     * Get arbitrary function keys from a provider
-     *
-     * @param {KeySearchParams} params parameters for the key search in form of: {proverUri: string, verifierUri: string, cacheKey: string}
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the specified program
-     *
-     * @example
-     * // Create a new object which implements the KeyProvider interface
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
-     *
-     * // Keys can also be fetched manually using the key provider
-     * const keySearchParams = { "cacheKey": "myProgram:myFunction" };
-     * const [transferPrivateProvingKey, transferPrivateVerifyingKey] = await keyProvider.functionKeys(keySearchParams);
-     */
-    async functionKeys(params) {
-        if (params) {
-            let proverUrl;
-            let verifierUrl;
-            let cacheKey;
-            if ("name" in params && typeof params["name"] == "string") {
-                let key = CREDITS_PROGRAM_KEYS.getKey(params["name"]);
-                return this.fetchCreditsKeys(key);
-            }
-            if ("proverUri" in params && typeof params["proverUri"] == "string") {
-                proverUrl = params["proverUri"];
-            }
-            if ("verifierUri" in params && typeof params["verifierUri"] == "string") {
-                verifierUrl = params["verifierUri"];
-            }
-            if ("cacheKey" in params && typeof params["cacheKey"] == "string") {
-                cacheKey = params["cacheKey"];
-            }
-            if (proverUrl && verifierUrl) {
-                return await this.fetchRemoteKeys(proverUrl, verifierUrl, cacheKey);
-            }
-            if (cacheKey) {
-                return this.getKeys(cacheKey);
-            }
-        }
-        throw new Error("Invalid parameters provided, must provide either a cacheKey and/or a proverUrl and a verifierUrl");
-    }
-    /**
-     * Returns the proving and verifying keys for a specified program from a specified url.
-     *
-     * @param {string} verifierUrl Url of the proving key
-     * @param {string} proverUrl Url the verifying key
-     * @param {string} cacheKey Key to store the keys in the cache
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the specified program
-     *
-     * @example
-     * // Create a new AleoKeyProvider object
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
-     *
-     * // Keys can also be fetched manually
-     * const [transferPrivateProvingKey, transferPrivateVerifyingKey] = await keyProvider.fetchKeys(
-     *     CREDITS_PROGRAM_KEYS.transfer_private.prover,
-     *     CREDITS_PROGRAM_KEYS.transfer_private.verifier,
-     * );
-     */
-    async fetchRemoteKeys(proverUrl, verifierUrl, cacheKey) {
-        try {
-            // If cache is enabled, check if the keys have already been fetched and return them if they have
-            if (this.cacheOption) {
-                if (!cacheKey) {
-                    cacheKey = proverUrl;
-                }
-                const value = this.cache.get(cacheKey);
-                if (typeof value !== "undefined") {
-                    return [ProvingKey.fromBytes(value[0]), VerifyingKey.fromBytes(value[1])];
-                }
-                else {
-                    console.debug("Fetching proving keys from url " + proverUrl);
-                    const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
-                    console.debug("Fetching verifying keys " + verifierUrl);
-                    const verifyingKey = (await this.getVerifyingKey(verifierUrl));
-                    this.cache.set(cacheKey, [provingKey.toBytes(), verifyingKey.toBytes()]);
-                    return [provingKey, verifyingKey];
-                }
-            }
-            else {
-                // If cache is disabled, fetch the keys and return them
-                const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
-                const verifyingKey = (await this.getVerifyingKey(verifierUrl));
-                return [provingKey, verifyingKey];
-            }
-        }
-        catch (error) {
-            throw new Error(`Error: ${error.message} fetching fee proving and verifying keys from ${proverUrl} and ${verifierUrl}.`);
-        }
-    }
-    /***
-     * Fetches the proving key from a remote source.
-     *
-     * @param proverUrl
-     * @param cacheKey
-     *
-     * @returns {Promise<ProvingKey>} Proving key for the specified program
-     */
-    async fetchProvingKey(proverUrl, cacheKey) {
-        try {
-            // If cache is enabled, check if the keys have already been fetched and return them if they have
-            if (this.cacheOption) {
-                if (!cacheKey) {
-                    cacheKey = proverUrl;
-                }
-                const value = this.cache.get(cacheKey);
-                if (typeof value !== "undefined") {
-                    return ProvingKey.fromBytes(value[0]);
-                }
-                else {
-                    console.debug("Fetching proving keys from url " + proverUrl);
-                    const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
-                    return provingKey;
-                }
-            }
-            else {
-                const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
-                return provingKey;
-            }
-        }
-        catch (error) {
-            throw new Error(`Error: ${error.message} fetching fee proving keys from ${proverUrl}`);
-        }
-    }
-    async fetchCreditsKeys(key) {
-        try {
-            if (!this.cache.has(key.locator) || !this.cacheOption) {
-                const verifying_key = key.verifyingKey();
-                const proving_key = await this.fetchProvingKey(key.prover, key.locator);
-                if (this.cacheOption) {
-                    this.cache.set(CREDITS_PROGRAM_KEYS.bond_public.locator, [proving_key.toBytes(), verifying_key.toBytes()]);
-                }
-                return [proving_key, verifying_key];
-            }
-            else {
-                const keyPair = this.cache.get(key.locator);
-                return [ProvingKey.fromBytes(keyPair[0]), VerifyingKey.fromBytes(keyPair[1])];
-            }
-        }
-        catch (error) {
-            throw new Error(`Error: fetching credits.aleo keys: ${error.message}`);
-        }
-    }
-    async bondPublicKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_public);
-    }
-    bondValidatorKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_validator);
-    }
-    claimUnbondPublicKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.claim_unbond_public);
-    }
-    /**
-     * Returns the proving and verifying keys for the transfer functions in the credits.aleo program
-     * @param {string} visibility Visibility of the transfer function
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the transfer functions
-     *
-     * @example
-     * // Create a new AleoKeyProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
-     *
-     * // Keys can also be fetched manually
-     * const [transferPublicProvingKey, transferPublicVerifyingKey] = await keyProvider.transferKeys("public");
-     */
-    async transferKeys(visibility) {
-        if (PRIVATE_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private);
-        }
-        else if (PRIVATE_TO_PUBLIC_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private_to_public);
-        }
-        else if (PUBLIC_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public);
-        }
-        else if (PUBLIC_TRANSFER_AS_SIGNER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_as_signer);
-        }
-        else if (PUBLIC_TO_PRIVATE_TRANSFER.has(visibility)) {
-            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_to_private);
-        }
-        else {
-            throw new Error("Invalid visibility type");
-        }
-    }
-    /**
-     * Returns the proving and verifying keys for the join function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
-     */
-    async joinKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.join);
-    }
-    /**
-     * Returns the proving and verifying keys for the split function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the split function
-     * */
-    async splitKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.split);
-    }
-    /**
-     * Returns the proving and verifying keys for the fee_private function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the fee function
-     */
-    async feePrivateKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.fee_private);
-    }
-    /**
-     * Returns the proving and verifying keys for the fee_public function in the credits.aleo program
-     *
-     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the fee function
-     */
-    async feePublicKeys() {
-        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.fee_public);
-    }
-    /**
-     * Gets a verifying key. If the verifying key is for a credits.aleo function, get it from the wasm cache otherwise
-     *
-     * @returns {Promise<VerifyingKey>} Verifying key for the function
-     */
-    // attempt to fetch it from the network
-    async getVerifyingKey(verifierUri) {
-        switch (verifierUri) {
-            case CREDITS_PROGRAM_KEYS.bond_public.verifier:
-                return CREDITS_PROGRAM_KEYS.bond_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.bond_validator.verifier:
-                return CREDITS_PROGRAM_KEYS.bond_validator.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.claim_unbond_public.verifier:
-                return CREDITS_PROGRAM_KEYS.claim_unbond_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.fee_private.verifier:
-                return CREDITS_PROGRAM_KEYS.fee_private.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.fee_public.verifier:
-                return CREDITS_PROGRAM_KEYS.fee_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.inclusion.verifier:
-                return CREDITS_PROGRAM_KEYS.inclusion.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.join.verifier:
-                return CREDITS_PROGRAM_KEYS.join.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.set_validator_state.verifier:
-                return CREDITS_PROGRAM_KEYS.set_validator_state.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.split.verifier:
-                return CREDITS_PROGRAM_KEYS.split.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_private.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_private.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_private_to_public.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_private_to_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_public.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_public.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_public_as_signer.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_public_as_signer.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.transfer_public_to_private.verifier:
-                return CREDITS_PROGRAM_KEYS.transfer_public_to_private.verifyingKey();
-            case CREDITS_PROGRAM_KEYS.unbond_public.verifier:
-                return CREDITS_PROGRAM_KEYS.unbond_public.verifyingKey();
-            default:
-                try {
-                    /// Try to fetch the verifying key from the network as a string
-                    const response = await get(verifierUri);
-                    const text = await response.text();
-                    return VerifyingKey.fromString(text);
-                }
-                catch (e) {
-                    /// If that fails, try to fetch the verifying key from the network as bytes
-                    try {
-                        return VerifyingKey.fromBytes(await this.fetchBytes(verifierUri));
-                    }
-                    catch (inner) {
-                        throw new Error("Invalid verifying key. Error: " + inner.message);
-                    }
-                }
-        }
-    }
-    unBondPublicKeys() {
-        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.unbond_public);
-    }
-}
-
-/**
- * The ProgramManager class is used to execute and deploy programs on the Aleo network and create value transfers.
- */
-class ProgramManager {
-    account;
-    keyProvider;
-    host;
-    networkClient;
-    recordProvider;
-    /** Create a new instance of the ProgramManager
-     *
-     * @param { string | undefined } host A host uri running the official Aleo API
-     * @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, 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
-     *
-     * @param {Account} account Account to use for transaction submission
-     */
-    setAccount(account) {
-        this.account = account;
-    }
-    /**
-     * Set the key provider that provides the proving and verifying keys for programs
-     *
-     * @param {FunctionKeyProvider} keyProvider
-     */
-    setKeyProvider(keyProvider) {
-        this.keyProvider = keyProvider;
-    }
-    /**
-     * Set the host peer to use for transaction submission to the Aleo network
-     *
-     * @param host {string} Peer url to use for transaction submission
-     */
-    setHost(host) {
-        this.host = host;
-        this.networkClient.setHost(host);
-    }
-    /**
-     * Set the record provider that provides records for transactions
-     *
-     * @param {RecordProvider} recordProvider
-     */
-    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} 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
-     * @param {PrivateKey | undefined} privateKey Optional private key to use for the transaction
-     * @returns {string} The transaction id of the deployed program or a failure message from the network
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for deployments
-     * const program = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * programManager.setAccount(Account);
-     *
-     * // Define a fee in credits
-     * const priorityFee = 0.0;
-     *
-     * // Create the deployment transaction.
-     * const tx = await programManager.buildDeploymentTransaction(program, fee, false);
-     * await programManager.networkClient.submitTransaction(tx);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 20000);
-     */
-    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 {
-            let programSource;
-            try {
-                programSource = await this.networkClient.getProgram(programObject.id());
-            }
-            catch (e) {
-                // 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 Error(`Program ${programObject.id()} already exists on the network, please rename your program`);
-            }
-        }
-        catch (e) {
-            logAndThrow(`Error validating program: ${e.message}`);
-        }
-        // Get the private key from the account if it is not provided in the parameters
-        let deploymentPrivateKey = privateKey;
-        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";
-        }
-        // Get the fee record from the account if it is not provided in the parameters
-        try {
-            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.`);
-        }
-        // Get the proving and verifying keys from the key provider
-        let feeKeys;
-        try {
-            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.`);
-        }
-        const [feeProvingKey, feeVerifyingKey] = feeKeys;
-        // Resolve the program imports if they exist
-        let imports;
-        try {
-            imports = await this.networkClient.getProgramImports(program);
-        }
-        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
-        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} 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
-     * @param {PrivateKey | undefined} privateKey Optional private key to use for the transaction
-     * @returns {string} The transaction id of the deployed program or a failure message from the network
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for deployments
-     * const program = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     *
-     * // Define a fee in credits
-     * const priorityFee = 0.0;
-     *
-     * // Deploy the program
-     * const tx_id = await programManager.deploy(program, fee, false);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 20000);
-     */
-    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);
-    }
-    /**
-     * Builds an execution transaction for submission to the Aleo network.
-     *
-     * @param {ExecuteOptions} options - The options for the execution transaction.
-     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error.
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider using official Aleo record, key, and network providers
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     *
-     * // Build and execute the transaction
-     * const tx = await programManager.buildExecutionTransaction({
-     *   programName: "hello_hello.aleo",
-     *   functionName: "hello_hello",
-     *   priorityFee: 0.0,
-     *   privateFee: false,
-     *   inputs: ["5u32", "5u32"],
-     *   keySearchParams: { "cacheKey": "hello_hello:hello" }
-     * });
-     *
-     * // Submit the transaction to the network
-     * await programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    async buildExecutionTransaction(options) {
-        // Destructure the options object to access the parameters
-        const { programName, functionName, priorityFee, privateFee, inputs, recordSearchParams, keySearchParams, privateKey, offlineQuery, } = options;
-        let feeRecord = options.feeRecord;
-        let provingKey = options.provingKey;
-        let verifyingKey = options.verifyingKey;
-        let program = options.program;
-        let imports = options.imports;
-        // Ensure the function exists on the network
-        if (program === undefined) {
-            try {
-                program = (await this.networkClient.getProgram(programName));
-            }
-            catch (e) {
-                logAndThrow(`Error finding ${programName}. Network response: '${e.message}'. Please ensure you're connected to a valid Aleo network the program is deployed to the network.`);
-            }
-        }
-        else if (program instanceof Program) {
-            program = program.toString();
-        }
-        // 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") {
-            executionPrivateKey = this.account.privateKey();
-        }
-        if (typeof executionPrivateKey === "undefined") {
-            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(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.`);
-        }
-        // Get the fee proving and verifying keys from the key provider
-        let feeKeys;
-        try {
-            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.`);
-        }
-        const [feeProvingKey, feeVerifyingKey] = feeKeys;
-        // 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));
-            }
-            catch (e) {
-                console.log(`Function keys not found. Key finder response: '${e}'. The function keys will be synthesized`);
-            }
-        }
-        // Resolve the program imports if they exist
-        const numberOfImports = Program.fromString(program).getImports().length;
-        if (numberOfImports > 0 && !imports) {
-            try {
-                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
-        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.
-     *
-     * @param {ExecuteOptions} options - The options for the execution transaction.
-     * @returns {Promise<string>} - The transaction id
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider using official Aleo record, key, and network providers
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     *
-     * // Build and execute the transaction
-     * const tx_id = await programManager.execute({
-     *   programName: "hello_hello.aleo",
-     *   functionName: "hello_hello",
-     *   priorityFee: 0.0,
-     *   privateFee: false,
-     *   inputs: ["5u32", "5u32"],
-     *   keySearchParams: { "cacheKey": "hello_hello:hello" }
-     * });
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    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);
-    }
-    /**
-     * Run an Aleo program in offline mode
-     *
-     * @param {string} program Program source code containing the function to be executed
-     * @param {string} function_name Function name to execute
-     * @param {string[]} inputs Inputs to the function
-     * @param {number} proveExecution Whether to prove the execution of the function and return an execution transcript that contains the proof.
-     * @param {string[] | undefined} imports Optional imports to the program
-     * @param {KeySearchParams | undefined} keySearchParams Optional parameters for finding the matching proving & verifying keys for the function
-     * @param {ProvingKey | undefined} provingKey Optional proving key to use for the transaction
-     * @param {VerifyingKey | undefined} verifyingKey Optional verifying key to use for the transaction
-     * @param {PrivateKey | undefined} privateKey Optional private key to use for the transaction
-     * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<ExecutionResponse>} The execution response containing the outputs of the function and the proof if the program is proved.
-     *
-     * @example
-     * /// Import the mainnet version of the sdk used to build executions.
-     * import { Account, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * /// Create the source for the "helloworld" program
-     * const program = "program helloworld.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
-     * const programManager = new ProgramManager(undefined, undefined, undefined);
-     *
-     * /// Create a temporary account for the execution of the program
-     * const account = new Account();
-     * programManager.setAccount(account);
-     *
-     * /// Get the response and ensure that the program executed correctly
-     * const executionResponse = await programManager.run(program, "hello", ["5u32", "5u32"]);
-     * const result = executionResponse.getOutputs();
-     * assert(result === ["10u32"]);
-     */
-    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") {
-            executionPrivateKey = this.account.privateKey();
-        }
-        if (typeof executionPrivateKey === "undefined") {
-            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));
-            }
-            catch (e) {
-                console.log(`Function keys not found. Key finder response: '${e}'. The function keys will be synthesized`);
-            }
-        }
-        // Run the program offline and return the result
-        console.log("Running program offline");
-        console.log("Proving key: ", provingKey);
-        console.log("Verifying key: ", verifyingKey);
-        return ProgramManager$1.executeFunctionOffline(executionPrivateKey, program, function_name, inputs, proveExecution, false, imports, provingKey, verifyingKey, this.host, offlineQuery);
-    }
-    /**
-     * Join two credits records into a single credits record
-     *
-     * @param {RecordPlaintext | string} recordOne First credits record to join
-     * @param {RecordPlaintext | string} recordTwo Second credits record to join
-     * @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
-     * @param {PrivateKey | undefined} privateKey Private key to use for the join transaction
-     * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * const record_1 = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 4106205762862305308495708971985748592380064201230396559307556388725936304984group.public}"
-     * const record_2 = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 1540945439182663264862696551825005342995406165131907382295858612069623286213group.public}"
-     * const tx_id = await programManager.join(record_1, record_2, 0.05, false);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    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;
-        let feeAddress;
-        if (typeof privateKey === "undefined" &&
-            typeof this.account !== "undefined") {
-            executionPrivateKey = this.account.privateKey();
-            feeAddress = this.account?.address();
-        }
-        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();
-            joinKeys = await this.keyProvider.joinKeys();
-        }
-        catch (e) {
-            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
-        }
-        const [feeProvingKey, feeVerifyingKey] = feeKeys;
-        const [joinProvingKey, joinVerifyingKey] = joinKeys;
-        // Get the fee record from the account if it is not provided in the parameters
-        try {
-            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);
-        }
-        catch (e) {
-            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, 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);
-    }
-    /**
-     * Split credits into two new credits records
-     *
-     * @param {number} splitAmount Amount in microcredits to split from the original credits record
-     * @param {RecordPlaintext | string} amountRecord Amount record to use for the split transaction
-     * @param {PrivateKey | undefined} privateKey Optional private key to use for the split transaction
-     * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * const record = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 4106205762862305308495708971985748592380064201230396559307556388725936304984group.public}"
-     * const tx_id = await programManager.split(25000000, record);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    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 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";
-        }
-        // Get the split keys from the key provider
-        let splitKeys;
-        try {
-            splitKeys = await this.keyProvider.splitKeys();
-        }
-        catch (e) {
-            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
-        }
-        const [splitProvingKey, splitVerifyingKey] = splitKeys;
-        // Validate the record to be split
-        try {
-            amountRecord =
-                amountRecord instanceof RecordPlaintext
-                    ? amountRecord
-                    : RecordPlaintext.fromString(amountRecord);
-        }
-        catch (e) {
-            logAndThrow("Record provided is not valid. Please ensure it is a valid plaintext record.");
-        }
-        // Build an execution transaction and submit it to the network
-        const tx = await ProgramManager$1.buildSplitTransaction(executionPrivateKey, splitAmount, amountRecord, this.host, splitProvingKey, splitVerifyingKey, offlineQuery);
-        return await this.networkClient.submitTransaction(tx);
-    }
-    /**
-     * Pre-synthesize proving and verifying keys for a program
-     *
-     * @param program {string} The program source code to synthesize keys for
-     * @param function_id {string} The function id to synthesize keys for
-     * @param inputs {Array<string>}  Sample inputs to the function
-     * @param privateKey {PrivateKey | undefined} Optional private key to use for the key synthesis
-     *
-     * @returns {Promise<FunctionKeyPair>}
-     */
-    async synthesizeKeys(program, function_id, inputs, privateKey) {
-        // Resolve the program imports if they exist
-        let imports;
-        let executionPrivateKey = privateKey;
-        if (typeof executionPrivateKey === "undefined") {
-            if (typeof this.account !== "undefined") {
-                executionPrivateKey = this.account.privateKey();
-            }
-            else {
-                executionPrivateKey = new PrivateKey();
-            }
-        }
-        // Attempt to run an offline execution of the program and extract the proving and verifying keys
-        try {
-            imports = await this.networkClient.getProgramImports(program);
-            const keyPair = await ProgramManager$1.synthesizeKeyPair(executionPrivateKey, program, function_id, inputs, imports);
-            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.`);
-        }
-    }
-    /**
-     * Build a 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} 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
-     * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
-     * @param {PrivateKey | undefined} privateKey Optional private key to use for the transfer transaction
-     * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<Transaction>} The transaction object
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * const tx = await programManager.buildTransferTransaction(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "public", 0.2, false);
-     * await programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    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") {
-            executionPrivateKey = this.account.privateKey();
-        }
-        if (typeof executionPrivateKey === "undefined") {
-            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));
-        }
-        catch (e) {
-            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
-        }
-        const [feeProvingKey, feeVerifyingKey] = feeKeys;
-        const [transferProvingKey, transferVerifyingKey] = transferKeys;
-        // Get the amount and fee record from the account if it is not provided in the parameters
-        try {
-            // Track the nonces of the records found so no duplicate records are used
-            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(priorityFee, [], amountRecord, recordSearchParams));
-                nonces.push(amountRecord.nonce());
-            }
-            else {
-                amountRecord = 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
-        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} 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
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * const tx = await programManager.buildTransferPublicTransaction(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", 0.2);
-     * await programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    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 {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
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * const tx = await programManager.buildTransferPublicAsSignerTransaction(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", 0.2);
-     * await programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    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
-     *
-     * @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} 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
-     * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
-     * @param {PrivateKey | undefined} privateKey Optional private key to use for the transfer transaction
-     * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * /// Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     * keyProvider.useCache = true;
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * const tx_id = await programManager.transfer(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "public", 0.2, false);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    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);
-    }
-    /**
-     * Build transaction to bond credits to a validator for later submission to the Aleo Network
-     *
-     * @param {string} validator_address Address of the validator to bond to, if this address is the same as the staker (i.e. the executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently requires a minimum of 10,000,000 credits to bond (subject to change). If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator's staking committee as a delegator. A minimum of 10 credits is required to bond as a delegator.
-     * @param {string} withdrawal_address Address to withdraw the staked credits to when unbond_public is called.
-     * @param {number} amount The amount of credits to bond
-     * @param {Partial<ExecuteOptions>} options - Override default execution options.
-     * @returns {Promise<Transaction>} The transaction object
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     * programManager.setAccount(new Account("YourPrivateKey"));
-     *
-     * // Create the bonding transaction object for later submission
-     * const tx = await programManager.buildBondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);
-     *
-     * // The transaction can be later submitted to the network using the network client.
-     * await programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    async buildBondPublicTransaction(validator_address, withdrawal_address, amount, options = {}) {
-        const scaledAmount = Math.trunc(amount * 1000000);
-        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",
-        }), program = this.creditsProgram(), ...additionalOptions } = options;
-        const executeOptions = {
-            programName,
-            functionName,
-            priorityFee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions,
-        };
-        return await this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Bond credits to validator.
-     *
-     * @param {string} validator_address Address of the validator to bond to, if this address is the same as the signer (i.e. the executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently requires a minimum of 1,000,000 credits to bond (subject to change). If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator's staking committee as a delegator. A minimum of 10 credits is required to bond as a delegator.
-     * @param {string} withdrawal_address Address to withdraw the staked credits to when unbond_public is called.
-     * @param {number} amount The amount of credits to bond
-     * @param {Options} options Options for the execution
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     *
-     * // Create the bonding transaction
-     * tx_id = await programManager.bondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    async bondPublic(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);
-    }
-    /**
-     * Build a bond_validator transaction for later submission to the Aleo Network.
-     *
-     * @param {string} validator_address Address of the validator to bond to, if this address is the same as the staker (i.e. the executor of this function), it will attempt to bond the credits as a validator. If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator's staking committee as a delegator.
-     * @param {string} withdrawal_address Address to withdraw the staked credits to when unbond_public is called.
-     * @param {number} amount The amount of credits to bond. A minimum of 10000 credits is required to bond as a delegator.
-     * @param {number} commission The commission rate for the validator (must be between 0 and 100 - an error will be thrown if it is not)
-     * @param {Partial<ExecuteOptions>} options - Override default execution options.
-     * @returns {Promise<Transaction>} The transaction object
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     * programManager.setAccount(new Account("YourPrivateKey"));
-     *
-     * // Create the bond validator transaction object for later use.
-     * const tx = await programManager.buildBondValidatorTransaction("aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);
-     *
-     * // The transaction can later be submitted to the network using the network client.
-     * const tx_id = await programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    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", 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",
-        }), program = this.creditsProgram(), ...additionalOptions } = options;
-        const executeOptions = {
-            programName,
-            functionName,
-            priorityFee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions,
-        };
-        return await this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Build transaction to bond a validator.
-     *
-     * @param {string} validator_address Address of the validator to bond to, if this address is the same as the staker (i.e. the executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently requires a minimum of 10,000,000 credits to bond (subject to change). If the address is specified is an existing validator and is different from the address of the executor of this function, it will bond the credits to that validator's staking committee as a delegator. A minimum of 10 credits is required to bond as a delegator.
-     * @param {string} withdrawal_address Address to withdraw the staked credits to when unbond_public is called.
-     * @param {number} amount The amount of credits to bond
-     * @param {number} commission The commission rate for the validator (must be between 0 and 100 - an error will be thrown if it is not)
-     * @param {Partial<ExecuteOptions>} options - Override default execution options.
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     * programManager.setAccount(new Account("YourPrivateKey"));
-     *
-     * // Create the bonding transaction
-     * const tx_id = await programManager.bondValidator("aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    async bondValidator(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);
-    }
-    /**
-     * Build an unbond_public execution transaction to unbond credits from a validator in the Aleo network.
-     *
-     * @param {string} staker_address - The address of the staker who is unbonding the credits.
-     * @param {number} amount - The amount of credits to unbond (scaled by 1,000,000).
-     * @param {Partial<ExecuteOptions>} options - Override default execution options.
-     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error message.
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management.
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to unbond credits.
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     * const tx = await programManager.buildUnbondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", 2000000);
-     *
-     * // The transaction can be submitted later to the network using the network client.
-     * programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    async buildUnbondPublicTransaction(staker_address, amount, options = {}) {
-        const scaledAmount = Math.trunc(amount * 1000000);
-        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",
-        }), program = this.creditsProgram(), ...additionalOptions } = options;
-        const executeOptions = {
-            programName,
-            functionName,
-            priorityFee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions,
-        };
-        return this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Unbond a specified amount of staked credits. If the address of the executor of this function is an existing
-     * validator, it will subtract this amount of credits from the validator's staked credits. If there are less than
-     * 1,000,000 credits staked pool after the unbond, the validator will be removed from the validator set. If the
-     * address of the executor of this function is not a validator and has credits bonded as a delegator, it will
-     * subtract this amount of credits from the delegator's staked credits. If there are less than 10 credits bonded
-     * after the unbond operation, the delegator will be removed from the validator's staking pool.
-     *
-     * @param {string} staker_address Address of the staker who is unbonding the credits
-     * @param {number} amount Amount of credits to unbond.
-     * @param {ExecuteOptions} options Options for the execution
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     * programManager.setAccount(new Account("YourPrivateKey"));
-     *
-     * // Create the unbond_public transaction and send it to the network
-     * const tx_id = await programManager.unbondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", 10);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    async unbondPublic(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);
-    }
-    /**
-     * Build a transaction to claim unbonded public credits in the Aleo network.
-     *
-     * @param {string} staker_address - The address of the staker who is claiming the credits.
-     * @param {Partial<ExecuteOptions>} options - Override default execution options.
-     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error message.
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to claim unbonded credits.
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     *
-     * // Create the claim_unbond_public transaction object for later use.
-     * const tx = await programManager.buildClaimUnbondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j");
-     *
-     * // The transaction can be submitted later to the network using the network client.
-     * programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    async buildClaimUnbondPublicTransaction(staker_address, options = {}) {
-        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",
-        }), program = this.creditsProgram(), ...additionalOptions } = options;
-        const executeOptions = {
-            programName,
-            functionName,
-            priorityFee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions,
-        };
-        // Check if the account has sufficient credits to pay for the transaction
-        return await this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Claim unbonded credits. If credits have been unbonded by the account executing this function, this method will
-     * claim them and add them to the public balance of the account.
-     *
-     * @param {string} staker_address Address of the staker who is claiming the credits
-     * @param {ExecuteOptions} options
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     * programManager.setAccount(new Account("YourPrivateKey"));
-     *
-     * // Create the claim_unbond_public transaction
-     * const tx_id = await programManager.claimUnbondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j");
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    async claimUnbondPublic(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);
-    }
-    /**
-     * Build a set_validator_state transaction for later usage.
-     *
-     * This function allows a validator to set their state to be either opened or closed to new stakers.
-     * When the validator is open to new stakers, any staker (including the validator) can bond or unbond from the validator.
-     * When the validator is closed to new stakers, existing stakers can still bond or unbond from the validator, but new stakers cannot bond.
-     *
-     * This function serves two primary purposes:
-     * 1. Allow a validator to leave the committee, by closing themselves to stakers and then unbonding all of their stakers.
-     * 2. Allow a validator to maintain their % of stake, by closing themselves to allowing more stakers to bond to them.
-     *
-     * @param {boolean} validator_state
-     * @param {Partial<ExecuteOptions>} options - Override default execution options
-     * @returns {Promise<Transaction>} The transaction object
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     *
-     * // Create the set_validator_state transaction
-     * const tx = await programManager.buildSetValidatorStateTransaction(true);
-     *
-     * // The transaction can be submitted later to the network using the network client.
-     * programManager.networkClient.submitTransaction(tx.toString());
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
-     *  assert(transaction.id() === tx.id());
-     * }, 10000);
-     */
-    async buildSetValidatorStateTransaction(validator_state, options = {}) {
-        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",
-        }), ...additionalOptions } = options;
-        const executeOptions = {
-            programName,
-            functionName,
-            priorityFee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions,
-        };
-        return await this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Submit a set_validator_state transaction to the Aleo Network.
-     *
-     * This function allows a validator to set their state to be either opened or closed to new stakers.
-     * When the validator is open to new stakers, any staker (including the validator) can bond or unbond from the validator.
-     * When the validator is closed to new stakers, existing stakers can still bond or unbond from the validator, but new stakers cannot bond.
-     *
-     * This function serves two primary purposes:
-     * 1. Allow a validator to leave the committee, by closing themselves to stakers and then unbonding all of their stakers.
-     * 2. Allow a validator to maintain their % of stake, by closing themselves to allowing more stakers to bond to them.
-     *
-     * @param {boolean} validator_state
-     * @param {Partial<ExecuteOptions>} options - Override default execution options
-     * @returns {Promise<string>} The transaction id
-     *
-     * @example
-     * // Import the mainnet version of the sdk.
-     * import { AleoKeyProvider, ProgramManager } from "@provablehq/sdk/mainnet.js";
-     *
-     * // Create a keyProvider to handle key management
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     *
-     * // Create a new ProgramManager with the key that will be used to bond credits
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, undefined);
-     *
-     * // Create the set_validator_state transaction
-     * const tx_id = await programManager.setValidatorState(true);
-     *
-     * // Verify the transaction was successful
-     * setTimeout(async () => {
-     *  const transaction = await programManager.networkClient.getTransaction(tx_id);
-     *  assert(transaction.id() === tx_id);
-     * }, 10000);
-     */
-    async setValidatorState(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 from an offline execution. This is useful when it is desired to do offchain proving and verification.
-     *
-     * @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, 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, imports, importedVerifyingKeys);
-        }
-        catch (e) {
-            console.warn("The execution was not found in the response, cannot verify the execution");
-            return false;
-        }
-    }
-    /**
-     * Create a program object from a program's source code
-     *
-     * @param {string} program Program source code
-     * @returns {Program} The program object
-     */
-    createProgramFromSource(program) {
-        return Program.fromString(program);
-    }
-    /**
-     * Get the credits program object
-     *
-     * @returns {Program} The credits program object
-     */
-    creditsProgram() {
-        return Program.getCreditsProgram();
-    }
-    /**
-     * Verify a program is valid
-     *
-     * @param {string} program The program source code
-     */
-    verifyProgram(program) {
-        try {
-            Program.fromString(program);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    // Internal utility function for getting a credits.aleo record
-    async getCreditsRecord(amount, nonces, record, params) {
-        try {
-            return record instanceof RecordPlaintext
-                ? record
-                : RecordPlaintext.fromString(record);
-        }
-        catch (e) {
-            try {
-                const recordProvider = this.recordProvider;
-                return (await recordProvider.findCreditsRecord(amount, true, nonces, params));
-            }
-            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.`);
-            }
-        }
-    }
-}
-// Ensure the transfer type requires an amount record
-function requiresAmountRecord(transferType) {
-    return PRIVATE_TRANSFER_TYPES.has(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'.`);
-}
-
-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-B-18sj9m.js.map