@provablehq/sdk 0.7.2 → 0.7.4

package/dist/mainnet/program-manager-DAqdrsXx.js

@@ -1,2356 +0,0 @@
-import { PrivateKey, RecordCiphertext, Program, Plaintext, Transaction, Metadata, VerifyingKey, ProvingKey, ProgramManager as ProgramManager$1, RecordPlaintext, verifyFunctionExecution } from '@provablehq/wasm/mainnet.js';
-
-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;
-}
-
-/**
- * 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://localhost:3030");
- *
- * // Connection to a public beacon node
- * const publicnetworkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
- */
-class AleoNetworkClient {
-    host;
-    headers;
-    account;
-    constructor(host, options) {
-        this.host = host + "/mainnet";
-        if (options && options.headers) {
-            this.headers = options.headers;
-        }
-        else {
-            this.headers = {
-                // This is replaced by the actual version by a Rollup plugin
-                "X-Aleo-SDK-Version": "0.7.0",
-            };
-        }
-    }
-    /**
-     * Set an account to use in networkClient calls
-     *
-     * @param {Account} account
-     * @example
-     * 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
-     */
-    setHost(host) {
-        this.host = host + "/mainnet";
-    }
-    async fetchData(url = "/") {
-        try {
-            const response = await get(this.host + url, {
-                headers: this.headers
-            });
-            const text = await response.text();
-            return parseJSON(text);
-        }
-        catch (error) {
-            throw new Error("Error fetching data.");
-        }
-    }
-    /**
-     * Attempts to find unspent records in the Aleo blockchain for a specified private key.
-     * @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 | PrivateKey} privateKey - The private key to use to find unspent records
-     * @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
-     *
-     * @example
-     * // Find all unspent records
-     * const privateKey = "[PRIVATE_KEY]";
-     * const records = networkClient.findUnspentRecords(0, undefined, privateKey);
-     *
-     * // Find specific amounts
-     * const startHeight = 500000;
-     * const amounts = [600000, 1000000];
-     * const records = networkClient.findUnspentRecords(startHeight, undefined, privateKey, amounts);
-     *
-     * // Find specific amounts with a maximum number of cumulative microcredits
-     * const maxMicrocredits = 100000;
-     * const records = networkClient.findUnspentRecords(startHeight, undefined, privateKey, undefined, maxMicrocredits);
-     */
-    async findUnspentRecords(startHeight, endHeight, privateKey, amounts, maxMicrocredits, nonces) {
-        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.");
-            }
-        }
-        catch (error) {
-            throw new Error("Error fetching latest block height.");
-        }
-        // 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 credits.aleo (for now)
-                                        if (transition.program !== "credits.aleo") {
-                                            continue;
-                                        }
-                                        if (!(typeof transition.outputs == "undefined")) {
-                                            for (let l = 0; l < transition.outputs.length; l++) {
-                                                const output = transition.outputs[l];
-                                                if (output.type === "record") {
-                                                    try {
-                                                        // Create a wasm record ciphertext object from the found output
-                                                        const record = RecordCiphertext.fromString(output.value);
-                                                        // Determine if the record is owned by the specified view key
-                                                        if (record.isOwner(viewKey)) {
-                                                            // Decrypt the record and get the serial number
-                                                            const recordPlaintext = record.decrypt(viewKey);
-                                                            // If the record has already been found, skip it
-                                                            const nonce = recordPlaintext.nonce();
-                                                            if (nonces.includes(nonce)) {
-                                                                continue;
-                                                            }
-                                                            // Otherwise record the nonce that has been found
-                                                            const serialNumber = recordPlaintext.serialNumberString(resolvedPrivateKey, "credits.aleo", "credits");
-                                                            // Attempt to see if the serial number is spent
-                                                            try {
-                                                                await this.getTransitionId(serialNumber);
-                                                            }
-                                                            catch (error) {
-                                                                // If it's not found, add it to the list of unspent records
-                                                                if (!amounts) {
-                                                                    records.push(recordPlaintext);
-                                                                    // If the user specified a maximum number of microcredits, check if the search has found enough
-                                                                    if (typeof maxMicrocredits === "number") {
-                                                                        totalRecordValue += recordPlaintext.microcredits();
-                                                                        // Exit if the search has found the amount specified
-                                                                        if (totalRecordValue >= BigInt(maxMicrocredits)) {
-                                                                            return records;
-                                                                        }
-                                                                    }
-                                                                }
-                                                                // 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;
-    }
-    /**
-     * Returns the contents of the block at the specified block height.
-     *
-     * @param {number} height
-     * @example
-     * const block = networkClient.getBlock(1234);
-     */
-    async getBlock(height) {
-        try {
-            const block = await this.fetchData("/block/" + height);
-            return block;
-        }
-        catch (error) {
-            throw new Error("Error fetching block.");
-        }
-    }
-    /**
-     * Returns a range of blocks between the specified block heights.
-     *
-     * @param {number} start
-     * @param {number} end
-     * @example
-     * const blockRange = networkClient.getBlockRange(2050, 2100);
-     */
-    async getBlockRange(start, end) {
-        try {
-            return await this.fetchData("/blocks?start=" + start + "&end=" + end);
-        }
-        catch (error) {
-            const errorMessage = `Error fetching blocks between ${start} and ${end}.`;
-            throw new Error(errorMessage);
-        }
-    }
-    /**
-     * Returns the deployment transaction id associated with the specified program.
-     *
-     * @param {Program | string} program
-     * @returns {TransactionJSON}
-     */
-    async getDeploymentTransactionIDForProgram(program) {
-        if (program instanceof Program) {
-            program = program.toString();
-        }
-        try {
-            const id = await this.fetchData("/find/transactionID/deployment/" + program);
-            return id.replace("\"", "");
-        }
-        catch (error) {
-            throw new Error("Error fetching deployment transaction for program.");
-        }
-    }
-    /**
-     * Returns the deployment transaction associated with a specified program.
-     *
-     * @param {Program | string} program
-     * @returns {TransactionJSON}
-     */
-    async getDeploymentTransactionForProgram(program) {
-        try {
-            const transaction_id = await this.getDeploymentTransactionIDForProgram(program);
-            return await this.getTransaction(transaction_id);
-        }
-        catch (error) {
-            throw new Error("Error fetching deployment transaction for program.");
-        }
-    }
-    /**
-     * Returns the deployment transaction associated with a specified program as a wasm object.
-     *
-     * @param {Program | string} program
-     * @returns {TransactionJSON}
-     */
-    async getDeploymentTransactioObjectnForProgram(program) {
-        try {
-            const transaction_id = await this.getDeploymentTransactionIDForProgram(program);
-            return await this.getTransactionObject(transaction_id);
-        }
-        catch (error) {
-            throw new Error("Error fetching deployment transaction for program.");
-        }
-    }
-    /**
-     * Returns the contents of the latest block.
-     *
-     * @example
-     * const latestHeight = networkClient.getLatestBlock();
-     */
-    async getLatestBlock() {
-        try {
-            return await this.fetchData("/block/latest");
-        }
-        catch (error) {
-            throw new Error("Error fetching latest block.");
-        }
-    }
-    /**
-     * Returns the latest committee.
-     *
-     * @returns {Promise<object>} A javascript object containing the latest committee
-     */
-    async getLatestCommittee() {
-        try {
-            return await this.fetchData("/committee/latest");
-        }
-        catch (error) {
-            throw new Error("Error fetching latest block.");
-        }
-    }
-    /**
-     * Returns the latest block height.
-     *
-     * @example
-     * const latestHeight = networkClient.getLatestHeight();
-     */
-    async getLatestHeight() {
-        try {
-            return Number(await this.fetchData("/block/height/latest"));
-        }
-        catch (error) {
-            throw new Error("Error fetching latest height.");
-        }
-    }
-    /**
-     * Returns the source code of a program given a program ID.
-     *
-     * @param {string} programId The program ID of a program deployed to the Aleo Network
-     * @return {Promise<string>} Source code of the program
-     *
-     * @example
-     * 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 {
-            return await this.fetchData("/program/" + programId);
-        }
-        catch (error) {
-            throw new Error("Error fetching program");
-        }
-    }
-    /**
-     * Returns a program object from a program ID or program source code.
-     *
-     * @param {string} inputProgram The program ID or program source code of a program deployed to the Aleo Network
-     * @return {Promise<Program>} Source code of the program
-     *
-     * @example
-     * 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.equal(programObjectFromID.to_string(), programObjectFromSource.to_string());
-     */
-    async getProgramObject(inputProgram) {
-        try {
-            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`);
-            }
-        }
-    }
-    /**
-     *  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
-     * 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"
-     * }
-     *
-     * // 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 {
-            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);
-        }
-    }
-    /**
-     * 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
-     * const programImportsNames = networkClient.getProgramImports("double_test.aleo");
-     * const expectedImportsNames = ["multiply_test.aleo"];
-     * assert.deepStrictEqual(programImportsNames, expectedImportsNames);
-     */
-    async getProgramImportNames(inputProgram) {
-        try {
-            const program = inputProgram instanceof Program ? inputProgram : (await this.getProgramObject(inputProgram));
-            return program.getImports();
-        }
-        catch (error) {
-            throw new Error("Error fetching program imports with error: " + error.message);
-        }
-    }
-    /**
-     * Returns the names of the mappings of a program.
-     *
-     * @param {string} programId - The program ID to get the mappings of (e.g. "credits.aleo")
-     * @example
-     * const mappings = networkClient.getProgramMappingNames("credits.aleo");
-     * const expectedMappings = ["account"];
-     * assert.deepStrictEqual(mappings, expectedMappings);
-     */
-    async getProgramMappingNames(programId) {
-        try {
-            return await this.fetchData("/program/" + programId + "/mappings");
-        }
-        catch (error) {
-            throw new Error("Error fetching program mappings - ensure the program exists on chain before trying again");
-        }
-    }
-    /**
-     * 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 of the mapping to get the value of (e.g. "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px")
-     * @return {Promise<string>} String representation of the value of the mapping
-     *
-     * @example
-     * // Get public balance of an account
-     * const mappingValue = networkClient.getMappingValue("credits.aleo", "account", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px");
-     * const expectedValue = "0u64";
-     * assert.equal(mappingValue, expectedValue);
-     */
-    async getProgramMappingValue(programId, mappingName, key) {
-        try {
-            const keyString = key instanceof Plaintext ? key.toString() : key;
-            return await this.fetchData("/program/" + programId + "/mapping/" + mappingName + "/" + keyString);
-        }
-        catch (error) {
-            throw new Error("Error fetching mapping value - ensure the mapping exists and the key is correct");
-        }
-    }
-    /**
-     * 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.
-     *
-     * @example
-     * // 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);
-     *
-     * @param {string} programId - The program ID to get the mapping value of (e.g. "credits.aleo")
-     * @param {string} mappingName - The name of the mapping to get the value of (e.g. "account")
-     * @param {string | Plaintext} key - The key of the mapping to get the value of (e.g. "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px")
-     *
-     * @return {Promise<string>} String representation of the value of the mapping
-     */
-    async getProgramMappingPlaintext(programId, mappingName, key) {
-        try {
-            const keyString = key instanceof Plaintext ? key.toString() : key;
-            const value = await this.fetchData("/program/" + programId + "/mapping/" + mappingName + "/" + keyString);
-            return Plaintext.fromString(value);
-        }
-        catch (error) {
-            throw new Error("Failed to fetch mapping value");
-        }
-    }
-    /**
-     * Returns the latest state/merkle root of the Aleo blockchain.
-     *
-     * @example
-     * const stateRoot = networkClient.getStateRoot();
-     */
-    async getStateRoot() {
-        try {
-            return await this.fetchData("/stateRoot/latest");
-        }
-        catch (error) {
-            throw new Error("Error fetching Aleo state root");
-        }
-    }
-    /**
-     * Returns a transaction by its unique identifier.
-     *
-     * @param {string} id
-     * @example
-     * const transaction = networkClient.getTransaction("at1handz9xjrqeynjrr0xay4pcsgtnczdksz3e584vfsgaz0dh0lyxq43a4wj");
-     */
-    async getTransaction(transactionId) {
-        try {
-            return await this.fetchData("/transaction/" + transactionId);
-        }
-        catch (error) {
-            throw new Error("Error fetching transaction.");
-        }
-    }
-    /**
-     * 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.
-     *
-     * @example
-     * const transactionObject = networkClient.getTransaction("at1handz9xjrqeynjrr0xay4pcsgtnczdksz3e584vfsgaz0dh0lyxq43a4wj");
-     * // Get the transaction inputs as a JS array.
-     * const transactionOutputs = transactionObject.inputs(true);
-     *
-     * // Get the transaction outputs as a JS object.
-     * const transactionInputs = 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();
-     *
-     * @param {string} transactionId
-     * @example
-     */
-    async getTransactionObject(transactionId) {
-        try {
-            const transaction = await this.fetchData("/transaction/" + transactionId);
-            return Transaction.fromString(transaction);
-        }
-        catch (error) {
-            throw new Error("Error fetching transaction.");
-        }
-    }
-    /**
-     * Returns the transactions present at the specified block height.
-     *
-     * @param {number} height
-     * @example
-     * const transactions = networkClient.getTransactions(654);
-     */
-    async getTransactions(height) {
-        try {
-            return await this.fetchData("/block/" + height.toString() + "/transactions");
-        }
-        catch (error) {
-            throw new Error("Error fetching transactions.");
-        }
-    }
-    /**
-     * Returns an array of transactions as wasm objects present at the specified block height.
-     *
-     * @param {number} height
-     * @example
-     * const transactions = networkClient.getTransactionObjects(654);
-     *
-     * let transaction_summaries = transactions.map(transaction => transaction.summary());
-     */
-    async getTransactionObjects(height) {
-        try {
-            return (await this.fetchData("/block/" + height.toString() + "/transactions"))
-                .reduce((acc, transaction) => {
-                acc.push(Transaction.fromString(transaction));
-                return acc;
-            }, []);
-        }
-        catch (error) {
-            throw new Error("Error fetching transactions.");
-        }
-    }
-    /**
-     * Returns the transactions in the memory pool.
-     *
-     * @example
-     * const transactions = networkClient.getTransactionsInMempool();
-     */
-    async getTransactionsInMempool() {
-        try {
-            return await this.fetchData("/memoryPool/transactions");
-        }
-        catch (error) {
-            throw new Error("Error fetching transactions from mempool.");
-        }
-    }
-    /**
-     * Returns the transactions in the memory pool as wasm objects.
-     *
-     * @example
-     * const transactions = networkClient.getTransactionsInMempool();
-     */
-    async getTransactionObjectsInMempool() {
-        try {
-            return (await this.fetchData("/memoryPool/transactions"))
-                .reduce((acc, transaction) => {
-                acc.push(Transaction.fromString(transaction));
-                return acc;
-            }, []);
-        }
-        catch (error) {
-            throw new Error("Error fetching transactions from mempool.");
-        }
-    }
-    /**
-     * Returns the transition ID of the transition corresponding to the ID of the input or output.
-     * @param {string} inputOrOutputID - ID of the input or output.
-     *
-     * @example
-     * const transitionId = networkClient.getTransitionId("2429232855236830926144356377868449890830704336664550203176918782554219952323field");
-     */
-    async getTransitionId(inputOrOutputID) {
-        try {
-            return await this.fetchData("/find/transitionID/" + inputOrOutputID);
-        }
-        catch (error) {
-            throw new Error("Error fetching transition ID.");
-        }
-    }
-    /**
-     * Submit an execute or deployment transaction to the Aleo network.
-     *
-     * @param {Transaction | string} transaction  - The transaction to submit to the network
-     * @returns {string} - The transaction id of the submitted transaction or the resulting error
-     */
-    async submitTransaction(transaction) {
-        const transaction_string = transaction instanceof Transaction ? transaction.toString() : transaction;
-        try {
-            const response = await post(this.host + "/transaction/broadcast", {
-                body: transaction_string,
-                headers: Object.assign({}, this.headers, {
-                    "Content-Type": "application/json",
-                }),
-            });
-            try {
-                const text = await response.text();
-                return parseJSON(text);
-            }
-            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 desired to be submitted to the network.
-     */
-    async submitSolution(solution) {
-        try {
-            const response = await post(this.host + "/solution/broadcast", {
-                body: solution,
-                headers: Object.assign({}, this.headers, {
-                    "Content-Type": "application/json",
-                }),
-            });
-            try {
-                const text = await response.text();
-                return parseJSON(text);
-            }
-            catch (error) {
-                throw new Error(`Error posting transaction. Aleo network response: ${error.message}`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Error posting transaction: No response received: ${error.message}`);
-        }
-    }
-}
-
-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) {
-        this.host = host ? host : 'https://api.explorer.provable.com/v1';
-        this.networkClient = new AleoNetworkClient(this.host);
-        this.keyProvider = keyProvider ? keyProvider : new AleoKeyProvider();
-        this.recordProvider = recordProvider;
-    }
-    /**
-     * 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;
-    }
-    /**
-     * Deploy an Aleo program to the Aleo network
-     *
-     * @param {string} program Program source code
-     * @param {number} fee Fee to pay 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 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
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for deployments
-     * const program = "program hello_hello.aleo;\n\nfunction hello:\n    input r0 as u32.public;\n    input r1 as u32.private;\n    add r0 r1 into r2;\n    output r2 as u32.private;\n";
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     *
-     * // Define a fee in credits
-     * const fee = 1.2;
-     *
-     * // Deploy the program
-     * const tx_id = await programManager.deploy(program, fee);
-     *
-     * // Verify the transaction was successful
-     * const transaction = await programManager.networkClient.getTransaction(tx_id);
-     */
-    async deploy(program, fee, privateFee, recordSearchParams, feeRecord, privateKey) {
-        // Ensure the program is valid and does not exist on the network
-        try {
-            const programObject = Program.fromString(program);
-            let programSource;
-            try {
-                programSource = await this.networkClient.getProgram(programObject.id());
-            }
-            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 (`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(fee, [], 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 and submit it to the network
-        const tx = await ProgramManager$1.buildDeploymentTransaction(deploymentPrivateKey, program, fee, feeRecord, this.host, imports, feeProvingKey, feeVerifyingKey);
-        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
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider using official Aleo record, key, and network providers
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     *
-     * // Build and execute the transaction
-     * const transaction = await programManager.buildExecutionTransaction({
-     *   programName: "hello_hello.aleo",
-     *   functionName: "hello_hello",
-     *   fee: 0.020,
-     *   privateFee: false,
-     *   inputs: ["5u32", "5u32"],
-     *   keySearchParams: { "cacheKey": "hello_hello:hello" }
-     * });
-     * const result = await programManager.networkClient.submitTransaction(transaction);
-     */
-    async buildExecutionTransaction(options) {
-        // Destructure the options object to access the parameters
-        const { programName, functionName, fee, 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(fee, [], 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 and submit it to the network
-        return await ProgramManager$1.buildExecutionTransaction(executionPrivateKey, program, functionName, inputs, fee, feeRecord, this.host, imports, provingKey, verifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
-    }
-    /**
-     * 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
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider using official Aleo record, key, and network providers
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * keyProvider.useCache = true;
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     *
-     * // Build and execute the transaction
-     * const transaction = await programManager.execute({
-     *   programName: "hello_hello.aleo",
-     *   functionName: "hello_hello",
-     *   fee: 0.020,
-     *   privateFee: false,
-     *   inputs: ["5u32", "5u32"],
-     *   keySearchParams: { "cacheKey": "hello_hello:hello" }
-     * });
-     * const result = await programManager.networkClient.submitTransaction(transaction);
-     */
-    async execute(options) {
-        const tx = await this.buildExecutionTransaction(options);
-        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<string>}
-     *
-     * @example
-     * import { Account, Program } from '@provablehq/sdk';
-     *
-     * /// 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();
-     *
-     * /// 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} fee Fee in credits pay for the join 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>}
-     */
-    async join(recordOne, recordTwo, fee, privateFee, recordSearchParams, feeRecord, privateKey, offlineQuery) {
-        // Get the private key from the account if it is not provided in the parameters
-        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 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(fee, [], 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, fee, feeRecord, this.host, joinProvingKey, joinVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
-        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>}
-     *
-     * @example
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programName = "hello_hello.aleo";
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * const record = "{  owner: aleo184vuwr5u7u0ha5f5k44067dd2uaqewxx6pe5ltha5pv99wvhfqxqv339h4.private,  microcredits: 45000000u64.private,  _nonce: 4106205762862305308495708971985748592380064201230396559307556388725936304984group.public}"
-     * const tx_id = await programManager.split(25000000, record);
-     * const transaction = await programManager.networkClient.getTransaction(tx_id);
-     */
-    async split(splitAmount, amountRecord, privateKey, offlineQuery) {
-        // Get the private key from the account if it is not provided in the parameters
-        let executionPrivateKey = privateKey;
-        if (typeof executionPrivateKey === "undefined" && typeof this.account !== "undefined") {
-            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} fee The fee to pay for the transfer
-     * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
-     * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the amount and fee
-     * records for the transfer transaction
-     * @param {RecordPlaintext | string} amountRecord Optional amount record to use for the transfer
-     * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
-     * @param {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 of the transfer transaction
-     *
-     * @example
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programName = "hello_hello.aleo";
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * await programManager.initialize();
-     * const tx_id = await programManager.transfer(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "private", 0.2)
-     * const transaction = await programManager.networkClient.getTransaction(tx_id);
-     */
-    async buildTransferTransaction(amount, recipient, transferType, fee, 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(fee, [], amountRecord, recordSearchParams);
-                nonces.push(amountRecord.nonce());
-            }
-            else {
-                amountRecord = undefined;
-            }
-            feeRecord = privateFee ? await this.getCreditsRecord(fee, nonces, feeRecord, recordSearchParams) : undefined;
-        }
-        catch (e) {
-            logAndThrow(`Error finding fee record. Record finder response: '${e.message}'. Please ensure you're connected to a valid Aleo network and a record with enough balance exists.`);
-        }
-        // Build an execution transaction and submit it to the network
-        return await ProgramManager$1.buildTransferTransaction(executionPrivateKey, amount, recipient, transferType, amountRecord, fee, feeRecord, this.host, transferProvingKey, transferVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
-    }
-    /**
-     * Build 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 {string} transferType The type of transfer to perform - options: 'private', 'privateToPublic', 'public', 'publicToPrivate'
-     * @param {number} fee The fee to pay for the transfer
-     * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
-     * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the amount and fee
-     * records for the transfer transaction
-     * @param {RecordPlaintext | string} amountRecord Optional amount record to use for the transfer
-     * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
-     * @param {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 of the transfer transaction
-     */
-    async buildTransferPublicTransaction(amount, recipient, fee, privateKey, offlineQuery) {
-        return this.buildTransferTransaction(amount, recipient, "public", fee, false, undefined, undefined, undefined, privateKey, offlineQuery);
-    }
-    /**
-     * Build a transfer_public_as_signer transaction to transfer credits to another account for later submission to the Aleo network
-     *
-     * @param {number} amount The amount of credits to transfer
-     * @param {string} recipient The recipient of the transfer
-     * @param {string} transferType The type of transfer to perform - options: 'private', 'privateToPublic', 'public', 'publicToPrivate'
-     * @param {number} fee The fee to pay for the transfer
-     * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
-     * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the amount and fee
-     * records for the transfer transaction
-     * @param {RecordPlaintext | string} amountRecord Optional amount record to use for the transfer
-     * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
-     * @param {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 of the transfer transaction
-     */
-    async buildTransferPublicAsSignerTransaction(amount, recipient, fee, privateKey, offlineQuery) {
-        return this.buildTransferTransaction(amount, recipient, "public", fee, 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} fee The fee to pay for the transfer
-     * @param {boolean} privateFee Use a private record to pay the fee. If false this will use the account's public credit balance
-     * @param {RecordSearchParams | undefined} recordSearchParams Optional parameters for finding the amount and fee
-     * records for the transfer transaction
-     * @param {RecordPlaintext | string} amountRecord Optional amount record to use for the transfer
-     * @param {RecordPlaintext | string} feeRecord Optional fee record to use for the transfer
-     * @param {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 of the transfer transaction
-     *
-     * @example
-     * // Create a new NetworkClient, KeyProvider, and RecordProvider
-     * const networkClient = new AleoNetworkClient("https://api.explorer.provable.com/v1");
-     * const keyProvider = new AleoKeyProvider();
-     * const recordProvider = new NetworkRecordProvider(account, networkClient);
-     *
-     * // Initialize a program manager with the key provider to automatically fetch keys for executions
-     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
-     * await programManager.initialize();
-     * const tx_id = await programManager.transfer(1, "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "private", 0.2)
-     * const transaction = await programManager.networkClient.getTransaction(tx_id);
-     */
-    async transfer(amount, recipient, transferType, fee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) {
-        const tx = await this.buildTransferTransaction(amount, recipient, transferType, fee, privateFee, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery);
-        return await this.networkClient.submitTransaction(tx);
-    }
-    /**
-     * Build transaction to bond credits to a validator for later submission to the Aleo Network
-     *
-     * @example
-     * // 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);
-     * console.log(tx);
-     *
-     * // The transaction can be later submitted to the network using the network client.
-     * const result = await programManager.networkClient.submitTransaction(tx);
-     *
-     * @returns string
-     * @param {string} staker_address Address of the staker who is bonding the credits
-     * @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.
-     */
-    async buildBondPublicTransaction(staker_address, validator_address, withdrawal_address, amount, options = {}) {
-        const scaledAmount = Math.trunc(amount * 1000000);
-        const { programName = "credits.aleo", functionName = "bond_public", fee = options.fee || 0.86, privateFee = false, inputs = [staker_address, 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,
-            fee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions
-        };
-        return await this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Bond credits to validator.
-     *
-     * @example
-     * // 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.bondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);
-     *
-     * @returns string
-     * @param {string} staker_address Address of the staker who is bonding the credits
-     * @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
-     */
-    async bondPublic(staker_address, validator_address, withdrawal_address, amount, options = {}) {
-        const tx = await this.buildBondPublicTransaction(staker_address, validator_address, withdrawal_address, amount, options);
-        return await this.networkClient.submitTransaction(tx);
-    }
-    /**
-     * Build a bond_validator transaction for later submission to the Aleo Network.
-     *
-     * @example
-     * // 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);
-     * console.log(tx);
-     *
-     * // The transaction can later be submitted to the network using the network client.
-     * const tx_id = await programManager.networkClient.submitTransaction(tx);
-     *
-     * @returns string
-     * @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.
-     */
-    async buildBondValidatorTransaction(validator_address, withdrawal_address, amount, commission, options = {}) {
-        const scaledAmount = Math.trunc(amount * 1000000);
-        const adjustedCommission = Math.trunc(commission);
-        const { programName = "credits.aleo", functionName = "bond_validator", fee = options.fee || 0.86, privateFee = false, inputs = [validator_address, withdrawal_address, `${scaledAmount.toString()}u64`, `${adjustedCommission.toString()}u8`], keySearchParams = new AleoKeyProviderParams({
-            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,
-            fee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions
-        };
-        return await this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Build transaction to bond a validator.
-     *
-     * @example
-     * // 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);
-     *
-     * @returns string
-     * @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.
-     */
-    async bondValidator(validator_address, withdrawal_address, amount, commission, options = {}) {
-        const tx = await this.buildBondValidatorTransaction(validator_address, withdrawal_address, amount, commission, options);
-        return await this.networkClient.submitTransaction(tx);
-    }
-    /**
-     * Build a transaction to unbond public 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
-     * // 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);
-     * console.log(tx);
-     *
-     * // The transaction can be submitted later to the network using the network client.
-     * programManager.networkClient.submitTransaction(tx);
-     */
-    async buildUnbondPublicTransaction(staker_address, amount, options = {}) {
-        const scaledAmount = Math.trunc(amount * 1000000);
-        const { programName = "credits.aleo", functionName = "unbond_public", fee = options.fee || 1.3, privateFee = false, inputs = [staker_address, `${scaledAmount.toString()}u64`], keySearchParams = new AleoKeyProviderParams({
-            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,
-            fee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions
-        };
-        return this.buildExecutionTransaction(executeOptions);
-    }
-    /**
-     * Unbond a specified amount of staked credits.
-     *
-     * @example
-     * // 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 and send it to the network
-     * const tx_id = await programManager.unbondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", 10);
-     *
-     * @returns string
-     * @param {string} staker_address Address of the staker who is unbonding the credits
-     * @param {number} amount Amount of credits to unbond. 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 {ExecuteOptions} options Options for the execution
-     */
-    async unbondPublic(staker_address, amount, options = {}) {
-        const tx = await this.buildUnbondPublicTransaction(staker_address, amount, options);
-        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
-     * // 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 unbonded transaction object for later use.
-     * const tx = await programManager.buildClaimUnbondPublicTransaction("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j");
-     * console.log(tx);
-     *
-     * // The transaction can be submitted later to the network using the network client.
-     * programManager.networkClient.submitTransaction(tx);
-     */
-    async buildClaimUnbondPublicTransaction(staker_address, options = {}) {
-        const { programName = "credits.aleo", functionName = "claim_unbond_public", fee = options.fee || 2, privateFee = false, inputs = [staker_address], keySearchParams = new AleoKeyProviderParams({
-            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,
-            fee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions
-        };
-        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.
-     *
-     * @example
-     * // 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.claimUnbondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j");
-     *
-     * @param {string} staker_address Address of the staker who is claiming the credits
-     * @param {ExecuteOptions} options
-     * @returns string
-     */
-    async claimUnbondPublic(staker_address, options = {}) {
-        const tx = await this.buildClaimUnbondPublicTransaction(staker_address, options);
-        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.
-     *
-     * @example
-     * // 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("ValidatorPrivateKey"));
-     *
-     * // Create the bonding transaction
-     * const tx = await programManager.buildSetValidatorStateTransaction(true);
-     *
-     * // The transaction can be submitted later to the network using the network client.
-     * programManager.networkClient.submitTransaction(tx);
-     *
-     * @returns string
-     * @param {boolean} validator_state
-     * @param {Partial<ExecuteOptions>} options - Override default execution options
-     */
-    async buildSetValidatorStateTransaction(validator_state, options = {}) {
-        const { programName = "credits.aleo", functionName = "set_validator_state", fee = 1, 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,
-            fee,
-            privateFee,
-            inputs,
-            keySearchParams,
-            ...additionalOptions
-        };
-        return await this.execute(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.
-     *
-     * @example
-     * // 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("ValidatorPrivateKey"));
-     *
-     * // Create the bonding transaction
-     * const tx_id = await programManager.setValidatorState(true);
-     *
-     * @returns string
-     * @param {boolean} validator_state
-     * @param {Partial<ExecuteOptions>} options - Override default execution options
-     */
-    async setValidatorState(validator_state, options = {}) {
-        const tx = await this.buildSetValidatorStateTransaction(validator_state, options);
-        return this.networkClient.submitTransaction(tx);
-    }
-    /**
-     * Verify a proof of execution from an offline execution
-     *
-     * @param {executionResponse} executionResponse
-     * @returns {boolean} True if the proof is valid, false otherwise
-     */
-    verifyExecution(executionResponse) {
-        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);
-        }
-        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-DAqdrsXx.js.map