@provablehq/sdk 0.9.14 → 0.9.16-rc

package/dist/mainnet/browser.d.ts

@@ -2,6 +2,7 @@ import "./polyfill/shared.js";
 import { Account } from "./account.js";
 import { AleoNetworkClient, ProgramImports } from "./network-client.js";
 import { BlockJSON, Header, Metadata } from "./models/blockJSON.js";
+import { CachedKeyPair, FunctionKeyPair } from "./models/keyPair.js";
 import { ConfirmedTransactionJSON } from "./models/confirmed_transaction.js";
 import { DeploymentJSON, VerifyingKeys } from "./models/deployment/deploymentJSON.js";
 import { DeploymentObject } from "./models/deployment/deploymentObject.js";
@@ -34,8 +35,10 @@ import { TransactionJSON } from "./models/transaction/transactionJSON.js";
 import { TransactionObject } from "./models/transaction/transactionObject.js";
 import { TransitionJSON } from "./models/transition/transitionJSON.js";
 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 { AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, FunctionKeyProvider, KeySearchParams } from "./keys/provider/function-key-provider";
+import { KeyStore } from "./keys/keystore/keystore";
+import { promoteMapToKeyStore } from "./keys/keystore/memory";
+import { OfflineKeyProvider, OfflineSearchParams } from "./keys/provider/offline-key-provider";
 import { BlockHeightSearch, NetworkRecordProvider, RecordProvider } from "./record-provider.js";
 import { RecordScanner } from "./record-scanner.js";
 import { SealanceMerkleTree } from "./integrations/sealance/merkle-tree.js";
@@ -45,4 +48,4 @@ 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, 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, 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, FunctionInput, 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, SealanceMerkleTree, SolutionJSON, SolutionsJSON, TransactionJSON, TransactionObject, TransitionJSON, TransitionObject, VerifyingKeys, };
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, BlockJSON, BlockHeightSearch, CachedKeyPair, ConfirmedTransactionJSON, DeploymentJSON, DeploymentObject, EncryptedRecord, ExecutionJSON, ExecutionObject, FeeExecutionJSON, FeeExecutionObject, FinalizeJSON, FunctionInput, FunctionObject, FunctionKeyPair, FunctionKeyProvider, Header, ImportedPrograms, ImportedVerifyingKeys, InputJSON, InputObject, KeyStore, KeySearchParams, Metadata, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, OutputJSON, OutputObject, OwnedFilter, OwnedRecord, OwnerJSON, PartialSolutionJSON, PlaintextArray, PlaintextLiteral, PlaintextObject, PlaintextStruct, ProgramImports, promoteMapToKeyStore, ProvingRequestJSON, ProvingResponse, RatificationJSON, RecordsFilter, RecordsResponseFilter, RecordProvider, RecordScanner, RecordSearchParams, SealanceMerkleTree, SolutionJSON, SolutionsJSON, TransactionJSON, TransactionObject, TransitionJSON, TransitionObject, VerifyingKeys, };

package/dist/mainnet/browser.js

@@ -602,7 +602,7 @@ class AleoNetworkClient {
         else {
             this.headers = {
                 // This is replaced by the actual version by a Rollup plugin
-                "X-Aleo-SDK-Version": "0.9.14",
+                "X-Aleo-SDK-Version": "0.9.16-rc",
                 "X-Aleo-environment": environment(),
             };
         }
@@ -2102,6 +2102,48 @@ class AleoNetworkClient {
     }
 }
 
+/**
+ * @param {Map<string, CachedKeyPair>} map Any interface which returns a string as cached keypair bytes.
+ *
+ * @returns {KeyStore} The map decorated as a keystore.
+ */
+function promoteMapToKeyStore(map) {
+    const ks = map;
+    ks.getKeys = async (locator) => {
+        const raw = map.get(locator);
+        if (!raw)
+            return null;
+        const [p, v] = raw;
+        return [
+            ProvingKey.fromBytes(p),
+            VerifyingKey.fromBytes(v),
+        ];
+    };
+    ks.getKeyBytes = async (locator) => map.get(locator) ?? null;
+    ks.getProvingKey = async (locator) => {
+        const raw = map.get(locator);
+        return raw ? ProvingKey.fromBytes(raw[0]) : null;
+    };
+    ks.getProvingKeyBytes = async (locator) => map.get(locator)?.[0] ?? null;
+    ks.getVerifyingKey = async (locator) => {
+        const raw = map.get(locator);
+        return raw ? VerifyingKey.fromBytes(raw[1]) : null;
+    };
+    ks.getVerifyingKeyBytes = async (locator) => map.get(locator)?.[1] ?? null;
+    ks.setKeys = async (locator, [pk, vk]) => {
+        map.set(locator, [pk.toBytes(), vk.toBytes()]);
+    };
+    ks.setKeyBytes = async (locator, raw) => {
+        map.set(locator, raw);
+    };
+    ks.has = async (locator) => Map.prototype.has.call(map, locator);
+    ks.delete = async (locator) => {
+        Map.prototype.delete.call(map, locator);
+    };
+    ks.clear = async () => Map.prototype.clear.call(map);
+    return ks;
+}
+
 /**
  * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
  * verifierUri to fetch keys via HTTP from a remote resource as well as a unique cacheKey to store the keys in memory.
@@ -2150,6 +2192,11 @@ class AleoKeyProvider {
         this.cache = new Map();
         this.cacheOption = false;
     }
+    keyStore() {
+        if (!this.cacheOption)
+            return Promise.resolve(undefined);
+        return Promise.resolve(promoteMapToKeyStore(this.cache));
+    }
     /**
      * Use local memory to store keys
      *
@@ -2202,8 +2249,11 @@ class AleoKeyProvider {
     getKeys(keyId) {
         console.debug(`Checking if key exists in cache. KeyId: ${keyId}`);
         if (this.cache.has(keyId)) {
-            const [provingKeyBytes, verifyingKeyBytes] = this.cache.get(keyId);
-            return [ProvingKey.fromBytes(provingKeyBytes), VerifyingKey.fromBytes(verifyingKeyBytes)];
+            const [provingKeyBytes, verifyingKeyBytes] = (this.cache.get(keyId));
+            return [
+                ProvingKey.fromBytes(provingKeyBytes),
+                VerifyingKey.fromBytes(verifyingKeyBytes),
+            ];
         }
         else {
             throw new Error("Key not found in cache.");
@@ -2238,10 +2288,12 @@ class AleoKeyProvider {
                 let key = CREDITS_PROGRAM_KEYS.getKey(params["name"]);
                 return this.fetchCreditsKeys(key);
             }
-            if ("proverUri" in params && typeof params["proverUri"] == "string") {
+            if ("proverUri" in params &&
+                typeof params["proverUri"] == "string") {
                 proverUrl = params["proverUri"];
             }
-            if ("verifierUri" in params && typeof params["verifierUri"] == "string") {
+            if ("verifierUri" in params &&
+                typeof params["verifierUri"] == "string") {
                 verifierUrl = params["verifierUri"];
             }
             if ("cacheKey" in params && typeof params["cacheKey"] == "string") {
@@ -2290,20 +2342,26 @@ class AleoKeyProvider {
                 }
                 const value = this.cache.get(cacheKey);
                 if (typeof value !== "undefined") {
-                    return [ProvingKey.fromBytes(value[0]), VerifyingKey.fromBytes(value[1])];
+                    return [
+                        ProvingKey.fromBytes(value[0]),
+                        VerifyingKey.fromBytes(value[1]),
+                    ];
                 }
                 else {
                     console.debug("Fetching proving keys from url " + proverUrl);
-                    const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
+                    const provingKey = (ProvingKey.fromBytes(await this.fetchBytes(proverUrl)));
                     console.debug("Fetching verifying keys " + verifierUrl);
                     const verifyingKey = (await this.getVerifyingKey(verifierUrl));
-                    this.cache.set(cacheKey, [provingKey.toBytes(), verifyingKey.toBytes()]);
+                    this.cache.set(cacheKey, [
+                        provingKey.toBytes(),
+                        verifyingKey.toBytes(),
+                    ]);
                     return [provingKey, verifyingKey];
                 }
             }
             else {
                 // If cache is disabled, fetch the keys and return them
-                const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
+                const provingKey = (ProvingKey.fromBytes(await this.fetchBytes(proverUrl)));
                 const verifyingKey = (await this.getVerifyingKey(verifierUrl));
                 return [provingKey, verifyingKey];
             }
@@ -2333,12 +2391,12 @@ class AleoKeyProvider {
                 }
                 else {
                     console.debug("Fetching proving keys from url " + proverUrl);
-                    const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
+                    const provingKey = (ProvingKey.fromBytes(await this.fetchBytes(proverUrl)));
                     return provingKey;
                 }
             }
             else {
-                const provingKey = ProvingKey.fromBytes(await this.fetchBytes(proverUrl));
+                const provingKey = (ProvingKey.fromBytes(await this.fetchBytes(proverUrl)));
                 return provingKey;
             }
         }
@@ -2350,7 +2408,7 @@ class AleoKeyProvider {
         try {
             if (!this.cache.has(key.locator) || !this.cacheOption) {
                 const verifying_key = key.verifyingKey();
-                const proving_key = await this.fetchProvingKey(key.prover, key.locator);
+                const proving_key = (await this.fetchProvingKey(key.prover, key.locator));
                 if (this.cacheOption) {
                     this.cache.set(CREDITS_PROGRAM_KEYS.getKey(key.name).locator, [proving_key.toBytes(), verifying_key.toBytes()]);
                 }
@@ -2358,7 +2416,10 @@ class AleoKeyProvider {
             }
             else {
                 const keyPair = this.cache.get(key.locator);
-                return [ProvingKey.fromBytes(keyPair[0]), VerifyingKey.fromBytes(keyPair[1])];
+                return [
+                    ProvingKey.fromBytes(keyPair[0]),
+                    VerifyingKey.fromBytes(keyPair[1]),
+                ];
             }
         }
         catch (error) {
@@ -2508,7 +2569,7 @@ class AleoKeyProvider {
                 catch (e) {
                     /// If that fails, try to fetch the verifying key from the network as bytes
                     try {
-                        return VerifyingKey.fromBytes(await this.fetchBytes(verifierUri));
+                        return (VerifyingKey.fromBytes(await this.fetchBytes(verifierUri)));
                     }
                     catch (inner) {
                         throw new Error("Invalid verifying key. Error: " + inner.message);
@@ -2694,6 +2755,9 @@ class OfflineKeyProvider {
     constructor() {
         this.cache = new Map();
     }
+    keyStore() {
+        return Promise.resolve(promoteMapToKeyStore(this.cache));
+    }
     /**
      * Get bond_public function keys from the credits.aleo program. The keys must be cached prior to calling this
      * method for it to work.
@@ -6623,5 +6687,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, RECORD_DOMAIN, RecordScanner, SealanceMerkleTree, 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, promoteMapToKeyStore };
 //# sourceMappingURL=browser.js.map