zkcloudworker 0.2.7 → 0.2.9

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 localWorker: (cloud: Cloud) => Promise<zkCloudWorker> | undefined;
+    readonly chain: blockchain;
+    readonly localWorker?: (cloud: Cloud) => Promise<zkCloudWorker>;
     /**
      * 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
@@ -59,7 +63,7 @@ export declare class zkCloudWorkerClient {
     execute(data: {
         developer: string;
         repo: string;
-        task?: string;
+        task: string;
         userId?: string;
         args?: string;
         metadata?: string;

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");
@@ -222,8 +223,11 @@ class zkCloudWorkerClient {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
         if (this.jwt === "local") {
+            if (this.localWorker === undefined)
+                throw new Error("localWorker is undefined");
             switch (command) {
                 case "recursiveProof": {
+                    console.log("calculating recursive proof locally...");
                     const timeCreated = Date.now();
                     const jobId = this.generateJobId();
                     const job = {
@@ -243,7 +247,11 @@ class zkCloudWorkerClient {
                         jobStatus: "started",
                         maxAttempts: 0,
                     };
-                    const cloud = new local_1.LocalCloud({ job });
+                    const cloud = new local_1.LocalCloud({
+                        job,
+                        chain: this.chain,
+                        localWorker: this.localWorker,
+                    });
                     const worker = await this.localWorker(cloud);
                     if (worker === undefined)
                         throw new Error("worker is undefined");
@@ -252,16 +260,22 @@ class zkCloudWorkerClient {
                         data,
                     });
                     job.timeFinished = Date.now();
-                    job.jobStatus = "finished";
-                    job.result = proof;
                     job.maxAttempts = 1;
-                    this.localJobs.set(jobId, job);
+                    if (proof !== undefined) {
+                        job.jobStatus = "finished";
+                        job.result = proof;
+                    }
+                    else {
+                        job.jobStatus = "failed";
+                    }
+                    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,23 +294,32 @@ class zkCloudWorkerClient {
                         jobStatus: "started",
                         maxAttempts: 0,
                     };
-                    const cloud = new local_1.LocalCloud({ job });
+                    const cloud = new local_1.LocalCloud({
+                        job,
+                        chain: this.chain,
+                        localWorker: this.localWorker,
+                    });
                     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;
-                    this.localJobs.set(jobId, job);
+                    if (result !== undefined) {
+                        job.jobStatus = "finished";
+                        job.result = result;
+                    }
+                    else {
+                        job.jobStatus = "failed";
+                    }
+                    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 +356,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;
@@ -36,12 +38,40 @@ export declare abstract class Cloud {
     abstract saveFile(filename: string, value: Buffer): Promise<void>;
     abstract loadFile(filename: string): Promise<Buffer | undefined>;
     abstract loadEnvironment(password: string): Promise<void>;
+    abstract recursiveProof(data: {
+        transactions: string[];
+        task?: string;
+        userId?: string;
+        args?: string;
+        metadata?: string;
+    }): Promise<string>;
+    abstract execute(data: {
+        task: string;
+        userId?: string;
+        args?: string;
+        metadata?: string;
+    }): Promise<string>;
+    abstract addTask(data: {
+        task: string;
+        userId?: string;
+        args?: string;
+        metadata?: string;
+    }): Promise<string>;
+    abstract deleteTask(taskId: string): Promise<void>;
+    abstract processTasks(): 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(): Promise<string | undefined>;
 }

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,26 @@ 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() {
+        return undefined;
+    }
 }
 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,12 +2,16 @@
 import { Cache, PrivateKey } from "o1js";
 import { Cloud, zkCloudWorker } from "./cloud";
 import { JobData } from "./job";
+import { TaskData } from "./task";
+import { blockchain } from "../networks";
 export declare class LocalCloud extends Cloud {
-    data: Map<string, string>;
+    readonly localWorker: (cloud: Cloud) => Promise<zkCloudWorker>;
     constructor(params: {
         job: JobData;
+        chain: blockchain;
         cache?: Cache;
         stepId?: string;
+        localWorker: (cloud: Cloud) => Promise<zkCloudWorker>;
     });
     getDeployer(): Promise<PrivateKey>;
     log(msg: string): Promise<void>;
@@ -16,6 +20,28 @@ export declare class LocalCloud extends Cloud {
     saveFile(filename: string, value: Buffer): Promise<void>;
     loadFile(filename: string): Promise<Buffer | undefined>;
     loadEnvironment(password: string): Promise<void>;
+    private generateId;
+    recursiveProof(data: {
+        transactions: string[];
+        task?: string;
+        userId?: string;
+        args?: string;
+        metadata?: string;
+    }): Promise<string>;
+    execute(data: {
+        task: string;
+        userId?: string;
+        args?: string;
+        metadata?: string;
+    }): Promise<string>;
+    addTask(data: {
+        task: string;
+        userId?: string;
+        args?: string;
+        metadata?: string;
+    }): Promise<string>;
+    deleteTask(taskId: string): Promise<void>;
+    processTasks(): Promise<void>;
     static sequencer(params: {
         worker: zkCloudWorker;
         data: {
@@ -29,3 +55,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]: TaskData;
+    };
+    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 mina_1 = require("../mina");
+const files_1 = require("./files");
 class LocalCloud extends cloud_1.Cloud {
     constructor(params) {
-        const { job, cache, stepId } = params;
+        const { job, chain, cache, stepId, localWorker } = params;
         const { jobId, developer, repo, task, userId, args, metadata } = job;
         super({
             jobId: jobId,
@@ -18,8 +20,9 @@ class LocalCloud extends cloud_1.Cloud {
             args: args,
             metadata: metadata,
             isLocalCloud: true,
+            chain,
         });
-        this.data = new Map();
+        this.localWorker = localWorker;
     }
     async getDeployer() {
         throw new Error("Method not implemented.");
@@ -28,21 +31,157 @@ 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.");
     }
+    generateId() {
+        return "local." + Date.now().toString() + "." + (0, mina_1.makeString)(32);
+    }
+    async recursiveProof(data) {
+        console.log("calculating recursive proof locally...");
+        const timeCreated = Date.now();
+        const jobId = this.generateId();
+        const job = {
+            id: "local",
+            jobId: jobId,
+            developer: this.developer,
+            repo: this.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 LocalCloud({
+            job,
+            chain: this.chain,
+            localWorker: this.localWorker,
+        });
+        const worker = await this.localWorker(cloud);
+        if (worker === undefined)
+            throw new Error("worker is undefined");
+        const proof = await LocalCloud.sequencer({
+            worker,
+            data: { ...data, developer: this.developer, repo: this.repo },
+        });
+        job.timeFinished = Date.now();
+        job.jobStatus = "finished";
+        job.result = proof;
+        job.maxAttempts = 1;
+        LocalStorage.jobs[jobId] = job;
+        return jobId;
+    }
+    async execute(data) {
+        console.log("executing locally...");
+        const timeCreated = Date.now();
+        const jobId = this.generateId();
+        const job = {
+            id: "local",
+            jobId: jobId,
+            developer: this.developer,
+            repo: this.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 LocalCloud({
+            job,
+            chain: this.chain,
+            localWorker: this.localWorker,
+        });
+        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;
+        LocalStorage.jobs[jobId] = job;
+        return jobId;
+    }
+    async addTask(data) {
+        const taskId = this.generateId();
+        LocalStorage.tasks[taskId] = {
+            ...data,
+            id: "local",
+            taskId,
+            developer: this.developer,
+            repo: this.repo,
+        };
+        return taskId;
+    }
+    async deleteTask(taskId) {
+        delete LocalStorage.tasks[taskId];
+    }
+    async processTasks() {
+        for (const taskId in LocalStorage.tasks) {
+            const data = LocalStorage.tasks[taskId];
+            const jobId = this.generateId();
+            const timeCreated = Date.now();
+            const job = {
+                id: "local",
+                jobId: jobId,
+                developer: this.developer,
+                repo: this.repo,
+                task: data.task,
+                userId: data.userId,
+                args: data.args,
+                metadata: data.metadata,
+                txNumber: 1,
+                timeCreated: timeCreated,
+                timeCreatedString: new Date(timeCreated).toISOString(),
+                timeStarted: Date.now(),
+                jobStatus: "started",
+                maxAttempts: 0,
+            };
+            const cloud = new LocalCloud({
+                job,
+                chain: this.chain,
+                localWorker: this.localWorker,
+            });
+            const worker = await this.localWorker(cloud);
+            console.log("Executing task", { taskId, data });
+            const result = await worker.task();
+            job.timeFinished = Date.now();
+            job.maxAttempts = 1;
+            job.billedDuration = job.timeFinished - timeCreated;
+            if (result !== undefined) {
+                job.jobStatus = "finished";
+                job.result = result;
+            }
+            else {
+                job.jobStatus = "failed";
+            }
+            LocalStorage.jobs[jobId] = job;
+        }
+    }
     static async sequencer(params) {
         const { worker, data } = params;
         const { transactions } = data;
@@ -66,3 +205,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/cloud/task.d.ts

@@ -0,0 +1,10 @@
+export interface TaskData {
+    id: string;
+    taskId: string;
+    developer: string;
+    repo: string;
+    task: string;
+    userId?: string;
+    args?: string;
+    metadata?: string;
+}

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

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