zkcloudworker 0.2.9 → 0.2.11

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
@@ -63,6 +64,7 @@ export declare class zkCloudWorkerClient {
     execute(data: {
         developer: string;
         repo: string;
+        transactions: string[];
         task: string;
         userId?: string;
         args?: string;

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

@@ -227,92 +227,24 @@ class zkCloudWorkerClient {
                 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,
+                    const jobId = await local_1.LocalCloud.run({
+                        command: "recursiveProof",
+                        data,
                         chain: this.chain,
                         localWorker: this.localWorker,
                     });
-                    const worker = await this.localWorker(cloud);
-                    if (worker === undefined)
-                        throw new Error("worker is undefined");
-                    const proof = await local_1.LocalCloud.sequencer({
-                        worker,
-                        data,
-                    });
-                    job.timeFinished = Date.now();
-                    job.maxAttempts = 1;
-                    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 = {
-                        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,
+                    const jobId = await local_1.LocalCloud.run({
+                        command: "execute",
+                        data,
                         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.maxAttempts = 1;
-                    if (result !== undefined) {
-                        job.jobStatus = "finished";
-                        job.result = result;
-                    }
-                    else {
-                        job.jobStatus = "failed";
-                    }
-                    local_1.LocalStorage.jobs[jobId] = job;
                     return {
                         success: true,
                         data: jobId,

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

@@ -31,7 +31,7 @@ export declare abstract class Cloud {
         isLocalCloud?: boolean;
         chain: blockchain;
     });
-    abstract getDeployer(): Promise<PrivateKey>;
+    abstract getDeployer(): Promise<PrivateKey | undefined>;
     abstract log(msg: string): void;
     abstract getDataByKey(key: string): Promise<string | undefined>;
     abstract saveDataByKey(key: string, value: string): Promise<void>;
@@ -46,6 +46,7 @@ export declare abstract class Cloud {
         metadata?: string;
     }): Promise<string>;
     abstract execute(data: {
+        transactions: string[];
         task: string;
         userId?: string;
         args?: string;
@@ -71,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(): Promise<string | undefined>;
 }

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

@@ -34,7 +34,7 @@ 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

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

@@ -4,6 +4,7 @@ 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: {
@@ -13,14 +14,28 @@ export declare class LocalCloud extends Cloud {
         stepId?: string;
         localWorker: (cloud: Cloud) => Promise<zkCloudWorker>;
     });
-    getDeployer(): Promise<PrivateKey>;
+    getDeployer(): Promise<PrivateKey | undefined>;
     log(msg: string): Promise<void>;
     getDataByKey(key: string): Promise<string | undefined>;
     saveDataByKey(key: string, value: string): Promise<void>;
     saveFile(filename: string, value: Buffer): Promise<void>;
     loadFile(filename: string): Promise<Buffer | undefined>;
     loadEnvironment(password: string): Promise<void>;
-    private generateId;
+    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;
@@ -29,6 +44,7 @@ export declare class LocalCloud extends Cloud {
         metadata?: string;
     }): Promise<string>;
     execute(data: {
+        transactions: string[];
         task: string;
         userId?: string;
         args?: string;

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

@@ -25,7 +25,7 @@ class LocalCloud extends cloud_1.Cloud {
         this.localWorker = localWorker;
     }
     async getDeployer() {
-        throw new Error("Method not implemented.");
+        return (0, mina_1.getDeployer)();
     }
     async log(msg) {
         console.log("LocalCloud:", msg);
@@ -47,24 +47,25 @@ class LocalCloud extends cloud_1.Cloud {
     async loadEnvironment(password) {
         throw new Error("Method not implemented.");
     }
-    generateId() {
+    static generateId() {
         return "local." + Date.now().toString() + "." + (0, mina_1.makeString)(32);
     }
-    async recursiveProof(data) {
-        console.log("calculating recursive proof locally...");
+    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 = this.generateId();
+        const jobId = LocalCloud.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,
+            jobId,
+            developer,
+            repo,
+            task,
+            userId,
+            args,
+            metadata,
+            txNumber: command === "recursiveProof" ? transactions.length : 1,
             timeCreated,
             timeCreatedString: new Date(timeCreated).toISOString(),
             timeStarted: timeCreated,
@@ -73,61 +74,69 @@ class LocalCloud extends cloud_1.Cloud {
         };
         const cloud = new LocalCloud({
             job,
-            chain: this.chain,
-            localWorker: this.localWorker,
+            chain,
+            localWorker,
         });
-        const worker = await this.localWorker(cloud);
+        const worker = await 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;
+        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) {
-        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,
+        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,
         });
-        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();
+        const taskId = LocalCloud.generateId();
         LocalStorage.tasks[taskId] = {
             ...data,
             id: "local",
@@ -143,7 +152,7 @@ class LocalCloud extends cloud_1.Cloud {
     async processTasks() {
         for (const taskId in LocalStorage.tasks) {
             const data = LocalStorage.tasks[taskId];
-            const jobId = this.generateId();
+            const jobId = LocalCloud.generateId();
             const timeCreated = Date.now();
             const job = {
                 id: "local",

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

@@ -1,4 +1,4 @@
-export { initBlockchain, Memory, makeString, sleep, accountBalance, accountBalanceMina, formatTime, MinaNetworkInstance, currentNetwork, getNetworkIdHash, };
+export { initBlockchain, Memory, makeString, sleep, accountBalance, accountBalanceMina, formatTime, MinaNetworkInstance, currentNetwork, getNetworkIdHash, getDeployer, };
 import { PublicKey, PrivateKey, UInt64, Field } from "o1js";
 import { blockchain, MinaNetwork } from "./networks";
 interface MinaNetworkInstance {
@@ -11,6 +11,7 @@ interface MinaNetworkInstance {
 }
 declare let currentNetwork: MinaNetworkInstance | undefined;
 declare function getNetworkIdHash(): Field;
+declare function getDeployer(): PrivateKey;
 declare function initBlockchain(instance: blockchain, deployersNumber?: number): MinaNetworkInstance;
 declare function accountBalance(address: PublicKey): Promise<UInt64>;
 declare function accountBalanceMina(address: PublicKey): Promise<number>;

package/lib/ts/src/mina.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNetworkIdHash = exports.currentNetwork = exports.formatTime = exports.accountBalanceMina = exports.accountBalance = exports.sleep = exports.makeString = exports.Memory = exports.initBlockchain = void 0;
+exports.getDeployer = exports.getNetworkIdHash = exports.currentNetwork = exports.formatTime = exports.accountBalanceMina = exports.accountBalance = exports.sleep = exports.makeString = exports.Memory = exports.initBlockchain = void 0;
 const o1js_1 = require("o1js");
 const networks_1 = require("./networks");
 let currentNetwork = undefined;
@@ -12,6 +12,13 @@ function getNetworkIdHash() {
     return currentNetwork.networkIdHash;
 }
 exports.getNetworkIdHash = getNetworkIdHash;
+function getDeployer() {
+    if (currentNetwork === undefined) {
+        throw new Error("Network is not initialized");
+    }
+    return currentNetwork.keys[0].privateKey;
+}
+exports.getDeployer = getDeployer;
 /*function getNetworkIdHash(params: {
   chainId?: blockchain;
   verbose?: boolean;