zkcloudworker 0.6.1 → 0.6.3

package/lib/ts/src/api/api.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zkCloudWorkerClient = void 0;
 const axios_1 = __importDefault(require("axios"));
 const chalk_1 = __importDefault(require("chalk"));
-const mina_1 = require("../utils/mina");
+const utils_1 = require("../utils/utils");
 const local_1 = require("../cloud/local");
 const config_1 = __importDefault(require("../config"));
 const { ZKCLOUDWORKER_AUTH, ZKCLOUDWORKER_API } = config_1.default;
@@ -312,7 +312,7 @@ class zkCloudWorkerClient {
                         result: undefined,
                     };
                 }
-                await (0, mina_1.sleep)(errorDelay * errors);
+                await (0, utils_1.sleep)(errorDelay * errors);
             }
             else {
                 if (this.isError(result.data))
@@ -335,7 +335,7 @@ class zkCloudWorkerClient {
                         result: result.data,
                     };
                 }
-                await (0, mina_1.sleep)(interval);
+                await (0, utils_1.sleep)(interval);
             }
             attempts++;
         }

package/lib/ts/src/cloud/cache.d.ts

@@ -0,0 +1,97 @@
+export { Cache };
+/**
+ * Interface for storing and retrieving values, for caching.
+ * `read()` and `write()` can just throw errors on failure.
+ *
+ * The data that will be passed to the cache for writing is exhaustively described by the {@link CacheHeader} type.
+ * It represents one of the following:
+ * - The SRS. This is a deterministic lists of curve points (one per curve) that needs to be generated just once,
+ *   to be used for polynomial commitments.
+ * - Lagrange basis commitments. Similar to the SRS, this will be created once for every power-of-2 circuit size.
+ * - Prover and verifier keys for every compiled circuit.
+ *
+ * Per smart contract or ZkProgram, several different keys are created:
+ * - a step prover key (`step-pk`) and verification key (`step-vk`) _for every method_.
+ * - a wrap prover key (`wrap-pk`) and verification key (`wrap-vk`) for the entire contract.
+ */
+type Cache = {
+    /**
+     * Read a value from the cache.
+     *
+     * @param header A small header to identify what is read from the cache.
+     */
+    read(header: CacheHeader): Uint8Array | undefined;
+    /**
+     * Write a value to the cache.
+     *
+     * @param header A small header to identify what is written to the cache. This will be used by `read()` to retrieve the data.
+     * @param value The value to write to the cache, as a byte array.
+     */
+    write(header: CacheHeader, value: Uint8Array): void;
+    /**
+     * Indicates whether the cache is writable.
+     */
+    canWrite: boolean;
+    /**
+     * If `debug` is toggled, `read()` and `write()` errors are logged to the console.
+     *
+     * By default, cache errors are silent, because they don't necessarily represent an error condition,
+     * but could just be a cache miss, or file system permissions incompatible with writing data.
+     */
+    debug?: boolean;
+};
+type CommonHeader = {
+    /**
+     * Header version to avoid parsing incompatible headers.
+     */
+    version: number;
+    /**
+     * An identifier that is persistent even as versions of the data change. Safe to use as a file path.
+     */
+    persistentId: string;
+    /**
+     * A unique identifier for the data to be read. Safe to use as a file path.
+     */
+    uniqueId: string;
+    /**
+     * Specifies whether the data to be read is a utf8-encoded string or raw binary data. This was added
+     * because node's `fs.readFileSync` returns garbage when reading string files without specifying the encoding.
+     */
+    dataType: "string" | "bytes";
+};
+type StepKeyHeader<Kind> = {
+    kind: Kind;
+    programName: string;
+    methodName: string;
+    methodIndex: number;
+    hash: string;
+};
+type WrapKeyHeader<Kind> = {
+    kind: Kind;
+    programName: string;
+    hash: string;
+};
+type PlainHeader<Kind> = {
+    kind: Kind;
+};
+/**
+ * A header that is passed to the caching layer, to support rich caching strategies.
+ *
+ * Both `uniqueId` and `programId` can safely be used as a file path.
+ */
+type CacheHeader = (StepKeyHeader<"step-pk"> | StepKeyHeader<"step-vk"> | WrapKeyHeader<"wrap-pk"> | WrapKeyHeader<"wrap-vk"> | PlainHeader<"srs"> | PlainHeader<"lagrange-basis">) & CommonHeader;
+declare const Cache: {
+    /**
+     * Store data on the file system, in a directory of your choice.
+     *
+     * Data will be stored in two files per cache entry: a data file and a `.header` file.
+     * The header file just contains a unique string which is used to determine whether we can use the cached data.
+     *
+     * Note: this {@link Cache} only caches data in Node.js.
+     */
+    FileSystem: (cacheDirectory: string, debug?: boolean) => Cache;
+    /**
+     * Don't store anything.
+     */
+    None: Cache;
+};

package/lib/ts/src/cloud/cache.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const jsEnvironment = "node";
+const cacheHeaderVersion = 1;
+function withVersion(header, version = cacheHeaderVersion) {
+    let uniqueId = `${header.uniqueId}-${version}`;
+    return { ...header, version, uniqueId };
+}
+function readCache(cache, header, transform) {
+    try {
+        let result = cache.read(header);
+        if (result === undefined) {
+            if (cache.debug)
+                console.trace("cache miss");
+            return undefined;
+        }
+        if (transform === undefined)
+            return result;
+        return transform(result);
+    }
+    catch (e) {
+        if (cache.debug)
+            console.log("Failed to read cache", e);
+        return undefined;
+    }
+}
+function writeCache(cache, header, value) {
+    if (!cache.canWrite)
+        return false;
+    try {
+        cache.write(header, value);
+        return true;
+    }
+    catch (e) {
+        if (cache.debug)
+            console.log("Failed to write cache", e);
+        return false;
+    }
+}
+const None = {
+    read() {
+        throw Error("not available");
+    },
+    write() {
+        throw Error("not available");
+    },
+    canWrite: false,
+};
+const FileSystem = (cacheDirectory, debug) => ({
+    read({ persistentId, uniqueId, dataType }) {
+        if (jsEnvironment !== "node")
+            throw Error("file system not available");
+        // read current uniqueId, return data if it matches
+        let currentId = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(cacheDirectory, `${persistentId}.header`), "utf8");
+        if (currentId !== uniqueId)
+            return undefined;
+        if (dataType === "string") {
+            let string = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(cacheDirectory, persistentId), "utf8");
+            return new TextEncoder().encode(string);
+        }
+        else {
+            let buffer = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(cacheDirectory, persistentId));
+            return new Uint8Array(buffer.buffer);
+        }
+    },
+    write({ persistentId, uniqueId, dataType }, data) {
+        if (jsEnvironment !== "node")
+            throw Error("file system not available");
+        (0, node_fs_1.mkdirSync)(cacheDirectory, { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(cacheDirectory, `${persistentId}.header`), uniqueId, {
+            encoding: "utf8",
+        });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(cacheDirectory, persistentId), data, {
+            encoding: dataType === "string" ? "utf8" : undefined,
+        });
+    },
+    canWrite: jsEnvironment === "node",
+    debug,
+});
+const Cache = {
+    /**
+     * Store data on the file system, in a directory of your choice.
+     *
+     * Data will be stored in two files per cache entry: a data file and a `.header` file.
+     * The header file just contains a unique string which is used to determine whether we can use the cached data.
+     *
+     * Note: this {@link Cache} only caches data in Node.js.
+     */
+    FileSystem,
+    /**
+     * Don't store anything.
+     */
+    None,
+};
+exports.Cache = Cache;

package/lib/ts/src/cloud/cloud.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { Cache } from "o1js";
+import { Cache } from "./cache";
 import { blockchain } from "../networks";
 import { JobData } from "./job";
 export interface DeployedSmartContract {

package/lib/ts/src/cloud/index.d.ts

@@ -3,3 +3,4 @@ export * from "./files";
 export * from "./job";
 export * from "./task";
 export * from "./local";
+export * from "./cache";

package/lib/ts/src/cloud/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./files"), exports);
 __exportStar(require("./job"), exports);
 __exportStar(require("./task"), exports);
 __exportStar(require("./local"), exports);
+__exportStar(require("./cache"), exports);

package/lib/ts/src/cloud/local.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Cache } from "o1js";
+import { Cache } from "./cache";
 import { Cloud, zkCloudWorker } from "./cloud";
 import { JobData } from "./job";
 import { TaskData } from "./task";

package/lib/ts/src/cloud/local.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorage = exports.LocalCloud = void 0;
 const o1js_1 = require("o1js");
+const cache_1 = require("./cache");
 const cloud_1 = require("./cloud");
-const mina_1 = require("../utils/mina");
+const utils_1 = require("../utils/utils");
 const files_1 = require("./files");
 class LocalCloud extends cloud_1.Cloud {
     constructor(params) {
@@ -14,7 +15,7 @@ class LocalCloud extends cloud_1.Cloud {
             jobId: jobId,
             stepId: stepId ?? "stepId",
             taskId: taskId ?? "taskId",
-            cache: cache ?? o1js_1.Cache.FileSystem("./cache"),
+            cache: cache ?? cache_1.Cache.FileSystem("./cache"),
             developer: developer,
             repo: repo,
             task: task,
@@ -68,7 +69,7 @@ class LocalCloud extends cloud_1.Cloud {
         throw new Error("Method not implemented.");
     }
     static generateId() {
-        return "local." + Date.now().toString() + "." + (0, mina_1.makeString)(32);
+        return "local." + Date.now().toString() + "." + (0, utils_1.makeString)(32);
     }
     static async addTransactions(transactions) {
         const timeReceived = Date.now();

package/lib/ts/src/utils/fetch.d.ts

@@ -4,10 +4,10 @@ export declare function fetchMinaAccount(params: {
     tokenId?: string | Field | undefined;
     force?: boolean;
 }): Promise<{
+    account: undefined;
+} | {
     account: import("o1js/dist/node/bindings/mina-transaction/gen/transaction").Account;
     error: undefined;
-} | {
-    account: undefined;
 }>;
 export declare function fetchMinaActions(publicKey: PublicKey, fromActionState: Field, endActionState?: Field): Promise<{
     actions: string[][];

package/lib/ts/src/utils/fetch.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkMinaZkappTransaction = exports.fetchMinaActions = exports.fetchMinaAccount = void 0;
 const o1js_1 = require("o1js");
-const mina_1 = require("./mina");
+const utils_1 = require("./utils");
 async function fetchMinaAccount(params) {
     const { publicKey, tokenId, force } = params;
     const timeout = 1000 * 60 * 2; // 2 minutes
@@ -34,7 +34,7 @@ async function fetchMinaAccount(params) {
                 return result;
             }
         }
-        await (0, mina_1.sleep)(1000 * 5);
+        await (0, utils_1.sleep)(1000 * 5);
     }
     if (force === true)
         throw new Error(`fetchMinaAccount timeout
@@ -65,7 +65,7 @@ async function fetchMinaActions(publicKey, fromActionState, endActionState) {
         catch (error) {
             console.log("Error in fetchMinaActions", error.toString().substring(0, 300));
         }
-        await (0, mina_1.sleep)(1000 * 60 * 2);
+        await (0, utils_1.sleep)(1000 * 60 * 2);
     }
     console.log("Timeout in fetchMinaActions");
     return undefined;

package/lib/ts/src/utils/index.d.ts

@@ -4,3 +4,4 @@ export * from "./fields";
 export * from "./graphql";
 export * from "./fee";
 export * from "./mina";
+export * from "./utils";

package/lib/ts/src/utils/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./fields"), exports);
 __exportStar(require("./graphql"), exports);
 __exportStar(require("./fee"), exports);
 __exportStar(require("./mina"), exports);
+__exportStar(require("./utils"), exports);

package/lib/ts/src/utils/mina.d.ts

@@ -1,4 +1,4 @@
-export { initBlockchain, Memory, makeString, sleep, accountBalance, accountBalanceMina, formatTime, MinaNetworkInstance, currentNetwork, getNetworkIdHash, getCurrentNetwork, getDeployer, };
+export { initBlockchain, accountBalance, accountBalanceMina, MinaNetworkInstance, currentNetwork, getNetworkIdHash, getCurrentNetwork, getDeployer, };
 import { Mina, PublicKey, UInt64, Field } from "o1js";
 import { blockchain, MinaNetwork } from "../networks";
 interface MinaNetworkInstance {
@@ -13,11 +13,3 @@ declare function getDeployer(): Mina.TestPublicKey | undefined;
 declare function initBlockchain(instance: blockchain, deployersNumber?: number): Promise<MinaNetworkInstance>;
 declare function accountBalance(address: PublicKey): Promise<UInt64>;
 declare function accountBalanceMina(address: PublicKey): Promise<number>;
-declare function sleep(ms: number): Promise<unknown>;
-declare function makeString(length: number): string;
-declare function formatTime(ms: number): string;
-declare class Memory {
-    static rss: number;
-    constructor();
-    static info(description?: string, fullInfo?: boolean): void;
-}

package/lib/ts/src/utils/mina.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDeployer = exports.getCurrentNetwork = exports.getNetworkIdHash = exports.currentNetwork = exports.formatTime = exports.accountBalanceMina = exports.accountBalance = exports.sleep = exports.makeString = exports.Memory = exports.initBlockchain = void 0;
+exports.getDeployer = exports.getCurrentNetwork = exports.getNetworkIdHash = exports.currentNetwork = exports.accountBalanceMina = exports.accountBalance = exports.initBlockchain = void 0;
 const o1js_1 = require("o1js");
 const networks_1 = require("../networks");
 let currentNetwork = undefined;
@@ -32,6 +32,14 @@ async function initBlockchain(instance, deployersNumber = 0) {
     if (instance === "mainnet") {
         throw new Error("Mainnet is not supported yet by zkApps");
     }
+    if (currentNetwork !== undefined) {
+        if (currentNetwork?.network.chainId === instance) {
+            return currentNetwork;
+        }
+        else {
+            throw new Error(`Network is already initialized to different chain ${currentNetwork.network.chainId}, cannot initialize to ${instance}`);
+        }
+    }
     const networkIdHash = o1js_1.Poseidon.hash(o1js_1.Encoding.stringToFields(instance));
     // await used for compatibility with future versions of o1js
     if (instance === "local") {
@@ -100,67 +108,3 @@ async function accountBalanceMina(address) {
     return Number((await accountBalance(address)).toBigInt()) / 1e9;
 }
 exports.accountBalanceMina = accountBalanceMina;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-exports.sleep = sleep;
-function makeString(length) {
-    // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    let outString = ``;
-    // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    const inOptions = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`;
-    for (let i = 0; i < length; i++) {
-        outString += inOptions.charAt(Math.floor(Math.random() * inOptions.length));
-    }
-    return outString;
-}
-exports.makeString = makeString;
-function formatTime(ms) {
-    if (ms === undefined)
-        return "";
-    if (ms < 1000)
-        return ms.toString() + " ms";
-    if (ms < 60 * 1000)
-        return parseInt((ms / 1000).toString()).toString() + " sec";
-    if (ms < 60 * 60 * 1000) {
-        const minutes = parseInt((ms / 1000 / 60).toString());
-        const seconds = parseInt(((ms - minutes * 60 * 1000) / 1000).toString());
-        return minutes.toString() + " min " + seconds.toString() + " sec";
-    }
-    else {
-        const hours = parseInt((ms / 1000 / 60 / 60).toString());
-        const minutes = parseInt(((ms - hours * 60 * 60 * 1000) / 1000 / 60).toString());
-        return hours.toString() + " h " + minutes.toString() + " min";
-    }
-}
-exports.formatTime = formatTime;
-class Memory {
-    constructor() {
-        Memory.rss = 0;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    static info(description = ``, fullInfo = false) {
-        const memoryData = process.memoryUsage();
-        const formatMemoryUsage = (data) => `${Math.round(data / 1024 / 1024)} MB`;
-        const oldRSS = Memory.rss;
-        Memory.rss = Math.round(memoryData.rss / 1024 / 1024);
-        const memoryUsage = fullInfo
-            ? {
-                step: `${description}:`,
-                rssDelta: `${(oldRSS === 0
-                    ? 0
-                    : Memory.rss - oldRSS).toString()} MB -> Resident Set Size memory change`,
-                rss: `${formatMemoryUsage(memoryData.rss)} -> Resident Set Size - total memory allocated`,
-                heapTotal: `${formatMemoryUsage(memoryData.heapTotal)} -> total size of the allocated heap`,
-                heapUsed: `${formatMemoryUsage(memoryData.heapUsed)} -> actual memory used during the execution`,
-                external: `${formatMemoryUsage(memoryData.external)} -> V8 external memory`,
-            }
-            : `RSS memory ${description}: ${formatMemoryUsage(memoryData.rss)}${oldRSS === 0
-                ? ``
-                : `, changed by ` + (Memory.rss - oldRSS).toString() + ` MB`}`;
-        console.log(memoryUsage);
-    }
-}
-exports.Memory = Memory;
-// eslint-disable-next-line @typescript-eslint/no-inferrable-types
-Memory.rss = 0;

package/lib/ts/src/utils/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function makeString(length: number): string;
+export declare function formatTime(ms: number): string;
+export declare class Memory {
+    static rss: number;
+    constructor();
+    static info(description?: string, fullInfo?: boolean): void;
+}

package/lib/ts/src/utils/utils.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = exports.formatTime = exports.makeString = exports.sleep = void 0;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+function makeString(length) {
+    // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+    let outString = ``;
+    // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+    const inOptions = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`;
+    for (let i = 0; i < length; i++) {
+        outString += inOptions.charAt(Math.floor(Math.random() * inOptions.length));
+    }
+    return outString;
+}
+exports.makeString = makeString;
+function formatTime(ms) {
+    if (ms === undefined)
+        return "";
+    if (ms < 1000)
+        return ms.toString() + " ms";
+    if (ms < 60 * 1000)
+        return parseInt((ms / 1000).toString()).toString() + " sec";
+    if (ms < 60 * 60 * 1000) {
+        const minutes = parseInt((ms / 1000 / 60).toString());
+        const seconds = parseInt(((ms - minutes * 60 * 1000) / 1000).toString());
+        return minutes.toString() + " min " + seconds.toString() + " sec";
+    }
+    else {
+        const hours = parseInt((ms / 1000 / 60 / 60).toString());
+        const minutes = parseInt(((ms - hours * 60 * 60 * 1000) / 1000 / 60).toString());
+        return hours.toString() + " h " + minutes.toString() + " min";
+    }
+}
+exports.formatTime = formatTime;
+class Memory {
+    constructor() {
+        Memory.rss = 0;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+    static info(description = ``, fullInfo = false) {
+        const memoryData = process.memoryUsage();
+        const formatMemoryUsage = (data) => `${Math.round(data / 1024 / 1024)} MB`;
+        const oldRSS = Memory.rss;
+        Memory.rss = Math.round(memoryData.rss / 1024 / 1024);
+        const memoryUsage = fullInfo
+            ? {
+                step: `${description}:`,
+                rssDelta: `${(oldRSS === 0
+                    ? 0
+                    : Memory.rss - oldRSS).toString()} MB -> Resident Set Size memory change`,
+                rss: `${formatMemoryUsage(memoryData.rss)} -> Resident Set Size - total memory allocated`,
+                heapTotal: `${formatMemoryUsage(memoryData.heapTotal)} -> total size of the allocated heap`,
+                heapUsed: `${formatMemoryUsage(memoryData.heapUsed)} -> actual memory used during the execution`,
+                external: `${formatMemoryUsage(memoryData.external)} -> V8 external memory`,
+            }
+            : `RSS memory ${description}: ${formatMemoryUsage(memoryData.rss)}${oldRSS === 0
+                ? ``
+                : `, changed by ` + (Memory.rss - oldRSS).toString() + ` MB`}`;
+        console.log(memoryUsage);
+    }
+}
+exports.Memory = Memory;
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+Memory.rss = 0;