@provablehq/sdk 0.10.5 → 0.11.0

package/dist/mainnet/program-manager.d.ts

@@ -4,6 +4,7 @@ import { ImportedPrograms, ImportedVerifyingKeys } from "./models/imports.js";
 import { RecordProvider } from "./record-provider.js";
 import { RecordSearchParams } from "./models/record-provider/recordSearchParams.js";
 import { FunctionKeyProvider, KeySearchParams } from "./keys/provider/interface.js";
+import { KeyStore } from "./keys/keystore/interface.js";
 import { FunctionKeyPair } from "./models/keyPair.js";
 import { Authorization, ExecutionRequest, ExecutionResponse, OfflineQuery, RecordPlaintext, PrivateKey, Program, ProvingKey, ProvingRequest, VerifyingKey, Transaction } from "./wasm.js";
 import { ExternalSigningOptions } from "./models/external-signing.js";
@@ -120,6 +121,7 @@ interface ExecuteAuthorizationOptions {
     offlineQuery?: OfflineQuery;
     program?: string | Program;
     imports?: ProgramImports;
+    edition?: number;
 }
 /**
  * Represents the options for executing a transaction in the Aleo network.
@@ -213,13 +215,14 @@ declare class ProgramManager {
     networkClient: AleoNetworkClient;
     recordProvider: RecordProvider | undefined;
     inclusionKeysLoaded: boolean;
+    private _keyStore;
     /** Create a new instance of the ProgramManager
      *
      * @param { string | undefined } host A host uri running the official Aleo API
      * @param { FunctionKeyProvider | undefined } keyProvider A key provider that implements {@link FunctionKeyProvider} interface
      * @param { RecordProvider | undefined } recordProvider A record provider that implements {@link RecordProvider} interface
      */
-    constructor(host?: string | undefined, keyProvider?: FunctionKeyProvider | undefined, recordProvider?: RecordProvider | undefined, networkClientOptions?: AleoNetworkClientOptions | undefined);
+    constructor(host?: string | undefined, keyProvider?: FunctionKeyProvider | undefined, recordProvider?: RecordProvider | undefined, networkClientOptions?: AleoNetworkClientOptions | undefined, keyStore?: KeyStore | undefined);
     /**
      * Pre-load the inclusion prover for offline execution. Required when the
      * user provides an explicit OfflineQuery (truly offline — can't fetch lazily).
@@ -262,6 +265,63 @@ declare class ProgramManager {
      * @param {RecordProvider} recordProvider
      */
     setRecordProvider(recordProvider: RecordProvider): void;
+    /**
+     * Set the key store for automatic key caching across executions.
+     *
+     * @param {KeyStore} keyStore
+     */
+    setKeyStore(keyStore: KeyStore): void;
+    /**
+     * Build a ProgramImportsBuilder from a program and its imports.
+     * Fetches imports from the network if not provided, resolves transitive
+     * dependencies, and optionally pre-loads cached keys from the KeyStore.
+     *
+     * @param loadKeys When true (default), loads cached proving/verifying keys
+     *   from the KeyStore into the builder. Set to false for authorization and
+     *   proving request paths where keys are not synthesized.
+     */
+    private buildProgramImports;
+    /**
+     * Extract `import program_name.aleo;` names from program source via regex.
+     * Avoids a WASM round-trip compared to Program.fromString + getImports.
+     */
+    private static getImportNames;
+    /**
+     * Convert the JS object returned by Program.getCallGraph() into a
+     * Map<string, Set<string>> for use in buildProgramImports.
+     */
+    private static callGraphToMap;
+    /**
+     * Resolve the active KeyStore, preferring the directly-set _keyStore
+     * over the KeyProvider's keyStore().
+     */
+    private resolveKeyStore;
+    /**
+     * Resolve the edition and amendment count for a program from the network.
+     * Returns `{ edition, amendment }` or falls back to `{ edition: 1, amendment: 0 }`.
+     */
+    private resolveEditionAndAmendment;
+    /**
+     * Load cached proving/verifying keys from the KeyStore into a ProgramImportsBuilder.
+     * Only loads keys for the specified functions — returns immediately if
+     * functionNames is empty or undefined.
+     * Resolves edition and amendment from the network for accurate key locator
+     * construction when not explicitly provided.
+     */
+    private loadKeysFromStore;
+    /**
+     * Persist newly synthesized keys from the returned ProgramImportsBuilder
+     * into the KeyStore. Only writes keys that are not already in the store,
+     * avoiding unnecessary writes of large proving keys.
+     * Fetches each program's current edition and amendment count from the network
+     * for accurate key locator construction.
+     */
+    private persistExtractedKeys;
+    /**
+     * Resolve top-level function keys, checking the KeyStore first and
+     * falling back to the KeyProvider.
+     */
+    private resolveTopLevelKeys;
     /**
      * Set a header in the `AleoNetworkClient`s header map
      *

package/dist/mainnet/record-scanner.d.cts

@@ -1,4 +1,4 @@
-import { TransportFunction } from "./utils.js";
+import { TransportFunction } from "./utils/utils.js";
 import { EncryptedRecord } from "./models/record-provider/encryptedRecord.js";
 import { CryptoBoxPubKey } from "./models/cryptoBoxPubkey.js";
 import { OwnedFilter } from "./models/record-scanner/ownedFilter.js";
@@ -62,7 +62,7 @@ export interface RecordScannerOptions {
  * const recordScanner = new RecordScanner({ url: "https://record-scanner.aleo.org" });
  * recordScanner.setAccount(account);
  * recordScanner.setApiKey("example-api-key");
- * const result = await recordScanner.register(viewKey, 0);
+ * const result = await recordScanner.registerEncrypted(viewKey, 0);
  * if (result.ok) { const uuid = result.data.uuid; }
  *
  * const filter = {
@@ -200,14 +200,6 @@ declare class RecordScanner implements RecordProvider {
      * @throws Re-throws err when it is not a RecordScannerRequestError.
      */
     private handleRequestError;
-    /**
-     * Register the account with the record scanning service (unencrypted POST /register). Does not throw if a valid error response from the record scanner is received; returns a result object instead.
-     *
-     * @param {ViewKey} viewKey The view key to register.
-     * @param {number} startBlock The block height to start scanning from.
-     * @returns {Promise<RegisterResult>} `{ ok: true, data }` on success, or `{ ok: false, status, error }` on failure.
-     */
-    register(viewKey: ViewKey, startBlock: number): Promise<RegisterResult>;
     /**
      * Fetches an ephemeral public key from the record scanning service for use with registerEncrypted.
      * Follows the same pattern as the delegated proving service /pubkey endpoint.
@@ -215,6 +207,17 @@ declare class RecordScanner implements RecordProvider {
      * @returns {Promise<CryptoBoxPubKey>} The service's ephemeral public key and key_id.
      */
     getPubkey(): Promise<CryptoBoxPubKey>;
+    /**
+     * Registers the account with the record scanning service using the encrypted flow.
+     * Alias of {@link registerEncrypted} — preserved so existing callers using the
+     * previous unencrypted `register(viewKey, startBlock)` API continue to work
+     * unchanged while transparently using the encrypted endpoint.
+     *
+     * @param {ViewKey} viewKey The view key to register.
+     * @param {number} startBlock The block height to start scanning from.
+     * @returns {Promise<RegisterResult>} `{ ok: true, data }` on success, or `{ ok: false, status, error }` on failure.
+     */
+    register(viewKey: ViewKey, startBlock: number): Promise<RegisterResult>;
     /**
      * Registers the account with the record scanning service using the encrypted flow: 1. fetches an ephemeral public key from /pubkey - 2. encrypts the registration request (view key + start block) - 3. POSTs to /register/encrypted. Does not HTTP error on a proper error response from the record scanner; returns a result object instead.
      *

package/dist/mainnet/record-scanner.d.ts

@@ -1,4 +1,4 @@
-import { TransportFunction } from "./utils.js";
+import { TransportFunction } from "./utils/utils.js";
 import { EncryptedRecord } from "./models/record-provider/encryptedRecord.js";
 import { CryptoBoxPubKey } from "./models/cryptoBoxPubkey.js";
 import { OwnedFilter } from "./models/record-scanner/ownedFilter.js";
@@ -62,7 +62,7 @@ export interface RecordScannerOptions {
  * const recordScanner = new RecordScanner({ url: "https://record-scanner.aleo.org" });
  * recordScanner.setAccount(account);
  * recordScanner.setApiKey("example-api-key");
- * const result = await recordScanner.register(viewKey, 0);
+ * const result = await recordScanner.registerEncrypted(viewKey, 0);
  * if (result.ok) { const uuid = result.data.uuid; }
  *
  * const filter = {
@@ -200,14 +200,6 @@ declare class RecordScanner implements RecordProvider {
      * @throws Re-throws err when it is not a RecordScannerRequestError.
      */
     private handleRequestError;
-    /**
-     * Register the account with the record scanning service (unencrypted POST /register). Does not throw if a valid error response from the record scanner is received; returns a result object instead.
-     *
-     * @param {ViewKey} viewKey The view key to register.
-     * @param {number} startBlock The block height to start scanning from.
-     * @returns {Promise<RegisterResult>} `{ ok: true, data }` on success, or `{ ok: false, status, error }` on failure.
-     */
-    register(viewKey: ViewKey, startBlock: number): Promise<RegisterResult>;
     /**
      * Fetches an ephemeral public key from the record scanning service for use with registerEncrypted.
      * Follows the same pattern as the delegated proving service /pubkey endpoint.
@@ -215,6 +207,17 @@ declare class RecordScanner implements RecordProvider {
      * @returns {Promise<CryptoBoxPubKey>} The service's ephemeral public key and key_id.
      */
     getPubkey(): Promise<CryptoBoxPubKey>;
+    /**
+     * Registers the account with the record scanning service using the encrypted flow.
+     * Alias of {@link registerEncrypted} — preserved so existing callers using the
+     * previous unencrypted `register(viewKey, startBlock)` API continue to work
+     * unchanged while transparently using the encrypted endpoint.
+     *
+     * @param {ViewKey} viewKey The view key to register.
+     * @param {number} startBlock The block height to start scanning from.
+     * @returns {Promise<RegisterResult>} `{ ok: true, data }` on success, or `{ ok: false, status, error }` on failure.
+     */
+    register(viewKey: ViewKey, startBlock: number): Promise<RegisterResult>;
     /**
      * Registers the account with the record scanning service using the encrypted flow: 1. fetches an ephemeral public key from /pubkey - 2. encrypts the registration request (view key + start block) - 3. POSTs to /register/encrypted. Does not HTTP error on a proper error response from the record scanner; returns a result object instead.
      *

package/dist/mainnet/utils/index.d.cts

@@ -0,0 +1,3 @@
+export { logger, setLogLevel, getLogLevel } from "./logger.js";
+export type { LogLevel } from "./logger.js";
+export { logAndThrow, retryWithBackoff, environment, isNode, TransportFunction, defaultTransport } from "./utils.js";

package/dist/mainnet/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { logger, setLogLevel, getLogLevel } from "./logger.js";
+export type { LogLevel } from "./logger.js";
+export { logAndThrow, retryWithBackoff, environment, isNode, TransportFunction, defaultTransport } from "./utils.js";

package/dist/mainnet/utils/logger.d.cts

@@ -0,0 +1,34 @@
+/**
+ * Log levels in ascending severity. Each level includes all levels above it.
+ * "silent" suppresses all output. "debug" enables everything.
+ *
+ * @example
+ * import { setLogLevel } from "@provablehq/sdk";
+ * setLogLevel("silent"); // suppress all SDK logging
+ */
+export type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
+/**
+ * Set the SDK log level. Levels are hierarchical:
+ * - "silent" — suppress all SDK logging
+ * - "error"  — only errors
+ * - "warn"   — errors + warnings
+ * - "info"   — errors + warnings + info (default)
+ * - "debug"  — everything including debug traces
+ *
+ * This controls both TS-side and WASM-side logging. WASM log calls
+ * (e.g., "Loading program", "Executing program") are silenced when
+ * the level is below "info".
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/** Returns the current SDK log level. */
+export declare function getLogLevel(): LogLevel;
+/**
+ * SDK logger object following console.log/warn/error/debug syntax.
+ * Respects the current log level set via setLogLevel().
+ */
+export declare const logger: {
+    log(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+};

package/dist/mainnet/utils/logger.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Log levels in ascending severity. Each level includes all levels above it.
+ * "silent" suppresses all output. "debug" enables everything.
+ *
+ * @example
+ * import { setLogLevel } from "@provablehq/sdk";
+ * setLogLevel("silent"); // suppress all SDK logging
+ */
+export type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
+/**
+ * Set the SDK log level. Levels are hierarchical:
+ * - "silent" — suppress all SDK logging
+ * - "error"  — only errors
+ * - "warn"   — errors + warnings
+ * - "info"   — errors + warnings + info (default)
+ * - "debug"  — everything including debug traces
+ *
+ * This controls both TS-side and WASM-side logging. WASM log calls
+ * (e.g., "Loading program", "Executing program") are silenced when
+ * the level is below "info".
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/** Returns the current SDK log level. */
+export declare function getLogLevel(): LogLevel;
+/**
+ * SDK logger object following console.log/warn/error/debug syntax.
+ * Respects the current log level set via setLogLevel().
+ */
+export declare const logger: {
+    log(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+};

package/dist/mainnet/wasm-Bnb_v1_O.js

@@ -0,0 +1,3 @@
+import { setWasmLogLevel } from '@provablehq/wasm/mainnet.js';
+export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Boolean, CallbackQuery, Ciphertext, ComputeKey, DynamicRecord, EncryptionToolkit, Execution, ExecutionRequest, ExecutionResponse, Field, GraphKey, Group, I128, I16, I32, I64, I8, Metadata, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramImports as ProgramImportsBuilder, ProgramManager, Proof, ProvingKey, ProvingRequest, QueryOption, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, U128, U16, U32, U64, U8, Value, VerifyingKey, ViewKey, getOrInitConsensusVersionTestHeights, initThreadPool, setWasmLogLevel, snarkVerify, snarkVerifyBatch, stringToField, verifyFunctionExecution } from '@provablehq/wasm/mainnet.js';
+//# sourceMappingURL=wasm-Bnb_v1_O.js.map

package/dist/mainnet/wasm-Bnb_v1_O.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-Bnb_v1_O.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/mainnet/wasm.cjs

@@ -0,0 +1,251 @@
+'use strict';
+
+var mainnet_js = require('@provablehq/wasm/mainnet.js');
+
+
+
+Object.defineProperty(exports, "Address", {
+    enumerable: true,
+    get: function () { return mainnet_js.Address; }
+});
+Object.defineProperty(exports, "Authorization", {
+    enumerable: true,
+    get: function () { return mainnet_js.Authorization; }
+});
+Object.defineProperty(exports, "BHP1024", {
+    enumerable: true,
+    get: function () { return mainnet_js.BHP1024; }
+});
+Object.defineProperty(exports, "BHP256", {
+    enumerable: true,
+    get: function () { return mainnet_js.BHP256; }
+});
+Object.defineProperty(exports, "BHP512", {
+    enumerable: true,
+    get: function () { return mainnet_js.BHP512; }
+});
+Object.defineProperty(exports, "BHP768", {
+    enumerable: true,
+    get: function () { return mainnet_js.BHP768; }
+});
+Object.defineProperty(exports, "Boolean", {
+    enumerable: true,
+    get: function () { return mainnet_js.Boolean; }
+});
+Object.defineProperty(exports, "CallbackQuery", {
+    enumerable: true,
+    get: function () { return mainnet_js.CallbackQuery; }
+});
+Object.defineProperty(exports, "Ciphertext", {
+    enumerable: true,
+    get: function () { return mainnet_js.Ciphertext; }
+});
+Object.defineProperty(exports, "ComputeKey", {
+    enumerable: true,
+    get: function () { return mainnet_js.ComputeKey; }
+});
+Object.defineProperty(exports, "DynamicRecord", {
+    enumerable: true,
+    get: function () { return mainnet_js.DynamicRecord; }
+});
+Object.defineProperty(exports, "EncryptionToolkit", {
+    enumerable: true,
+    get: function () { return mainnet_js.EncryptionToolkit; }
+});
+Object.defineProperty(exports, "Execution", {
+    enumerable: true,
+    get: function () { return mainnet_js.Execution; }
+});
+Object.defineProperty(exports, "ExecutionRequest", {
+    enumerable: true,
+    get: function () { return mainnet_js.ExecutionRequest; }
+});
+Object.defineProperty(exports, "ExecutionResponse", {
+    enumerable: true,
+    get: function () { return mainnet_js.ExecutionResponse; }
+});
+Object.defineProperty(exports, "Field", {
+    enumerable: true,
+    get: function () { return mainnet_js.Field; }
+});
+Object.defineProperty(exports, "GraphKey", {
+    enumerable: true,
+    get: function () { return mainnet_js.GraphKey; }
+});
+Object.defineProperty(exports, "Group", {
+    enumerable: true,
+    get: function () { return mainnet_js.Group; }
+});
+Object.defineProperty(exports, "I128", {
+    enumerable: true,
+    get: function () { return mainnet_js.I128; }
+});
+Object.defineProperty(exports, "I16", {
+    enumerable: true,
+    get: function () { return mainnet_js.I16; }
+});
+Object.defineProperty(exports, "I32", {
+    enumerable: true,
+    get: function () { return mainnet_js.I32; }
+});
+Object.defineProperty(exports, "I64", {
+    enumerable: true,
+    get: function () { return mainnet_js.I64; }
+});
+Object.defineProperty(exports, "I8", {
+    enumerable: true,
+    get: function () { return mainnet_js.I8; }
+});
+Object.defineProperty(exports, "Metadata", {
+    enumerable: true,
+    get: function () { return mainnet_js.Metadata; }
+});
+Object.defineProperty(exports, "OfflineQuery", {
+    enumerable: true,
+    get: function () { return mainnet_js.OfflineQuery; }
+});
+Object.defineProperty(exports, "Pedersen128", {
+    enumerable: true,
+    get: function () { return mainnet_js.Pedersen128; }
+});
+Object.defineProperty(exports, "Pedersen64", {
+    enumerable: true,
+    get: function () { return mainnet_js.Pedersen64; }
+});
+Object.defineProperty(exports, "Plaintext", {
+    enumerable: true,
+    get: function () { return mainnet_js.Plaintext; }
+});
+Object.defineProperty(exports, "Poseidon2", {
+    enumerable: true,
+    get: function () { return mainnet_js.Poseidon2; }
+});
+Object.defineProperty(exports, "Poseidon4", {
+    enumerable: true,
+    get: function () { return mainnet_js.Poseidon4; }
+});
+Object.defineProperty(exports, "Poseidon8", {
+    enumerable: true,
+    get: function () { return mainnet_js.Poseidon8; }
+});
+Object.defineProperty(exports, "PrivateKey", {
+    enumerable: true,
+    get: function () { return mainnet_js.PrivateKey; }
+});
+Object.defineProperty(exports, "PrivateKeyCiphertext", {
+    enumerable: true,
+    get: function () { return mainnet_js.PrivateKeyCiphertext; }
+});
+Object.defineProperty(exports, "Program", {
+    enumerable: true,
+    get: function () { return mainnet_js.Program; }
+});
+Object.defineProperty(exports, "ProgramImportsBuilder", {
+    enumerable: true,
+    get: function () { return mainnet_js.ProgramImports; }
+});
+Object.defineProperty(exports, "ProgramManager", {
+    enumerable: true,
+    get: function () { return mainnet_js.ProgramManager; }
+});
+Object.defineProperty(exports, "Proof", {
+    enumerable: true,
+    get: function () { return mainnet_js.Proof; }
+});
+Object.defineProperty(exports, "ProvingKey", {
+    enumerable: true,
+    get: function () { return mainnet_js.ProvingKey; }
+});
+Object.defineProperty(exports, "ProvingRequest", {
+    enumerable: true,
+    get: function () { return mainnet_js.ProvingRequest; }
+});
+Object.defineProperty(exports, "QueryOption", {
+    enumerable: true,
+    get: function () { return mainnet_js.QueryOption; }
+});
+Object.defineProperty(exports, "RecordCiphertext", {
+    enumerable: true,
+    get: function () { return mainnet_js.RecordCiphertext; }
+});
+Object.defineProperty(exports, "RecordPlaintext", {
+    enumerable: true,
+    get: function () { return mainnet_js.RecordPlaintext; }
+});
+Object.defineProperty(exports, "Scalar", {
+    enumerable: true,
+    get: function () { return mainnet_js.Scalar; }
+});
+Object.defineProperty(exports, "Signature", {
+    enumerable: true,
+    get: function () { return mainnet_js.Signature; }
+});
+Object.defineProperty(exports, "Transaction", {
+    enumerable: true,
+    get: function () { return mainnet_js.Transaction; }
+});
+Object.defineProperty(exports, "Transition", {
+    enumerable: true,
+    get: function () { return mainnet_js.Transition; }
+});
+Object.defineProperty(exports, "U128", {
+    enumerable: true,
+    get: function () { return mainnet_js.U128; }
+});
+Object.defineProperty(exports, "U16", {
+    enumerable: true,
+    get: function () { return mainnet_js.U16; }
+});
+Object.defineProperty(exports, "U32", {
+    enumerable: true,
+    get: function () { return mainnet_js.U32; }
+});
+Object.defineProperty(exports, "U64", {
+    enumerable: true,
+    get: function () { return mainnet_js.U64; }
+});
+Object.defineProperty(exports, "U8", {
+    enumerable: true,
+    get: function () { return mainnet_js.U8; }
+});
+Object.defineProperty(exports, "Value", {
+    enumerable: true,
+    get: function () { return mainnet_js.Value; }
+});
+Object.defineProperty(exports, "VerifyingKey", {
+    enumerable: true,
+    get: function () { return mainnet_js.VerifyingKey; }
+});
+Object.defineProperty(exports, "ViewKey", {
+    enumerable: true,
+    get: function () { return mainnet_js.ViewKey; }
+});
+Object.defineProperty(exports, "getOrInitConsensusVersionTestHeights", {
+    enumerable: true,
+    get: function () { return mainnet_js.getOrInitConsensusVersionTestHeights; }
+});
+Object.defineProperty(exports, "initThreadPool", {
+    enumerable: true,
+    get: function () { return mainnet_js.initThreadPool; }
+});
+Object.defineProperty(exports, "setWasmLogLevel", {
+    enumerable: true,
+    get: function () { return mainnet_js.setWasmLogLevel; }
+});
+Object.defineProperty(exports, "snarkVerify", {
+    enumerable: true,
+    get: function () { return mainnet_js.snarkVerify; }
+});
+Object.defineProperty(exports, "snarkVerifyBatch", {
+    enumerable: true,
+    get: function () { return mainnet_js.snarkVerifyBatch; }
+});
+Object.defineProperty(exports, "stringToField", {
+    enumerable: true,
+    get: function () { return mainnet_js.stringToField; }
+});
+Object.defineProperty(exports, "verifyFunctionExecution", {
+    enumerable: true,
+    get: function () { return mainnet_js.verifyFunctionExecution; }
+});
+//# sourceMappingURL=wasm.cjs.map

package/dist/mainnet/wasm.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/mainnet/wasm.d.cts

@@ -1 +1 @@
-export { Address, Authorization, Boolean, BHP256, BHP512, BHP768, BHP1024, Ciphertext, ComputeKey, DynamicRecord, EncryptionToolkit, ExecutionRequest, Execution, ExecutionResponse, Field, GraphKey, Group, I8, I16, I32, I64, I128, CallbackQuery, OfflineQuery, QueryOption, Metadata, Pedersen64, Pedersen128, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, Proof, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, stringToField, Transaction, Transition, U8, U16, U32, U64, U128, Value, VerifyingKey, ViewKey, initThreadPool, getOrInitConsensusVersionTestHeights, snarkVerify, snarkVerifyBatch, verifyFunctionExecution, } from "@provablehq/wasm/mainnet.js";
+export { Address, Authorization, Boolean, BHP256, BHP512, BHP768, BHP1024, Ciphertext, ComputeKey, DynamicRecord, EncryptionToolkit, ExecutionRequest, Execution, ExecutionResponse, Field, GraphKey, Group, I8, I16, I32, I64, I128, CallbackQuery, OfflineQuery, QueryOption, Metadata, Pedersen64, Pedersen128, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramImports as ProgramImportsBuilder, ProgramManager, Proof, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, stringToField, Transaction, Transition, U8, U16, U32, U64, U128, Value, VerifyingKey, ViewKey, initThreadPool, getOrInitConsensusVersionTestHeights, setWasmLogLevel, snarkVerify, snarkVerifyBatch, verifyFunctionExecution, } from "@provablehq/wasm/mainnet.js";

package/dist/mainnet/wasm.d.ts

@@ -1 +1 @@
-export { Address, Authorization, Boolean, BHP256, BHP512, BHP768, BHP1024, Ciphertext, ComputeKey, DynamicRecord, EncryptionToolkit, ExecutionRequest, Execution, ExecutionResponse, Field, GraphKey, Group, I8, I16, I32, I64, I128, CallbackQuery, OfflineQuery, QueryOption, Metadata, Pedersen64, Pedersen128, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, Proof, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, stringToField, Transaction, Transition, U8, U16, U32, U64, U128, Value, VerifyingKey, ViewKey, initThreadPool, getOrInitConsensusVersionTestHeights, snarkVerify, snarkVerifyBatch, verifyFunctionExecution, } from "@provablehq/wasm/mainnet.js";
+export { Address, Authorization, Boolean, BHP256, BHP512, BHP768, BHP1024, Ciphertext, ComputeKey, DynamicRecord, EncryptionToolkit, ExecutionRequest, Execution, ExecutionResponse, Field, GraphKey, Group, I8, I16, I32, I64, I128, CallbackQuery, OfflineQuery, QueryOption, Metadata, Pedersen64, Pedersen128, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramImports as ProgramImportsBuilder, ProgramManager, Proof, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, stringToField, Transaction, Transition, U8, U16, U32, U64, U128, Value, VerifyingKey, ViewKey, initThreadPool, getOrInitConsensusVersionTestHeights, setWasmLogLevel, snarkVerify, snarkVerifyBatch, verifyFunctionExecution, } from "@provablehq/wasm/mainnet.js";