@provablehq/sdk 0.9.9 → 0.9.10

package/dist/testnet/browser.js

@@ -1,6 +1,7 @@
 import 'core-js/proposals/json-parse-with-source.js';
-import { ViewKey, ComputeKey, Address, PrivateKeyCiphertext, PrivateKey, RecordCiphertext, EncryptionToolkit, Group, Program, Plaintext, Transaction, ProvingRequest, Metadata, VerifyingKey, ProvingKey, RecordPlaintext, ProgramManager as ProgramManager$1, verifyFunctionExecution } from '@provablehq/wasm/testnet.js';
-export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Boolean, Ciphertext, ComputeKey, EncryptionToolkit, ExecutionRequest, ExecutionResponse, Field, Execution as FunctionExecution, GraphKey, Group, I128, I16, I32, I64, I8, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, U128, U16, U32, U64, U8, VerifyingKey, ViewKey, initThreadPool, verifyFunctionExecution } from '@provablehq/wasm/testnet.js';
+import { ViewKey, ComputeKey, Address, PrivateKeyCiphertext, PrivateKey, RecordCiphertext, EncryptionToolkit, Group, Program, Plaintext, Transaction, ProvingRequest, Metadata, VerifyingKey, ProvingKey, RecordPlaintext, Field, Poseidon4, ProgramManager as ProgramManager$1, verifyFunctionExecution } from '@provablehq/wasm/testnet.js';
+export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Boolean, Ciphertext, ComputeKey, EncryptionToolkit, ExecutionRequest, ExecutionResponse, Field, Execution as FunctionExecution, GraphKey, Group, I128, I16, I32, I64, I8, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, U128, U16, U32, U64, U8, VerifyingKey, ViewKey, getOrInitConsensusVersionTestHeights, initThreadPool, verifyFunctionExecution } from '@provablehq/wasm/testnet.js';
+import { bech32m } from '@scure/base';
 
 /**
  * Key Management class. Enables the creation of a new Aleo Account, importation of an existing account from
@@ -491,7 +492,7 @@ class AleoNetworkClient {
         else {
             this.headers = {
                 // This is replaced by the actual version by a Rollup plugin
-                "X-Aleo-SDK-Version": "0.9.9",
+                "X-Aleo-SDK-Version": "0.9.10",
                 "X-Aleo-environment": environment(),
             };
         }
@@ -2044,6 +2045,11 @@ const PUBLIC_TO_PRIVATE_TRANSFER = new Set([
     "transfer_public_to_private",
     "transferPublicToPrivate",
 ]);
+const RECORD_DOMAIN = "RecordScannerV0";
+/**
+ * Zero address on Aleo blockchain that corresponds to field element 0. Used as padding in Merkle trees and as a sentinel value.
+ */
+const ZERO_ADDRESS = "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc";
 
 /**
  * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
@@ -2355,6 +2361,22 @@ class AleoKeyProvider {
             throw new Error("Invalid visibility type");
         }
     }
+    /**
+     * Returns the proving and verifying keys for the transfer_public function.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the transfer_public function
+     */
+    async transferPublicKeys() {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public);
+    }
+    /**
+     * Returns the proving and verifying keys for the inclusion proof.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the inclusion proof.
+     */
+    async inclusionKeys() {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.inclusion);
+    }
     /**
      * Returns the proving and verifying keys for the join function in the credits.aleo program
      *
@@ -2771,6 +2793,15 @@ class OfflineKeyProvider {
         return this.functionKeys(OfflineSearchParams.feePublicKeyParams());
     }
     ;
+    /**
+     * Get the inclusion prover keys from. The keys must be cached prior to calling this method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the inclusion prover
+     */
+    inclusionKeys() {
+        return this.functionKeys(OfflineSearchParams.inclusionKeyParams());
+    }
+    ;
     /**
      * Get join function keys from the credits.aleo program. The keys must be cached prior to calling this
      * method for it to work.
@@ -2903,6 +2934,21 @@ class OfflineKeyProvider {
             throw new Error("Attempted to insert invalid proving keys for fee_public");
         }
     }
+    /**
+     * Insert the proving and verifying keys for the inclusion prover into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for the inclusion prover.
+     *
+     * @param provingKey
+     */
+    insertInclusionKeys(provingKey) {
+        if (provingKey.isInclusionProver()) {
+            this.cache.set(CREDITS_PROGRAM_KEYS.inclusion.locator, [provingKey.toBytes(), VerifyingKey.inclusionVerifier().toBytes()]);
+        }
+        else {
+            throw new Error("Attempted to insert invalid proving keys for the inclusion prover");
+        }
+    }
     /**
      * Insert the proving and verifying keys for the join function into the cache. Only the proving key needs
      * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
@@ -3236,6 +3282,532 @@ class BlockHeightSearch {
     }
 }
 
+/**
+ * RecordScanner is a RecordProvider implementation that uses the record scanner service to find records.
+ *
+ * @example
+ * const account = new Account({ privateKey: 'APrivateKey1...' });
+ *
+ * const recordScanner = new RecordScanner({ url: "https://record-scanner.aleo.org" });
+ * recordScanner.setAccount(account);
+ * recordScanner.setApiKey("your-api-key");
+ * const uuid = await recordScanner.register(0);
+ *
+ * const filter = {
+ *     uuid,
+ *     filter: {
+ *         program: "credits.aleo",
+ *         records: ["credits"],
+ *     },
+ *     responseFilter: {
+ *         commitment: true,
+ *         owner: true,
+ *         tag: true,
+ *         tag?: boolean;
+ *         sender: true,
+ *         spent: true,
+ *         record_ciphertext: true,
+ *         block_height: true;
+ *         block_timestamp: true;
+ *         output_index: true;
+ *         record_name: true;
+ *         function_name: true;
+ *         program_name: true;
+ *         transition_id: true;
+ *         transaction_id: true;
+ *         transaction_index: true;
+ *         transition_index: true;
+ *     },
+ *     unspent: true,
+ * };
+ *
+ * const records = await recordScanner.findRecords(filter);
+ */
+class RecordScanner {
+    url;
+    apiKey;
+    uuid;
+    constructor(options) {
+        this.url = options.url;
+        this.apiKey = typeof options.apiKey === "string" ? { header: "X-Provable-API-Key", value: options.apiKey } : options.apiKey;
+    }
+    /**
+     * Set the API key to use for the record scanner.
+     *
+     * @param {string} apiKey The API key to use for the record scanner.
+     */
+    async setApiKey(apiKey) {
+        this.apiKey = typeof apiKey === "string" ? { header: "X-Provable-API-Key", value: apiKey } : apiKey;
+    }
+    /**
+     * Set the UUID to use for the record scanner.
+     *
+     * @param {Field} uuid The UUID to use for the record scanner.
+     */
+    async setUuid(uuidOrViewKey) {
+        this.uuid = uuidOrViewKey instanceof ViewKey ? this.computeUUID(uuidOrViewKey) : uuidOrViewKey;
+    }
+    /**
+     * Register the account with the record scanner service.
+     *
+     * @param {number} startBlock The block height to start scanning from.
+     * @returns {Promise<RegistrationResponse>} The response from the record scanner service.
+     */
+    async register(viewKey, startBlock) {
+        try {
+            let request = {
+                view_key: viewKey.to_string(),
+                start: startBlock,
+            };
+            const response = await this.request(new Request(`${this.url}/register`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(request),
+            }));
+            const data = await response.json();
+            this.uuid = data.uuid;
+            return data;
+        }
+        catch (error) {
+            console.error(`Failed to register view key: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Get encrypted records from the record scanner service.
+     *
+     * @param {RecordsFilter} recordsFilter The filter to use to find the records and filter the response.
+     * @returns {Promise<EncryptedRecord[]>} The encrypted records.
+     */
+    async encryptedRecords(recordsFilter) {
+        try {
+            const response = await this.request(new Request(`${this.url}/records/encrypted`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(recordsFilter),
+            }));
+            return await response.json();
+        }
+        catch (error) {
+            console.error(`Failed to get encrypted records: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Check if a list of serial numbers exist in the record scanner service.
+     *
+     * @param {string[]} serialNumbers The serial numbers to check.
+     * @returns {Promise<Record<string, boolean>>} Map of Aleo Record serial numbers and whether they appeared in any inputs on chain. If boolean corresponding to the Serial Number has a true value, that Record is considered spent by the Aleo Network.
+     */
+    async checkSerialNumbers(serialNumbers) {
+        try {
+            const response = await this.request(new Request(`${this.url}/records/sns`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(serialNumbers),
+            }));
+            return await response.json();
+        }
+        catch (error) {
+            console.error(`Failed to check if serial numbers exist: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Check if a list of tags exist in the record scanner service.
+     *
+     * @param {string[]} tags The tags to check.
+     * @returns {Promise<Record<string, boolean>>} Map of Aleo Record tags and whether they appeared in any inputs on chain. If boolean corresponding to the tag has a true value, that Record is considered spent by the Aleo Network.
+     */
+    async checkTags(tags) {
+        try {
+            const response = await this.request(new Request(`${this.url}/records/tags`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(tags),
+            }));
+            return await response.json();
+        }
+        catch (error) {
+            console.error(`Failed to check if tags exist: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Check the status of a record scanner indexing job.
+     *
+     * @param {string} jobId The job id to check.
+     * @returns {Promise<StatusResponse>} The status of the job.
+     */
+    async checkStatus() {
+        try {
+            const response = await this.request(new Request(`${this.url}/status`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(this.uuid?.toString()),
+            }));
+            return await response.json();
+        }
+        catch (error) {
+            console.error(`Failed to check status of job: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Find a record in the record scanner service.
+     *
+     * @param {OwnedFilter} searchParameters The filter to use to find the record.
+     * @returns {Promise<OwnedRecord>} The record.
+     */
+    async findRecord(searchParameters) {
+        try {
+            const records = await this.findRecords(searchParameters);
+            if (records.length > 0) {
+                return records[0];
+            }
+            throw new Error("Record not found");
+        }
+        catch (error) {
+            console.error(`Failed to find record: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Find records in the record scanner service.
+     *
+     * @param {OwnedFilter} filter The filter to use to find the records.
+     * @returns {Promise<OwnedRecord[]>} The records.
+     */
+    async findRecords(filter) {
+        if (!this.uuid) {
+            throw new Error("You are using the RecordScanner implementation of the RecordProvider. No account has been registered with the RecordScanner which is required to use the findRecords method. Please set an with the setAccount method before calling the findRecords method again.");
+        }
+        filter.uuid = this.uuid?.toString();
+        try {
+            const response = await this.request(new Request(`${this.url}/records/owned`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(filter),
+            }));
+            return await response.json();
+        }
+        catch (error) {
+            console.error(`Failed to get owned records: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Find a credits record in the record scanner service.
+     *
+     * @param {number} microcredits The amount of microcredits to find.
+     * @param {OwnedFilter} searchParameters The filter to use to find the record.
+     * @returns {Promise<OwnedRecord>} The record.
+     */
+    async findCreditsRecord(microcredits, searchParameters) {
+        try {
+            const records = await this.findRecords({
+                decrypt: true,
+                unspent: searchParameters.unspent,
+                filter: {
+                    start: searchParameters.filter?.start ?? 0,
+                    program: "credits.aleo",
+                    record: "credits",
+                },
+                uuid: this.uuid?.toString(),
+            });
+            const record = records.find(record => {
+                const plaintext = RecordPlaintext.fromString(record.record_plaintext ?? '');
+                const amountStr = plaintext.getMember("microcredits").toString();
+                const amount = parseInt(amountStr.replace("u64", ""));
+                return amount >= microcredits;
+            });
+            if (!record) {
+                throw new Error(`No records found matching the supplied search filter:\n${JSON.stringify(searchParameters, null, 2)}`);
+            }
+            return record;
+        }
+        catch (error) {
+            console.error(`Failed to find credits record: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Find credits records using a record scanning service.
+     *
+     * @param {number[]} microcreditAmounts The amounts of microcredits to find.
+     * @param {OwnedFilter} searchParameters The filter to use to find the records.
+     * @returns {Promise<OwnedRecord[]>} The records
+     */
+    async findCreditsRecords(microcreditAmounts, searchParameters) {
+        try {
+            const records = await this.findRecords({
+                decrypt: true,
+                unspent: searchParameters.unspent,
+                filter: {
+                    start: searchParameters.filter?.start ?? 0,
+                    program: "credits.aleo",
+                    record: "credits",
+                },
+                uuid: this.uuid?.toString(),
+            });
+            return records.filter(record => {
+                const plaintext = RecordPlaintext.fromString(record.record_plaintext ?? '');
+                const amount = plaintext.getMember("microcredits").toString();
+                return microcreditAmounts.includes(parseInt(amount.replace("u64", "")));
+            });
+        }
+        catch (error) {
+            console.error(`Failed to find credits records: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Wrapper function to make a request to the record scanner service and handle any errors.
+     *
+     * @param {Request} req The request to make.
+     * @returns {Promise<Response>} The response.
+     */
+    async request(req) {
+        try {
+            if (this.apiKey) {
+                req.headers.set(this.apiKey.header, this.apiKey.value);
+            }
+            const response = await fetch(req);
+            if (!response.ok) {
+                throw new Error(await response.text() ?? `Request to ${req.url} failed with status ${response.status}`);
+            }
+            return response;
+        }
+        catch (error) {
+            console.error(`Failed to make request to ${req.url}: ${error}`);
+            throw error;
+        }
+    }
+    computeUUID(vk) {
+        // Construct the material needed for the Poseidon oracle.
+        const inputs = [Field.newDomainSeparator(RECORD_DOMAIN), vk.toField(), Field.one()];
+        // Calculate the uuid.
+        const hasher = new Poseidon4();
+        return hasher.hash(inputs);
+    }
+}
+
+/**
+ * Client library that encapsulates methods for constructing Merkle exclusion proofs for compliant stablecoin programs following the Sealance architecture.
+ *
+
+ * @example
+ * Construct a Merkle exclusion proof.
+ *  ```typescript
+ * const sealance = new SealanceMerkleTree();
+ * const leaves = [
+ *      "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px",
+ *      "aleo1s3ws5tra87fjycnjrwsjcrnw2qxr8jfqqdugnf0xzqqw29q9m5pqem2u4t",
+ *      "aleo1s3ws5tra87fjycnjrwsjcrnw2qxr8jfqqdugnf0xzqqw29q9m5pqem2u4t",
+ *    ];
+ * const result = sealance.generateLeaves(leaves);
+ * const tree = sealance.buildTree(result);
+ * const [leftIdx, rightIdx] = sealance.getLeafIndices(tree, "aleo1kypwp5m7qtk9mwazgcpg0tq8aal23mnrvwfvug65qgcg9xvsrqgspyjm6n");
+ * const proof_left = sealance.getSiblingPath(tree, leftIdx, 15);
+ * const proof_right = sealance.getSiblingPath(tree, rightIdx, 15);
+ * const exclusion_proof = [proof_left, proof_right];
+ * ```
+ */
+class SealanceMerkleTree {
+    static hasher = new Poseidon4();
+    /**
+    * Converts an Aleo blockchain address to a field element.
+    *
+    * This function decodes a bech32m-encoded Aleo address and converts it to a field element
+    * represented as a BigInt. The address format follows the Aleo protocol specification,
+    * starting with the prefix "aleo1" followed by encoded data.
+    *
+    * @param address - The Aleo blockchain address (e.g., "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px")
+    * @returns A BigInt representing the field element.
+    * @throws Error if the address is invalid or cannot be decoded.
+    *
+    * @example
+    * ```typescript
+    * const address = "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px";
+    * const fieldValue = convertAddressToField(address);
+    * console.log(fieldValue); // 123456789...n
+    * ```
+    */
+    convertAddressToField(address) {
+        const { words } = bech32m.decode(address);
+        const bytes = bech32m.fromWords(words);
+        // Convert bytes to BigInt (little-endian)
+        let fieldValue = BigInt(0);
+        for (let i = 0; i < bytes.length; i++) {
+            fieldValue |= BigInt(bytes[i]) << BigInt(i * 8);
+        }
+        return fieldValue;
+    }
+    /**
+    * Hashes two elements using Poseidon4 hash function
+    * @param prefix - Prefix for the hash (e.g., "0field" for nodes, "1field" for leaves)
+    * @param el1 - First element to hash
+    * @param el2 - Second element to hash
+    * @returns The hash result as a Field
+    * @throws {Error} If inputs are empty or invalid
+    */
+    hashTwoElements(prefix, el1, el2) {
+        if (!el1 || !el2) {
+            throw new Error("Invalid inputs: elements cannot be empty");
+        }
+        const fields = [Field.fromString(prefix), Field.fromString(el1), Field.fromString(el2)];
+        const arrayPlaintext = Plaintext.fromString(`[${fields.map(f => f.toString()).join(",")}]`);
+        return SealanceMerkleTree.hasher.hash(arrayPlaintext.toFields());
+    }
+    /**
+    * Builds a Merkle tree from given leaves. The tree is built bottom-up, hashing pairs of elements at each level.
+    *
+    * @param leaves - Array of leaf elements (must have even number of elements).
+    * @returns Array representing the complete Merkle tree as BigInts.
+    * @throws {Error} If leaves array is empty or has odd number of elements.
+    *
+    * @example
+    * ```typescript
+    * const leaves = ["0field", "1field", "2field", "3field"];
+    * const tree = buildTree(leaves);
+    * const root = tree[tree.length - 1]; // Get the Merkle root
+    * ```
+    */
+    buildTree(leaves) {
+        if (leaves.length === 0) {
+            throw new Error("Leaves array cannot be empty");
+        }
+        if (leaves.length % 2 !== 0) {
+            throw new Error("Leaves array must have even number of elements");
+        }
+        let currentLevel = leaves;
+        let tree = [...currentLevel];
+        let levelSize = currentLevel.length;
+        while (levelSize > 1) {
+            const nextLevel = [];
+            for (let i = 0; i < levelSize; i += 2) {
+                const left = currentLevel[i];
+                const right = currentLevel[i + 1];
+                const prefix = leaves.length === levelSize ? "1field" : "0field";
+                const hash = this.hashTwoElements(prefix, left, right);
+                nextLevel.push(hash.toString());
+            }
+            tree = [...tree, ...nextLevel];
+            currentLevel = nextLevel;
+            levelSize = currentLevel.length;
+        }
+        return tree.map(element => BigInt(element.slice(0, element.length - "field".length)));
+    }
+    /**
+    * Converts Aleo addresses to field elements, sorts them, pads with zero fields, and returns an array. This prepares addresses for Merkle tree construction.
+    *
+    * @param addresses - Array of Aleo addresses.
+    * @param maxTreeDepth - Maximum depth of the Merkle tree (default: 15).
+    * @returns Array of field elements ready for Merkle tree construction.
+    * @throws {Error} If the number of addresses exceeds the maximum capacity.
+    *
+    * @example
+    * ```typescript
+    * const addresses = [
+    *   "aleo1...",
+    *   "aleo1..."
+    * ];
+    * const leaves = generateLeaves(addresses, 15);
+    * const tree = buildTree(leaves);
+    * ```
+    */
+    generateLeaves(addresses, maxTreeDepth = 15) {
+        const maxNumLeaves = Math.floor(2 ** (maxTreeDepth - 1));
+        // Filter out zero addresses
+        addresses = addresses.filter(addr => addr !== ZERO_ADDRESS);
+        let numLeaves = 0;
+        if (addresses.length === 0 || addresses.length === 1) {
+            numLeaves = 2;
+        }
+        else {
+            numLeaves = Math.pow(2, Math.ceil(Math.log2(addresses.length)));
+        }
+        if (addresses.length > maxNumLeaves) {
+            throw new Error(`Leaves limit exceeded. Max: ${maxNumLeaves}, provided: ${addresses.length}`);
+        }
+        // Convert addresses to fields
+        const addressFields = addresses.map(addr => ({
+            address: addr,
+            field: this.convertAddressToField(addr),
+        }));
+        // Sort by field value
+        const sortedFields = addressFields.sort((a, b) => (a.field < b.field ? -1 : 1)).map(item => item.field);
+        // Convert to field strings
+        const sortedFieldElements = sortedFields.map(field => field.toString() + "field");
+        // Pad with zeros to reach power of 2
+        const fullTree = Array(Math.max(numLeaves - sortedFieldElements.length, 0)).fill("0field");
+        return fullTree.concat(sortedFieldElements);
+    }
+    /**
+    * Finds the leaf indices for non-inclusion proof of an address and returns the indices of the two adjacent leaves that surround the target address.
+    *
+    * @param merkleTree - The complete Merkle tree as array of BigInts.
+    * @param address - The Aleo address for which to find indices.
+    * @returns Tuple of [leftLeafIndex, rightLeafIndex].
+    *
+    * @example
+    * ```typescript
+    * const tree = buildTree(leaves);
+    * const [leftIdx, rightIdx] = getLeafIndices(tree, "aleo1...");
+    * ```
+    */
+    getLeafIndices(merkleTree, address) {
+        const num_leaves = Math.floor((merkleTree.length + 1) / 2);
+        const addressBigInt = this.convertAddressToField(address);
+        const leaves = merkleTree.slice(0, num_leaves);
+        let rightLeafIndex = leaves.findIndex((leaf) => addressBigInt <= leaf);
+        let leftLeafIndex = rightLeafIndex - 1;
+        if (rightLeafIndex === -1) {
+            rightLeafIndex = leaves.length - 1;
+            leftLeafIndex = leaves.length - 1;
+        }
+        if (rightLeafIndex === 0) {
+            leftLeafIndex = 0;
+        }
+        return [leftLeafIndex, rightLeafIndex];
+    }
+    /**
+    * Generates the sibling path (Merkle proof) for a given leaf index
+    *
+    * @param tree - The complete Merkle tree.
+    * @param leafIndex - Index of the leaf for which to generate the proof.
+    * @param depth - Maximum depth of the tree.
+    * @returns Object containing siblings array and leaf_index.
+    *
+    * @example
+    * ```typescript
+    * const tree = buildTree(leaves);
+    * const proof = getSiblingPath(tree, 0, 15);
+    * // proof = { siblings: [0n, 1n, ...], leaf_index: 0 }
+    * ```
+    */
+    getSiblingPath(tree, leafIndex, depth) {
+        let num_leaves = Math.floor((tree.length + 1) / 2);
+        const siblingPath = [];
+        let index = leafIndex;
+        let parentIndex = num_leaves;
+        siblingPath.push(tree[index]);
+        let level = 1;
+        while (parentIndex < tree.length) {
+            let siblingIndex = index % 2 === 0 ? index + 1 : index - 1; // Get the sibling index
+            siblingPath.push(tree[siblingIndex]);
+            index = parentIndex + Math.floor(leafIndex / 2 ** level); // Move up to the parent node
+            parentIndex += Math.floor(num_leaves / 2 ** level); // Halve the number of nodes for the next level
+            level++;
+        }
+        while (level < depth) {
+            siblingPath.push(0n);
+            level++;
+        }
+        return { siblings: siblingPath, leaf_index: leafIndex };
+    }
+}
+
 /**
  * The ProgramManager class is used to execute and deploy programs on the Aleo network and create value transfers.
  */
@@ -3245,6 +3817,7 @@ class ProgramManager {
     host;
     networkClient;
     recordProvider;
+    inclusionKeysLoaded = false;
     /** Create a new instance of the ProgramManager
      *
      * @param { string | undefined } host A host uri running the official Aleo API
@@ -3610,9 +4183,146 @@ class ProgramManager {
                 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.`);
             }
         }
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                ProgramManager$1.loadInclusionProver(inclusionKeys[0]);
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            }
+            catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`);
+            }
+        }
         // Build an execution transaction
         return await ProgramManager$1.buildExecutionTransaction(executionPrivateKey, program, functionName, inputs, priorityFee, feeRecord, this.host, imports, provingKey, verifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery, edition);
     }
+    /**
+     * Builds an execution transaction for submission to the Aleo network from an Authorization and Fee Authorization.
+     * This method is helpful if signing and authorization needs to be done in a secure environment separate from where
+     * transactions are built.
+     *
+     * @param {ExecuteAuthorizationOptions} options - The options for executing the authorizations.
+     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error.
+     *
+     * @example
+     * /// Import the mainnet version of the sdk.
+     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a new NetworkClient, KeyProvider, and RecordProvider.
+     * const keyProvider = new AleoKeyProvider();
+     * keyProvider.useCache(true);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for executions
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider);
+     *
+     * // Build the `Authorization`.
+     * const authorization = await programManager.buildAuthorization({
+     *   programName: "credits.aleo",
+     *   functionName: "transfer_public",
+     *   inputs: [
+     *     "aleo1vwls2ete8dk8uu2kmkmzumd7q38fvshrht8hlc0a5362uq8ftgyqnm3w08",
+     *     "10000000u64",
+     *   ],
+     * });
+     *
+     * // Derive the execution ID and base fee.
+     * const executionId = authorization.toExecutionId().toString();
+     *
+     * // Get the base fee in microcredits.
+     * const baseFeeMicrocredits = ProgramManager.estimateFeeForAuthorization(authorization, "credits.aleo");
+     * const baseFeeCredits = baseFeeMicrocredits/1000000;
+     *
+     * // Build a credits.aleo/fee_public `Authorization`.
+     * const feeAuthorization = await programManager.buildFeeAuthorization({
+     *   deploymentOrExecutionId: executionId,
+     *   baseFeeCredits,
+     * });
+     *
+     * // Build and execute the transaction
+     * const tx = await programManager.buildTransactionFromAuthorization({
+     *   programName: "hello_hello.aleo",
+     *   authorization,
+     *   feeAuthorization,
+     * });
+     *
+     * // Submit the transaction to the network
+     * await programManager.networkClient.submitTransaction(tx.toString());
+     *
+     * // Verify the transaction was successful
+     * setTimeout(async () => {
+     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
+     *  assert(transaction.id() === tx.id());
+     * }, 10000);
+     */
+    async buildTransactionFromAuthorization(options) {
+        // Destructure the options object to access the parameters.
+        const { programName, authorization, } = options;
+        const feeAuthorization = options.feeAuthorization;
+        const keySearchParams = options.keySearchParams;
+        const offlineQuery = options.offlineQuery;
+        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 fee proving and verifying keys from the key provider.
+        let feeKeys;
+        const privateFee = feeAuthorization ? feeAuthorization.isFeePrivate() : false;
+        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.`);
+            }
+        }
+        // If the offline query exists, add the inclusion key.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                ProgramManager$1.loadInclusionProver(inclusionKeys[0]);
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            }
+            catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`);
+            }
+        }
+        // Build an execution transaction from the authorization.
+        return await ProgramManager$1.executeAuthorization(authorization, feeAuthorization, program, provingKey, verifyingKey, feeProvingKey, feeVerifyingKey, imports, this.host, offlineQuery);
+    }
     /**
      * Builds a SnarkVM `Authorization` for a specific function.
      *
@@ -3895,14 +4605,14 @@ class ProgramManager {
      * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      *
      * // Build a credits.aleo/fee_public `Authorization`.
-     * const feePublicAuthorization = await programManager.authorizeFee({
+     * const feePublicAuthorization = await programManager.buildFeeAuthorization({
      *   deploymentOrExecutionId: "2423957656946557501636078245035919227529640894159332581642187482178647335171field",
      *   baseFeeCredits: 0.1,
      * });
      *
      * // Build a credits.aleo/fee_private `Authorization`.
      * const record = "{ owner: aleo1j7qxyunfldj2lp8hsvy7mw5k8zaqgjfyr72x2gh3x4ewgae8v5gscf5jh3.private, microcredits: 1500000000000000u64.private, _nonce: 3077450429259593211617823051143573281856129402760267155982965992208217472983group.public }";
-     * const feePrivateAuthorization = await programManager.authorizeFee({
+     * const feePrivateAuthorization = await programManager.buildFeeAuthorization({
      *   deploymentOrExecutionId: "2423957656946557501636078245035919227529640894159332581642187482178647335171field",
      *   baseFeeCredits: 0.1,
      *   feeRecord: record,
@@ -4116,6 +4826,18 @@ class ProgramManager {
         catch (e) {
             logAndThrow("Records provided are not valid. Please ensure they are valid plaintext records.");
         }
+        // Load the inclusion prover offline.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                ProgramManager$1.loadInclusionProver(inclusionKeys[0]);
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            }
+            catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`);
+            }
+        }
         // Build an execution transaction and submit it to the network
         const tx = await ProgramManager$1.buildJoinTransaction(executionPrivateKey, recordOne, recordTwo, priorityFee, feeRecord, this.host, joinProvingKey, joinVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
         // Check if the account has sufficient credits to pay for the transaction
@@ -4180,6 +4902,18 @@ class ProgramManager {
         catch (e) {
             logAndThrow("Record provided is not valid. Please ensure it is a valid plaintext record.");
         }
+        // Load the inclusion prover offline.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                ProgramManager$1.loadInclusionProver(inclusionKeys[0]);
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            }
+            catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`);
+            }
+        }
         // 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);
@@ -4299,6 +5033,20 @@ class ProgramManager {
         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.`);
         }
+        // Load the inclusion prover offline.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            const inclusionKeys = await this.keyProvider.inclusionKeys();
+            ProgramManager$1.loadInclusionProver(inclusionKeys[0]);
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                ProgramManager$1.loadInclusionProver(inclusionKeys[0]);
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            }
+            catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`);
+            }
+        }
         // Build an execution transaction
         return await ProgramManager$1.buildTransferTransaction(executionPrivateKey, amount, recipient, transferType, amountRecord, priorityFee, feeRecord, this.host, transferProvingKey, transferVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
     }
@@ -4469,6 +5217,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
@@ -4572,6 +5321,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
@@ -4666,6 +5416,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return this.buildExecutionTransaction(executeOptions);
@@ -4763,6 +5514,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         // Check if the account has sufficient credits to pay for the transaction
@@ -4856,7 +5608,7 @@ class ProgramManager {
             proverUri: CREDITS_PROGRAM_KEYS.set_validator_state.prover,
             verifierUri: CREDITS_PROGRAM_KEYS.set_validator_state.verifier,
             cacheKey: "credits.aleo/set_validator_state",
-        }), ...additionalOptions } = options;
+        }), program = this.creditsProgram(), ...additionalOptions } = options;
         const executeOptions = {
             programName,
             functionName,
@@ -4864,6 +5616,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
@@ -4966,6 +5719,15 @@ class ProgramManager {
             return false;
         }
     }
+    /**
+     * Set the inclusion key bytes.
+     *
+     * @param {executionResponse} executionResponse The response from an offline function execution (via the `programManager.run` method)
+     * @param {ImportedPrograms} imports The imported programs used in the execution. Specified as { "programName": "programSourceCode", ... }
+     * @param {ImportedVerifyingKeys} importedVerifyingKeys The verifying keys in the execution. Specified as { "programName": [["functionName", "verifyingKey"], ...], ... }
+     * @returns {boolean} True if the proof is valid, false otherwise
+     *
+
     /**
      * Create a program object from a program's source code
      *
@@ -5039,5 +5801,5 @@ async function initializeWasm() {
     console.warn("initializeWasm is deprecated, you no longer need to use it");
 }
 
-export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoNetworkClient, BlockHeightSearch, CREDITS_PROGRAM_KEYS, KEY_STORE, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TO_PRIVATE_TRANSFER, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, ProgramManager, VALID_TRANSFER_TYPES, initializeWasm, logAndThrow };
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoNetworkClient, BlockHeightSearch, CREDITS_PROGRAM_KEYS, KEY_STORE, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TO_PRIVATE_TRANSFER, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, ProgramManager, RECORD_DOMAIN, RecordScanner, SealanceMerkleTree, VALID_TRANSFER_TYPES, initializeWasm, logAndThrow };
 //# sourceMappingURL=browser.js.map