zkcloudworker 0.2.6 → 0.2.8

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

@@ -1,4 +1,5 @@
 import { zkCloudWorker, Cloud } from "../cloud/cloud";
+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
@@ -7,13 +8,17 @@ import { zkCloudWorker, Cloud } from "../cloud/cloud";
 export declare class zkCloudWorkerClient {
     readonly jwt: string;
     readonly endpoint: string;
-    readonly localJobs: Map<string, string>;
+    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,8 +225,27 @@ 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 cloud = new local_1.LocalCloud({ jobId, ...data });
+                    const job = {
+                        id: "local",
+                        jobId: jobId,
+                        developer: data.developer,
+                        repo: data.repo,
+                        task: data.task,
+                        userId: data.userId,
+                        args: data.args,
+                        metadata: data.metadata,
+                        filename: "recursiveProof.json",
+                        txNumber: data.transactions.length,
+                        timeCreated,
+                        timeCreatedString: new Date(timeCreated).toISOString(),
+                        timeStarted: timeCreated,
+                        jobStatus: "started",
+                        maxAttempts: 0,
+                    };
+                    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");
@@ -233,38 +253,66 @@ class zkCloudWorkerClient {
                         worker,
                         data,
                     });
-                    this.localJobs.set(jobId, proof);
+                    job.timeFinished = Date.now();
+                    job.jobStatus = "finished";
+                    job.result = proof;
+                    job.maxAttempts = 1;
+                    local_1.LocalStorage.jobs[jobId] = job;
                     return {
                         success: true,
                         data: jobId,
                     };
                 }
-                case "execute":
+                case "execute": {
+                    console.log("executing locally...");
+                    const timeCreated = Date.now();
+                    const jobId = this.generateJobId();
+                    const job = {
+                        id: "local",
+                        jobId: jobId,
+                        developer: data.developer,
+                        repo: data.repo,
+                        task: data.task,
+                        userId: data.userId,
+                        args: data.args,
+                        metadata: data.metadata,
+                        txNumber: 1,
+                        timeCreated,
+                        timeCreatedString: new Date(timeCreated).toISOString(),
+                        timeStarted: timeCreated,
+                        jobStatus: "started",
+                        maxAttempts: 0,
+                    };
+                    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");
+                    const result = await worker.execute();
+                    job.timeFinished = Date.now();
+                    job.jobStatus = "finished";
+                    job.result = result;
+                    job.maxAttempts = 1;
+                    local_1.LocalStorage.jobs[jobId] = job;
                     return {
                         success: true,
-                        data: "local_execute",
+                        data: jobId,
                     };
-                case "jobResult":
-                    const result = this.localJobs.get(data.jobId);
-                    if (result === undefined) {
+                }
+                case "jobResult": {
+                    const job = local_1.LocalStorage.jobs[data.jobId];
+                    if (job === undefined) {
                         return {
-                            success: true,
-                            data: {
-                                success: false,
-                                error: "local job not found",
-                            },
+                            success: false,
+                            error: "local job not found",
                         };
                     }
                     else {
                         return {
                             success: true,
-                            data: {
-                                result,
-                                jobId: data.jobId,
-                                jobStatus: "finished",
-                            },
+                            data: job,
                         };
                     }
+                }
                 case "deploy":
                     return {
                         success: true,
@@ -288,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/job.d.ts

@@ -0,0 +1,23 @@
+export type JobStatus = "created" | "started" | "finished" | "failed" | "used";
+export interface JobData {
+    id: string;
+    jobId: string;
+    developer: string;
+    repo: string;
+    task?: string;
+    userId?: string;
+    args?: string;
+    metadata?: string;
+    filename?: string;
+    txNumber: number;
+    timeCreated: number;
+    timeCreatedString: string;
+    timeStarted?: number;
+    timeFinished?: number;
+    timeFailed?: number;
+    timeUsed?: number;
+    billedDuration?: number;
+    jobStatus: JobStatus;
+    maxAttempts: number;
+    result?: string;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,18 +1,14 @@
 /// <reference types="node" />
 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: {
-        jobId: string;
-        stepId?: string;
+        job: JobData;
+        chain: blockchain;
         cache?: Cache;
-        developer: string;
-        repo: string;
-        task?: string;
-        userId?: string;
-        args?: string;
-        metadata?: string;
+        stepId?: string;
     });
     getDeployer(): Promise<PrivateKey>;
     log(msg: string): Promise<void>;
@@ -34,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,13 @@
 "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 { jobId, stepId, cache, developer, repo, task, userId, args, metadata, } = params;
+        const { job, chain, cache, stepId } = params;
+        const { jobId, developer, repo, task, userId, args, metadata } = job;
         super({
             jobId: jobId,
             stepId: stepId ?? "stepId",
@@ -17,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.");
@@ -27,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.");
@@ -65,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 = {};

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

@@ -1,6 +1,7 @@
 export * from "./api/api";
 export * from "./cloud/cloud";
 export * from "./cloud/local";
+export * from "./cloud/job";
 export * from "./mina";
 export * from "./fee";
 export * from "./networks";

package/lib/ts/src/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api/api"), exports);
 __exportStar(require("./cloud/cloud"), exports);
 __exportStar(require("./cloud/local"), exports);
+__exportStar(require("./cloud/job"), exports);
 __exportStar(require("./mina"), exports);
 __exportStar(require("./fee"), exports);
 __exportStar(require("./networks"), exports);