zkcloudworker 0.2.8 → 0.2.10

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

@@ -1,5 +1,6 @@
 import { zkCloudWorker, Cloud } from "../cloud/cloud";
 import { blockchain } from "../networks";
+export type ApiCommand = "recursiveProof" | "execute" | "jobResult" | "deploy" | "queryBilling";
 /**
  * API class for interacting with the zkCloudWorker
  * @property jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
@@ -9,7 +10,7 @@ export declare class zkCloudWorkerClient {
     readonly jwt: string;
     readonly endpoint: string;
     readonly chain: blockchain;
-    readonly localWorker: (cloud: Cloud) => Promise<zkCloudWorker> | undefined;
+    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
@@ -63,7 +64,8 @@ export declare class zkCloudWorkerClient {
     execute(data: {
         developer: string;
         repo: string;
-        task?: string;
+        transactions: string[];
+        task: string;
         userId?: string;
         args?: string;
         metadata?: string;

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

@@ -223,76 +223,28 @@ 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 = {
-                        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");
-                    const proof = await local_1.LocalCloud.sequencer({
-                        worker,
+                    const jobId = await local_1.LocalCloud.run({
+                        command: "recursiveProof",
                         data,
+                        chain: this.chain,
+                        localWorker: this.localWorker,
                     });
-                    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": {
-                    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;
+                    const jobId = await local_1.LocalCloud.run({
+                        command: "execute",
+                        data,
+                        chain: this.chain,
+                        localWorker: this.localWorker,
+                    });
                     return {
                         success: true,
                         data: jobId,

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

@@ -38,6 +38,28 @@ 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: {
+        transactions: string[];
+        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;
@@ -50,7 +72,7 @@ export declare abstract class zkCloudWorker {
     deployedContracts(): Promise<DeployedSmartContract[]>;
     create(transaction: string): Promise<string | undefined>;
     merge(proof1: string, proof2: string): Promise<string | undefined>;
-    execute(): Promise<string | undefined>;
+    execute(transactions: string[]): Promise<string | undefined>;
     processTransactions(transactions: CloudTransaction[]): Promise<void>;
-    task(data: string): Promise<void>;
+    task(): Promise<string | undefined>;
 }

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

@@ -34,12 +34,14 @@ class zkCloudWorker {
         return undefined;
     }
     // Those methods should be implemented for anything except for recursive proofs
-    async execute() {
+    async execute(transactions) {
         return undefined;
     }
     // process the transactions received by the cloud
     async processTransactions(transactions) { }
     // process the task defined by the developer
-    async task(data) { }
+    async task() {
+        return undefined;
+    }
 }
 exports.zkCloudWorker = zkCloudWorker;

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

@@ -2,13 +2,17 @@
 import { Cache, PrivateKey } from "o1js";
 import { Cloud, zkCloudWorker } from "./cloud";
 import { JobData } from "./job";
+import { TaskData } from "./task";
 import { blockchain } from "../networks";
+import { ApiCommand } from "../api/api";
 export declare class LocalCloud extends Cloud {
+    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>;
@@ -17,6 +21,43 @@ 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 static generateId;
+    static run(params: {
+        command: ApiCommand;
+        data: {
+            developer: string;
+            repo: string;
+            transactions: string[];
+            task: string;
+            userId?: string;
+            args?: string;
+            metadata?: string;
+        };
+        chain: blockchain;
+        localWorker: (cloud: Cloud) => Promise<zkCloudWorker>;
+    }): Promise<string>;
+    recursiveProof(data: {
+        transactions: string[];
+        task?: string;
+        userId?: string;
+        args?: string;
+        metadata?: string;
+    }): Promise<string>;
+    execute(data: {
+        transactions: string[];
+        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: {
@@ -44,7 +85,7 @@ export declare class LocalStorage {
         };
     };
     static tasks: {
-        [key: string]: string;
+        [key: string]: TaskData;
     };
     static saveData(name: string): Promise<void>;
     static loadData(name: string): Promise<void>;

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

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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, chain, cache, stepId } = params;
+        const { job, chain, cache, stepId, localWorker } = params;
         const { jobId, developer, repo, task, userId, args, metadata } = job;
         super({
             jobId: jobId,
@@ -21,6 +22,7 @@ class LocalCloud extends cloud_1.Cloud {
             isLocalCloud: true,
             chain,
         });
+        this.localWorker = localWorker;
     }
     async getDeployer() {
         throw new Error("Method not implemented.");
@@ -45,6 +47,150 @@ class LocalCloud extends cloud_1.Cloud {
     async loadEnvironment(password) {
         throw new Error("Method not implemented.");
     }
+    static generateId() {
+        return "local." + Date.now().toString() + "." + (0, mina_1.makeString)(32);
+    }
+    static async run(params) {
+        const { command, data, chain, localWorker } = params;
+        console.log("executing locally command", command);
+        const { developer, repo, transactions, task, userId, args, metadata } = data;
+        const timeCreated = Date.now();
+        const jobId = LocalCloud.generateId();
+        const job = {
+            id: "local",
+            jobId,
+            developer,
+            repo,
+            task,
+            userId,
+            args,
+            metadata,
+            txNumber: command === "recursiveProof" ? transactions.length : 1,
+            timeCreated,
+            timeCreatedString: new Date(timeCreated).toISOString(),
+            timeStarted: timeCreated,
+            jobStatus: "started",
+            maxAttempts: 0,
+        };
+        const cloud = new LocalCloud({
+            job,
+            chain,
+            localWorker,
+        });
+        const worker = await localWorker(cloud);
+        if (worker === undefined)
+            throw new Error("worker is undefined");
+        const result = command === "recursiveProof"
+            ? await LocalCloud.sequencer({
+                worker,
+                data,
+            })
+            : command === "execute"
+                ? await worker.execute(transactions)
+                : undefined;
+        const timeFinished = Date.now();
+        if (result !== undefined) {
+            job.jobStatus = "finished";
+            job.timeFinished = timeFinished;
+            job.result = result;
+        }
+        else {
+            job.jobStatus = "failed";
+            job.timeFailed = timeFinished;
+        }
+        job.maxAttempts = 1;
+        job.billedDuration = timeFinished - timeCreated;
+        LocalStorage.jobs[jobId] = job;
+        return jobId;
+    }
+    async recursiveProof(data) {
+        return await LocalCloud.run({
+            command: "recursiveProof",
+            data: {
+                developer: this.developer,
+                repo: this.repo,
+                transactions: data.transactions,
+                task: data.task ?? "recursiveProof",
+                userId: data.userId,
+                args: data.args,
+                metadata: data.metadata,
+            },
+            chain: this.chain,
+            localWorker: this.localWorker,
+        });
+    }
+    async execute(data) {
+        return await LocalCloud.run({
+            command: "execute",
+            data: {
+                developer: this.developer,
+                repo: this.repo,
+                transactions: data.transactions,
+                task: data.task,
+                userId: data.userId,
+                args: data.args,
+                metadata: data.metadata,
+            },
+            chain: this.chain,
+            localWorker: this.localWorker,
+        });
+    }
+    async addTask(data) {
+        const taskId = LocalCloud.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 = LocalCloud.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;

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 });