@provablehq/sdk 0.9.9 → 0.9.10-testnet-rc

package/dist/mainnet/browser.d.ts

@@ -36,10 +36,11 @@ import { TransitionObject } from "./models/transition/transitionObject.js";
 import { AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, CachedKeyPair, FunctionKeyPair, FunctionKeyProvider, KeySearchParams } from "./function-key-provider.js";
 import { OfflineKeyProvider, OfflineSearchParams } from "./offline-key-provider.js";
 import { BlockHeightSearch, NetworkRecordProvider, RecordProvider } from "./record-provider.js";
+import { RecordScanner } from "./record-scanner.js";
 declare function initializeWasm(): Promise<void>;
 export { ProgramManager, ProvingRequestOptions, ExecuteOptions, FeeAuthorizationOptions, AuthorizationOptions } from "./program-manager.js";
 export { logAndThrow } from "./utils.js";
-export { Address, Authorization, Boolean, BHP256, BHP512, BHP768, BHP1024, Ciphertext, ComputeKey, Execution as FunctionExecution, ExecutionRequest, ExecutionResponse, EncryptionToolkit, Field, GraphKey, Group, I8, I16, I32, I64, I128, OfflineQuery, Pedersen64, Pedersen128, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Signature, Scalar, Transaction, Transition, U8, U16, U32, U64, U128, VerifyingKey, ViewKey, initThreadPool, verifyFunctionExecution, } from "./wasm.js";
+export { Address, Authorization, Boolean, BHP256, BHP512, BHP768, BHP1024, Ciphertext, ComputeKey, Execution as FunctionExecution, ExecutionRequest, ExecutionResponse, EncryptionToolkit, Field, GraphKey, Group, I8, I16, I32, I64, I128, OfflineQuery, Pedersen64, Pedersen128, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Signature, Scalar, Transaction, Transition, U8, U16, U32, U64, U128, VerifyingKey, ViewKey, initThreadPool, getOrInitConsensusVersionTestHeights, verifyFunctionExecution, } from "./wasm.js";
 export { initializeWasm };
-export { Key, CREDITS_PROGRAM_KEYS, KEY_STORE, PRIVATE_TRANSFER, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, PUBLIC_TO_PRIVATE_TRANSFER, VALID_TRANSFER_TYPES, } from "./constants.js";
-export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, BlockJSON, BlockHeightSearch, CachedKeyPair, ConfirmedTransactionJSON, DeploymentJSON, DeploymentObject, EncryptedRecord, ExecutionJSON, ExecutionObject, FeeExecutionJSON, FeeExecutionObject, FinalizeJSON, FunctionObject, FunctionKeyPair, FunctionKeyProvider, Header, ImportedPrograms, ImportedVerifyingKeys, InputJSON, InputObject, KeySearchParams, Metadata, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, OutputJSON, OutputObject, OwnedFilter, OwnedRecord, OwnerJSON, PartialSolutionJSON, PlaintextArray, PlaintextLiteral, PlaintextObject, PlaintextStruct, ProgramImports, ProvingRequestJSON, ProvingResponse, RatificationJSON, RecordsFilter, RecordsResponseFilter, RecordProvider, RecordSearchParams, SolutionJSON, SolutionsJSON, TransactionJSON, TransactionObject, TransitionJSON, TransitionObject, VerifyingKeys, };
+export { Key, CREDITS_PROGRAM_KEYS, KEY_STORE, PRIVATE_TRANSFER, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, PUBLIC_TO_PRIVATE_TRANSFER, RECORD_DOMAIN, VALID_TRANSFER_TYPES, } from "./constants.js";
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, BlockJSON, BlockHeightSearch, CachedKeyPair, ConfirmedTransactionJSON, DeploymentJSON, DeploymentObject, EncryptedRecord, ExecutionJSON, ExecutionObject, FeeExecutionJSON, FeeExecutionObject, FinalizeJSON, FunctionObject, FunctionKeyPair, FunctionKeyProvider, Header, ImportedPrograms, ImportedVerifyingKeys, InputJSON, InputObject, KeySearchParams, Metadata, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, OutputJSON, OutputObject, OwnedFilter, OwnedRecord, OwnerJSON, PartialSolutionJSON, PlaintextArray, PlaintextLiteral, PlaintextObject, PlaintextStruct, ProgramImports, ProvingRequestJSON, ProvingResponse, RatificationJSON, RecordsFilter, RecordsResponseFilter, RecordProvider, RecordScanner, RecordSearchParams, SolutionJSON, SolutionsJSON, TransactionJSON, TransactionObject, TransitionJSON, TransitionObject, VerifyingKeys, };

package/dist/mainnet/browser.js

@@ -1,6 +1,6 @@
 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/mainnet.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/mainnet.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/mainnet.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/mainnet.js';
 
 /**
  * Key Management class. Enables the creation of a new Aleo Account, importation of an existing account from
@@ -491,7 +491,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-testnet-rc",
                 "X-Aleo-environment": environment(),
             };
         }
@@ -2044,6 +2044,7 @@ const PUBLIC_TO_PRIVATE_TRANSFER = new Set([
     "transfer_public_to_private",
     "transferPublicToPrivate",
 ]);
+const RECORD_DOMAIN = "RecordScannerV0";
 
 /**
  * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
@@ -2355,6 +2356,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 +2788,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 +2929,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 +3277,316 @@ 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);
+    }
+}
+
 /**
  * The ProgramManager class is used to execute and deploy programs on the Aleo network and create value transfers.
  */
@@ -3245,6 +3596,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,6 +3962,17 @@ 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);
     }
@@ -4116,6 +4479,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 +4555,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 +4686,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 +4870,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
@@ -4572,6 +4974,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
@@ -4666,6 +5069,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return this.buildExecutionTransaction(executeOptions);
@@ -4763,6 +5167,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         // Check if the account has sufficient credits to pay for the transaction
@@ -4856,7 +5261,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 +5269,7 @@ class ProgramManager {
             privateFee,
             inputs,
             keySearchParams,
+            program,
             ...additionalOptions,
         };
         return await this.buildExecutionTransaction(executeOptions);
@@ -4966,6 +5372,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 +5454,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, VALID_TRANSFER_TYPES, initializeWasm, logAndThrow };
 //# sourceMappingURL=browser.js.map