@provablehq/sdk 0.6.11 → 0.6.13

package/dist/function-key-provider.d.ts

@@ -1,4 +1,4 @@
-import { ProvingKey, VerifyingKey } from "./index";
+import { ProvingKey, VerifyingKey, Key } from "./index";
 type FunctionKeyPair = [ProvingKey, VerifyingKey];
 type CachedKeyPair = [Uint8Array, Uint8Array];
 type AleoKeyProviderInitParams = {
@@ -18,6 +18,7 @@ interface KeySearchParams {
  * verifierUri to fetch keys via HTTP from a remote resource as well as a unique cacheKey to store the keys in memory.
  */
 declare class AleoKeyProviderParams implements KeySearchParams {
+    name: string | undefined;
     proverUri: string | undefined;
     verifierUri: string | undefined;
     cacheKey: string | undefined;
@@ -33,6 +34,7 @@ declare class AleoKeyProviderParams implements KeySearchParams {
         proverUri?: string;
         verifierUri?: string;
         cacheKey?: string;
+        name?: string;
     });
 }
 /**
@@ -278,7 +280,17 @@ declare class AleoKeyProvider implements FunctionKeyProvider {
      *     CREDITS_PROGRAM_KEYS.transfer_private.verifier,
      * );
      */
-    fetchKeys(proverUrl: string, verifierUrl: string, cacheKey?: string): Promise<FunctionKeyPair | Error>;
+    fetchRemoteKeys(proverUrl: string, verifierUrl: string, cacheKey?: string): Promise<FunctionKeyPair | Error>;
+    /***
+     * Fetches the proving key from a remote source.
+     *
+     * @param proverUrl
+     * @param cacheKey
+     *
+     * @returns {Promise<ProvingKey | Error>} Proving key for the specified program
+     */
+    fetchProvingKey(proverUrl: string, cacheKey?: string): Promise<ProvingKey | Error>;
+    fetchCreditsKeys(key: Key): Promise<FunctionKeyPair | Error>;
     bondPublicKeys(): Promise<FunctionKeyPair | Error>;
     bondValidatorKeys(): Promise<FunctionKeyPair | Error>;
     claimUnbondPublicKeys(): Promise<FunctionKeyPair | Error>;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { VerifyingKey } from "@provablehq/wasm";
 declare const KEY_STORE: string;
 interface Key {
+    name: string;
     locator: string;
     prover: string;
     verifier: string;
@@ -22,6 +23,7 @@ declare const CREDITS_PROGRAM_KEYS: {
     transfer_public_as_signer: Key;
     transfer_public_to_private: Key;
     unbond_public: Key;
+    getKey: (key: string) => Key | Error;
 };
 declare const PRIVATE_TRANSFER_TYPES: Set<string>;
 declare const VALID_TRANSFER_TYPES: Set<string>;
@@ -47,4 +49,4 @@ export { createAleoWorker } from "./managed-worker";
 export { ProgramManager } from "./program-manager";
 export { Address, Execution as FunctionExecution, ExecutionResponse, Field, OfflineQuery, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, RecordCiphertext, RecordPlaintext, Signature, Transaction, VerifyingKey, ViewKey, initThreadPool, verifyFunctionExecution, } from "@provablehq/wasm";
 export { initializeWasm };
-export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, Block, BlockHeightSearch, CachedKeyPair, Execution, FunctionKeyPair, FunctionKeyProvider, Input, KeySearchParams, NetworkRecordProvider, ProgramImports, OfflineKeyProvider, OfflineSearchParams, Output, RecordProvider, RecordSearchParams, TransactionModel, Transition, 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, logAndThrow, };
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, Block, BlockHeightSearch, CachedKeyPair, Execution, FunctionKeyPair, FunctionKeyProvider, Input, Key, KeySearchParams, NetworkRecordProvider, ProgramImports, OfflineKeyProvider, OfflineSearchParams, Output, RecordProvider, RecordSearchParams, TransactionModel, Transition, 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, logAndThrow, };

package/dist/index.js

@@ -232,7 +232,7 @@ class AleoNetworkClient {
         else {
             this.headers = {
                 // This is replaced by the actual version by a Rollup plugin
-                "X-Aleo-SDK-Version": "0.6.10",
+                "X-Aleo-SDK-Version": "0.6.12",
             };
         }
     }
@@ -839,6 +839,7 @@ class AleoNetworkClient {
  * 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;
@@ -854,6 +855,7 @@ class AleoKeyProviderParams {
         this.proverUri = params.proverUri;
         this.verifierUri = params.verifierUri;
         this.cacheKey = params.cacheKey;
+        this.name = params.name;
     }
 }
 /**
@@ -964,6 +966,12 @@ class AleoKeyProvider {
             let proverUrl;
             let verifierUrl;
             let cacheKey;
+            if ("name" in params && typeof params["name"] == "string") {
+                let key = CREDITS_PROGRAM_KEYS.getKey(params["name"]);
+                if (!(key instanceof Error)) {
+                    return this.fetchCreditsKeys(key);
+                }
+            }
             if ("proverUri" in params && typeof params["proverUri"] == "string") {
                 proverUrl = params["proverUri"];
             }
@@ -974,7 +982,7 @@ class AleoKeyProvider {
                 cacheKey = params["cacheKey"];
             }
             if (proverUrl && verifierUrl) {
-                return await this.fetchKeys(proverUrl, verifierUrl, cacheKey);
+                return await this.fetchRemoteKeys(proverUrl, verifierUrl, cacheKey);
             }
             if (cacheKey) {
                 return this.getKeys(cacheKey);
@@ -1007,7 +1015,7 @@ class AleoKeyProvider {
      *     CREDITS_PROGRAM_KEYS.transfer_private.verifier,
      * );
      */
-    async fetchKeys(proverUrl, verifierUrl, cacheKey) {
+    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) {
@@ -1038,14 +1046,67 @@ class AleoKeyProvider {
             throw new Error(`Error: ${error} fetching fee proving and verifying keys from ${proverUrl} and ${verifierUrl}.`);
         }
     }
-    bondPublicKeys() {
-        return this.fetchKeys(CREDITS_PROGRAM_KEYS.bond_public.prover, CREDITS_PROGRAM_KEYS.bond_public.verifier, CREDITS_PROGRAM_KEYS.bond_public.locator);
+    /***
+     * Fetches the proving key from a remote source.
+     *
+     * @param proverUrl
+     * @param cacheKey
+     *
+     * @returns {Promise<ProvingKey | Error>} 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} 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}`);
+        }
+    }
+    async bondPublicKeys() {
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_public);
     }
     bondValidatorKeys() {
-        return this.fetchKeys(CREDITS_PROGRAM_KEYS.bond_validator.prover, CREDITS_PROGRAM_KEYS.bond_validator.verifier, CREDITS_PROGRAM_KEYS.bond_validator.locator);
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.bond_validator);
     }
     claimUnbondPublicKeys() {
-        return this.fetchKeys(CREDITS_PROGRAM_KEYS.claim_unbond_public.prover, CREDITS_PROGRAM_KEYS.claim_unbond_public.verifier, CREDITS_PROGRAM_KEYS.claim_unbond_public.locator);
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.claim_unbond_public);
     }
     /**
      * Returns the proving and verifying keys for the transfer functions in the credits.aleo program
@@ -1067,19 +1128,19 @@ class AleoKeyProvider {
      */
     async transferKeys(visibility) {
         if (PRIVATE_TRANSFER.has(visibility)) {
-            return await this.fetchKeys(CREDITS_PROGRAM_KEYS.transfer_private.prover, CREDITS_PROGRAM_KEYS.transfer_private.verifier, CREDITS_PROGRAM_KEYS.transfer_private.locator);
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private);
         }
         else if (PRIVATE_TO_PUBLIC_TRANSFER.has(visibility)) {
-            return await this.fetchKeys(CREDITS_PROGRAM_KEYS.transfer_private_to_public.prover, CREDITS_PROGRAM_KEYS.transfer_private_to_public.verifier, CREDITS_PROGRAM_KEYS.transfer_private_to_public.locator);
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_private_to_public);
         }
         else if (PUBLIC_TRANSFER.has(visibility)) {
-            return await this.fetchKeys(CREDITS_PROGRAM_KEYS.transfer_public.prover, CREDITS_PROGRAM_KEYS.transfer_public.verifier, CREDITS_PROGRAM_KEYS.transfer_public.locator);
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public);
         }
         else if (PUBLIC_TRANSFER_AS_SIGNER.has(visibility)) {
-            return await this.fetchKeys(CREDITS_PROGRAM_KEYS.transfer_public_as_signer.prover, CREDITS_PROGRAM_KEYS.transfer_public_as_signer.verifier, CREDITS_PROGRAM_KEYS.transfer_public_as_signer.locator);
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_as_signer);
         }
         else if (PUBLIC_TO_PRIVATE_TRANSFER.has(visibility)) {
-            return await this.fetchKeys(CREDITS_PROGRAM_KEYS.transfer_public_to_private.prover, CREDITS_PROGRAM_KEYS.transfer_public_to_private.verifier, CREDITS_PROGRAM_KEYS.transfer_public_to_private.locator);
+            return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public_to_private);
         }
         else {
             throw new Error("Invalid visibility type");
@@ -1091,7 +1152,7 @@ class AleoKeyProvider {
      * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
      */
     async joinKeys() {
-        return await this.fetchKeys(CREDITS_PROGRAM_KEYS.join.prover, CREDITS_PROGRAM_KEYS.join.verifier, CREDITS_PROGRAM_KEYS.join.locator);
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.join);
     }
     /**
      * Returns the proving and verifying keys for the split function in the credits.aleo program
@@ -1099,7 +1160,7 @@ class AleoKeyProvider {
      * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the split function
      * */
     async splitKeys() {
-        return await this.fetchKeys(CREDITS_PROGRAM_KEYS.split.prover, CREDITS_PROGRAM_KEYS.split.verifier, CREDITS_PROGRAM_KEYS.split.locator);
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.split);
     }
     /**
      * Returns the proving and verifying keys for the fee_private function in the credits.aleo program
@@ -1107,7 +1168,7 @@ class AleoKeyProvider {
      * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the fee function
      */
     async feePrivateKeys() {
-        return await this.fetchKeys(CREDITS_PROGRAM_KEYS.fee_private.prover, CREDITS_PROGRAM_KEYS.fee_private.verifier, CREDITS_PROGRAM_KEYS.fee_private.locator);
+        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
@@ -1115,7 +1176,7 @@ class AleoKeyProvider {
      * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the fee function
      */
     async feePublicKeys() {
-        return await this.fetchKeys(CREDITS_PROGRAM_KEYS.fee_public.prover, CREDITS_PROGRAM_KEYS.fee_public.verifier, CREDITS_PROGRAM_KEYS.fee_public.locator);
+        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
@@ -1174,7 +1235,7 @@ class AleoKeyProvider {
         }
     }
     unBondPublicKeys() {
-        return this.fetchKeys(CREDITS_PROGRAM_KEYS.unbond_public.prover, CREDITS_PROGRAM_KEYS.unbond_public.verifier, CREDITS_PROGRAM_KEYS.unbond_public.locator);
+        return this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.unbond_public);
     }
 }
 
@@ -2373,7 +2434,6 @@ class ProgramManager {
      * @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 {string | undefined} caller The caller of the function (if calling transfer_public)
      * @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
@@ -2395,7 +2455,7 @@ class ProgramManager {
      * 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, caller, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) {
+    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
@@ -2436,13 +2496,12 @@ class ProgramManager {
             throw logAndThrow(`Error finding fee record. Record finder response: '${e}'. 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, caller, amountRecord, fee, feeRecord, this.host, transferProvingKey, transferVerifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery);
+        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} caller The caller of the transfer (may be different from the signer)
      * @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
@@ -2455,8 +2514,8 @@ class ProgramManager {
      * @param {OfflineQuery | undefined} offlineQuery Optional offline query if creating transactions in an offline environment
      * @returns {Promise<string | Error>} The transaction id of the transfer transaction
      */
-    async buildTransferPublicTransaction(amount, caller, recipient, fee, privateKey, offlineQuery) {
-        return this.buildTransferTransaction(amount, recipient, "public", fee, false, caller, undefined, undefined, undefined, privateKey, offlineQuery);
+    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
@@ -2475,7 +2534,7 @@ class ProgramManager {
      * @returns {Promise<string | Error>} 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, undefined, privateKey, offlineQuery);
+        return this.buildTransferTransaction(amount, recipient, "public", fee, false, undefined, undefined, undefined, privateKey, offlineQuery);
     }
     /**
      * Transfer credits to another account
@@ -2485,7 +2544,6 @@ class ProgramManager {
      * @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 {string | undefined} caller The caller of the function (if calling transfer_public)
      * @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
@@ -2506,8 +2564,8 @@ class ProgramManager {
      * 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, caller, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery) {
-        const tx = await this.buildTransferTransaction(amount, recipient, transferType, fee, privateFee, caller, recordSearchParams, amountRecord, feeRecord, privateKey, offlineQuery);
+    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);
     }
     /**
@@ -2960,6 +3018,7 @@ function convert(metadata) {
         throw new Error("Invalid method name: " + metadata.verifyingKey);
     }
     return {
+        name: metadata.name,
         locator: metadata.locator,
         prover: metadata.prover,
         verifier: metadata.verifier,
@@ -2982,6 +3041,14 @@ const CREDITS_PROGRAM_KEYS = {
     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 {
+            return new Error(`Key "${key}" not found.`);
+        }
+    }
 };
 const PRIVATE_TRANSFER_TYPES = new Set([
     "transfer_private",