zkcloudworker 0.2.7 → 0.2.8

package/lib/ts/src/api/api.d.ts

@@ -1,5 +1,5 @@
 import { zkCloudWorker, Cloud } from "../cloud/cloud";
-import { JobData } from "../cloud/job";
+import { blockchain } from "../networks";
 /**
  * API class for interacting with the zkCloudWorker
  * @property jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
@@ -8,13 +8,17 @@ import { JobData } from "../cloud/job";
 export declare class zkCloudWorkerClient {
     readonly jwt: string;
     readonly endpoint: string;
-    readonly localJobs: Map<string, JobData>;
+    readonly chain: blockchain;
     readonly localWorker: (cloud: Cloud) => Promise<zkCloudWorker> | undefined;
     /**
      * Constructor for the API class
      * @param jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
      */
-    constructor(jwt: string, zkcloudworker?: ((cloud: Cloud) => Promise<zkCloudWorker>) | undefined);
+    constructor(params: {
+        jwt: string;
+        zkcloudworker?: (cloud: Cloud) => Promise<zkCloudWorker>;
+        chain?: blockchain;
+    });
     /**
      * Starts a new job for the proof calculation using serverless api call
      * The developer and name should correspond to the BackupPlugin of the API

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

@@ -19,10 +19,11 @@ class zkCloudWorkerClient {
      * Constructor for the API class
      * @param jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
      */
-    constructor(jwt, zkcloudworker = undefined) {
-        this.localJobs = new Map();
+    constructor(params) {
+        const { jwt, zkcloudworker, chain } = params;
         this.jwt = jwt;
         this.endpoint = ZKCLOUDWORKER_API;
+        this.chain = chain ?? "berkeley";
         if (jwt === "local") {
             if (zkcloudworker === undefined)
                 throw new Error("worker is required for local mode");
@@ -224,6 +225,7 @@ class zkCloudWorkerClient {
         if (this.jwt === "local") {
             switch (command) {
                 case "recursiveProof": {
+                    console.log("calculating recursive proof locally...");
                     const timeCreated = Date.now();
                     const jobId = this.generateJobId();
                     const job = {
@@ -243,7 +245,7 @@ class zkCloudWorkerClient {
                         jobStatus: "started",
                         maxAttempts: 0,
                     };
-                    const cloud = new local_1.LocalCloud({ job });
+                    const cloud = new local_1.LocalCloud({ job, chain: this.chain });
                     const worker = await this.localWorker(cloud);
                     if (worker === undefined)
                         throw new Error("worker is undefined");
@@ -255,13 +257,14 @@ class zkCloudWorkerClient {
                     job.jobStatus = "finished";
                     job.result = proof;
                     job.maxAttempts = 1;
-                    this.localJobs.set(jobId, job);
+                    local_1.LocalStorage.jobs[jobId] = job;
                     return {
                         success: true,
                         data: jobId,
                     };
                 }
                 case "execute": {
+                    console.log("executing locally...");
                     const timeCreated = Date.now();
                     const jobId = this.generateJobId();
                     const job = {
@@ -280,7 +283,7 @@ class zkCloudWorkerClient {
                         jobStatus: "started",
                         maxAttempts: 0,
                     };
-                    const cloud = new local_1.LocalCloud({ job });
+                    const cloud = new local_1.LocalCloud({ job, chain: this.chain });
                     const worker = await this.localWorker(cloud);
                     if (worker === undefined)
                         throw new Error("worker is undefined");
@@ -289,14 +292,14 @@ class zkCloudWorkerClient {
                     job.jobStatus = "finished";
                     job.result = result;
                     job.maxAttempts = 1;
-                    this.localJobs.set(jobId, job);
+                    local_1.LocalStorage.jobs[jobId] = job;
                     return {
                         success: true,
                         data: jobId,
                     };
                 }
                 case "jobResult": {
-                    const job = this.localJobs.get(data.jobId);
+                    const job = local_1.LocalStorage.jobs[data.jobId];
                     if (job === undefined) {
                         return {
                             success: false,
@@ -333,6 +336,7 @@ class zkCloudWorkerClient {
                 command: command,
                 jwtToken: this.jwt,
                 data: data,
+                chain: this.chain,
             };
             try {
                 const response = await axios_1.default.post(this.endpoint, apiData);

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

@@ -16,6 +16,7 @@ export declare abstract class Cloud {
     readonly userId?: string;
     readonly args?: string;
     readonly metadata?: string;
+    readonly chain: blockchain;
     readonly isLocalCloud: boolean;
     constructor(params: {
         jobId: string;
@@ -28,6 +29,7 @@ export declare abstract class Cloud {
         args?: string;
         metadata?: string;
         isLocalCloud?: boolean;
+        chain: blockchain;
     });
     abstract getDeployer(): Promise<PrivateKey>;
     abstract log(msg: string): void;
@@ -37,11 +39,18 @@ export declare abstract class Cloud {
     abstract loadFile(filename: string): Promise<Buffer | undefined>;
     abstract loadEnvironment(password: string): Promise<void>;
 }
+export interface CloudTransaction {
+    txId: string;
+    transaction: string;
+    timeReceived: number;
+}
 export declare abstract class zkCloudWorker {
     readonly cloud: Cloud;
     constructor(cloud: Cloud);
-    abstract deployedContracts(): Promise<DeployedSmartContract[]>;
-    abstract create(transaction: string): Promise<string | undefined>;
-    abstract merge(proof1: string, proof2: string): Promise<string | undefined>;
-    abstract execute(): Promise<string | undefined>;
+    deployedContracts(): Promise<DeployedSmartContract[]>;
+    create(transaction: string): Promise<string | undefined>;
+    merge(proof1: string, proof2: string): Promise<string | undefined>;
+    execute(): Promise<string | undefined>;
+    processTransactions(transactions: CloudTransaction[]): Promise<void>;
+    task(data: string): Promise<void>;
 }

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zkCloudWorker = exports.Cloud = void 0;
 class Cloud {
     constructor(params) {
-        const { jobId, stepId, cache, developer, repo, task, userId, args, metadata, isLocalCloud, } = params;
+        const { jobId, stepId, cache, developer, repo, task, userId, args, metadata, isLocalCloud, chain, } = params;
         this.jobId = jobId;
         this.stepId = stepId;
         this.cache = cache;
@@ -14,6 +14,7 @@ class Cloud {
         this.args = args;
         this.metadata = metadata;
         this.isLocalCloud = isLocalCloud ?? false;
+        this.chain = chain;
     }
 }
 exports.Cloud = Cloud;
@@ -21,5 +22,24 @@ class zkCloudWorker {
     constructor(cloud) {
         this.cloud = cloud;
     }
+    // To verify the SmartContract code
+    async deployedContracts() {
+        return [];
+    }
+    // Those methods should be implemented for recursive proofs calculations
+    async create(transaction) {
+        return undefined;
+    }
+    async merge(proof1, proof2) {
+        return undefined;
+    }
+    // Those methods should be implemented for anything except for recursive proofs
+    async execute() {
+        return undefined;
+    }
+    // process the transactions received by the cloud
+    async processTransactions(transactions) { }
+    // process the task defined by the developer
+    async task(data) { }
 }
 exports.zkCloudWorker = zkCloudWorker;

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

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+export declare function saveFile(params: {
+    data: any;
+    filename: string;
+}): Promise<string | undefined>;
+export declare function loadFile(filename: string): Promise<any>;
+export declare function saveBinaryFile(params: {
+    data: any;
+    filename: string;
+}): Promise<string | undefined>;
+export declare function loadBinaryFile(filename: string): Promise<Buffer | undefined>;

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

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBinaryFile = exports.saveBinaryFile = exports.loadFile = exports.saveFile = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+async function saveFile(params) {
+    const { data, filename } = params;
+    const folder = "./data/";
+    const name = folder + filename + ".json";
+    try {
+        await promises_1.default.access("./data");
+    }
+    catch (e) {
+        // if not, create it
+        await promises_1.default.mkdir("./data");
+    }
+    try {
+        await promises_1.default.writeFile(name, JSON.stringify(data, null, 2));
+        return name;
+    }
+    catch (e) {
+        console.error(`Error writing file ${name}`);
+        return undefined;
+    }
+}
+exports.saveFile = saveFile;
+async function loadFile(filename) {
+    const name = "./data/" + filename + ".json";
+    try {
+        const filedata = await promises_1.default.readFile(name, "utf8");
+        const data = JSON.parse(filedata);
+        return data;
+    }
+    catch (e) {
+        console.error(`File ${name} does not exist or has wrong format`);
+        return undefined;
+    }
+}
+exports.loadFile = loadFile;
+async function saveBinaryFile(params) {
+    const { data, filename } = params;
+    const folder = "./data/";
+    const name = folder + filename + ".bin";
+    try {
+        await promises_1.default.access("./data");
+    }
+    catch (e) {
+        // if not, create it
+        await promises_1.default.mkdir("./data");
+    }
+    try {
+        await promises_1.default.writeFile(name, data);
+        return name;
+    }
+    catch (e) {
+        console.error(`Error writing file ${name}`);
+        return undefined;
+    }
+}
+exports.saveBinaryFile = saveBinaryFile;
+async function loadBinaryFile(filename) {
+    const name = "./data/" + filename + ".bin";
+    try {
+        const data = await promises_1.default.readFile(name);
+        return data;
+    }
+    catch (e) {
+        console.error(`File ${name} does not exist or has wrong format`);
+        return undefined;
+    }
+}
+exports.loadBinaryFile = loadBinaryFile;

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

@@ -2,10 +2,11 @@
 import { Cache, PrivateKey } from "o1js";
 import { Cloud, zkCloudWorker } from "./cloud";
 import { JobData } from "./job";
+import { blockchain } from "../networks";
 export declare class LocalCloud extends Cloud {
-    data: Map<string, string>;
     constructor(params: {
         job: JobData;
+        chain: blockchain;
         cache?: Cache;
         stepId?: string;
     });
@@ -29,3 +30,22 @@ export declare class LocalCloud extends Cloud {
         };
     }): Promise<string>;
 }
+export declare class LocalStorage {
+    static jobs: {
+        [key: string]: JobData;
+    };
+    static data: {
+        [key: string]: string;
+    };
+    static transactions: {
+        [key: string]: {
+            transaction: string;
+            timeReceived: number;
+        };
+    };
+    static tasks: {
+        [key: string]: string;
+    };
+    static saveData(name: string): Promise<void>;
+    static loadData(name: string): Promise<void>;
+}

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

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalCloud = void 0;
+exports.LocalStorage = exports.LocalCloud = void 0;
 const o1js_1 = require("o1js");
 const cloud_1 = require("./cloud");
+const files_1 = require("./files");
 class LocalCloud extends cloud_1.Cloud {
     constructor(params) {
-        const { job, cache, stepId } = params;
+        const { job, chain, cache, stepId } = params;
         const { jobId, developer, repo, task, userId, args, metadata } = job;
         super({
             jobId: jobId,
@@ -18,8 +19,8 @@ class LocalCloud extends cloud_1.Cloud {
             args: args,
             metadata: metadata,
             isLocalCloud: true,
+            chain,
         });
-        this.data = new Map();
     }
     async getDeployer() {
         throw new Error("Method not implemented.");
@@ -28,17 +29,18 @@ class LocalCloud extends cloud_1.Cloud {
         console.log("LocalCloud:", msg);
     }
     async getDataByKey(key) {
-        const value = this.data.get(key);
+        const value = LocalStorage.data[key];
         return value;
     }
     async saveDataByKey(key, value) {
-        this.data.set(key, value);
+        LocalStorage.data[key] = value;
     }
     async saveFile(filename, value) {
-        throw new Error("Method not implemented.");
+        await (0, files_1.saveBinaryFile)({ data: value, filename });
     }
     async loadFile(filename) {
-        throw new Error("Method not implemented.");
+        const data = await (0, files_1.loadBinaryFile)(filename);
+        return data;
     }
     async loadEnvironment(password) {
         throw new Error("Method not implemented.");
@@ -66,3 +68,30 @@ class LocalCloud extends cloud_1.Cloud {
     }
 }
 exports.LocalCloud = LocalCloud;
+class LocalStorage {
+    static async saveData(name) {
+        const data = {
+            jobs: LocalStorage.jobs,
+            data: LocalStorage.data,
+            transactions: LocalStorage.transactions,
+            tasks: LocalStorage.tasks,
+        };
+        const filename = name + ".cloud";
+        await (0, files_1.saveFile)({ data, filename });
+    }
+    static async loadData(name) {
+        const filename = name + ".cloud";
+        const data = await (0, files_1.loadFile)(filename);
+        if (data === undefined)
+            return;
+        LocalStorage.jobs = data.jobs;
+        LocalStorage.data = data.data;
+        LocalStorage.transactions = data.transactions;
+        LocalStorage.tasks = data.tasks;
+    }
+}
+exports.LocalStorage = LocalStorage;
+LocalStorage.jobs = {};
+LocalStorage.data = {};
+LocalStorage.transactions = {};
+LocalStorage.tasks = {};