zkcloudworker 0.4.6 → 0.5.0

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

@@ -108,6 +108,7 @@ export declare class zkCloudWorkerClient {
      * Gets the result of the job using serverless api call
      * @param data the data for the jobResult call
      * @param data.jobId the jobId of the job
+     * @param data.includeLogs include logs in the result, default is false
      * @returns { success: boolean, error?: string, result?: any }
      * where result is the result of the job
      * if the job is not finished yet, the result will be undefined
@@ -117,6 +118,7 @@ export declare class zkCloudWorkerClient {
      */
     jobResult(data: {
         jobId: string;
+        includeLogs?: boolean;
     }): Promise<{
         success: boolean;
         error?: string;
@@ -169,6 +171,7 @@ export declare class zkCloudWorkerClient {
      * @param data.maxAttempts the maximum number of attempts, default is 360 (2 hours)
      * @param data.interval the interval between attempts, default is 20000 (20 seconds)
      * @param data.maxErrors the maximum number of network errors, default is 10
+     * @param data.printLogs print logs, default is true
      * @returns { success: boolean, error?: string, result?: any }
      * where result is the result of the job
      */
@@ -177,6 +180,7 @@ export declare class zkCloudWorkerClient {
         maxAttempts?: number;
         interval?: number;
         maxErrors?: number;
+        printLogs?: boolean;
     }): Promise<{
         success: boolean;
         error?: string;

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zkCloudWorkerClient = void 0;
 const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
 const mina_1 = require("../mina");
 const local_1 = require("../cloud/local");
 const config_1 = __importDefault(require("../config"));
@@ -85,13 +86,23 @@ class zkCloudWorkerClient {
                 success: false,
                 error: result.error,
             };
-        else
+        else if (result.success === false || result.data?.success === false)
+            return {
+                success: false,
+                error: result.error ?? result.data?.error ?? "execute call failed",
+            };
+        else if (result.success === true && result.data?.success === true)
             return {
                 success: result.success,
-                jobId: data.mode === "sync" ? undefined : result.data,
+                jobId: data.mode === "sync" ? undefined : result.data.jobId,
                 result: data.mode === "sync" ? result.data : undefined,
                 error: result.error,
             };
+        else
+            return {
+                success: false,
+                error: "execute call error",
+            };
     }
     /**
      * Starts a new job for the function call using serverless api call
@@ -124,6 +135,7 @@ class zkCloudWorkerClient {
      * Gets the result of the job using serverless api call
      * @param data the data for the jobResult call
      * @param data.jobId the jobId of the job
+     * @param data.includeLogs include logs in the result, default is false
      * @returns { success: boolean, error?: string, result?: any }
      * where result is the result of the job
      * if the job is not finished yet, the result will be undefined
@@ -225,18 +237,39 @@ class zkCloudWorkerClient {
      * @param data.maxAttempts the maximum number of attempts, default is 360 (2 hours)
      * @param data.interval the interval between attempts, default is 20000 (20 seconds)
      * @param data.maxErrors the maximum number of network errors, default is 10
+     * @param data.printLogs print logs, default is true
      * @returns { success: boolean, error?: string, result?: any }
      * where result is the result of the job
      */
     async waitForJobResult(data) {
         const maxAttempts = data?.maxAttempts ?? 360; // 2 hours
-        const interval = data?.interval ?? 20000;
+        const interval = data?.interval ?? 10000;
         const maxErrors = data?.maxErrors ?? 10;
         const errorDelay = 30000; // 30 seconds
+        const printedLogs = [];
+        const printLogs = data.printLogs ?? true;
+        function print(logs) {
+            logs.forEach((log) => {
+                if (printedLogs.includes(log) === false) {
+                    printedLogs.push(log);
+                    // replace all occurrences of "error" with red color
+                    const text = log.replace(/error/gi, (matched) => chalk_1.default.red(matched));
+                    console.log(text);
+                }
+            });
+        }
         let attempts = 0;
         let errors = 0;
         while (attempts < maxAttempts) {
-            const result = await this.apiHub("jobResult", data);
+            const result = await this.apiHub("jobResult", {
+                jobId: data.jobId,
+                includeLogs: printLogs,
+            });
+            if (printLogs === true &&
+                result?.data?.logs !== undefined &&
+                result?.data?.logs !== null &&
+                Array.isArray(result.data.logs) === true)
+                print(result.data.logs);
             if (result.success === false) {
                 errors++;
                 if (errors > maxErrors) {
@@ -262,6 +295,13 @@ class zkCloudWorkerClient {
                         result: result.data,
                     };
                 }
+                else if (result.data?.jobStatus === "failed") {
+                    return {
+                        success: false,
+                        error: "Job failed",
+                        result: result.data,
+                    };
+                }
                 await (0, mina_1.sleep)(interval);
             }
             attempts++;

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

@@ -1,5 +1,10 @@
 import { blockchain } from "../networks";
 export type JobStatus = "created" | "started" | "finished" | "failed" | "used";
+export interface LogStream {
+    logGroupName: string;
+    logStreamName: string;
+    awsRequestId: string;
+}
 export interface JobData {
     id: string;
     jobId: string;
@@ -29,4 +34,6 @@ export interface JobData {
     jobStatus: JobStatus;
     maxAttempts: number;
     result?: string;
+    logStreams?: LogStream[];
+    logs?: string[];
 }

package/lib/ts/src/config.d.ts

@@ -2,5 +2,6 @@ declare const config: {
     MINAFEE: string;
     ZKCLOUDWORKER_AUTH: string;
     ZKCLOUDWORKER_API: string;
+    NATS_SERVER: string;
 };
 export default config;

package/lib/ts/src/config.js

@@ -4,5 +4,6 @@ const config = {
     MINAFEE: "200000000",
     ZKCLOUDWORKER_AUTH: "M6t4jtbBAFFXhLERHQWyEB9JA9xi4cWqmYduaCXtbrFjb7yaY7TyaXDunKDJNiUTBEcyUomNXJgC",
     ZKCLOUDWORKER_API: "https://cuq99yahhi.execute-api.eu-west-1.amazonaws.com/dev/zkcloudworker",
+    NATS_SERVER: "nats.socialcap.dev:4222",
 };
 exports.default = config;

package/lib/ts/src/encryption/encryption.d.ts

@@ -0,0 +1,12 @@
+import { Field, Group } from "o1js";
+export interface CipherTextObject {
+    cipherText: Field[];
+    publicKey: Group;
+}
+export declare class CipherText {
+    static stringify(cipherText: CipherTextObject): string;
+    static parse(jsonStr: string): CipherTextObject;
+    static encrypt(message: string, publicId: string): string;
+    static decrypt(cipherText: string, privateKey: string): string;
+    static initialize(): Promise<void>;
+}

package/lib/ts/src/encryption/encryption.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CipherText = void 0;
+const o1js_1 = require("o1js");
+class CipherText {
+    static stringify(cipherText) {
+        return JSON.stringify(cipherText);
+    }
+    static parse(jsonStr) {
+        let obj = JSON.parse(jsonStr);
+        return {
+            publicKey: new o1js_1.Group(obj.publicKey),
+            cipherText: (obj.cipherText || []).map((t) => (0, o1js_1.Field)(t)),
+        };
+    }
+    static encrypt(message, publicId) {
+        try {
+            let fields = o1js_1.Encoding.stringToFields(message);
+            let encrypted = o1js_1.Encryption.encrypt(fields, o1js_1.PublicKey.fromBase58(publicId));
+            return CipherText.stringify(encrypted);
+        }
+        catch (err) {
+            throw Error(`Could not encrypt message='${message}' using key='${publicId}'.` +
+                ` Error ${err}`);
+        }
+    }
+    static decrypt(cipherText, privateKey) {
+        try {
+            let fields = o1js_1.Encryption.decrypt(CipherText.parse(cipherText), o1js_1.PrivateKey.fromBase58(privateKey));
+            let decrypted = o1js_1.Encoding.stringFromFields(fields);
+            return decrypted;
+        }
+        catch (err) {
+            throw Error(`Could not decrypt cipher='${cipherText}'.` + ` Error ${err}`);
+        }
+    }
+    static async initialize() {
+        await (0, o1js_1.initializeBindings)();
+    }
+}
+exports.CipherText = CipherText;

package/lib/ts/src/encryption/messages.d.ts

@@ -0,0 +1,2 @@
+export declare function postReadyMessage(clientAddress: string, workerAddress: string): Promise<any>;
+export declare function postDoneMessage(clientAddress: string, encrypted: string): Promise<any>;

package/lib/ts/src/encryption/messages.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postDoneMessage = exports.postReadyMessage = void 0;
+const nats_1 = require("nats");
+const config_1 = __importDefault(require("../config"));
+const { NATS_SERVER } = config_1.default;
+const codec = (0, nats_1.JSONCodec)();
+async function postReadyMessage(clientAddress, workerAddress) {
+    // connect to the NATS server and send a 'ready' request
+    const nc = await (0, nats_1.connect)({ servers: NATS_SERVER });
+    const msg = await nc.request(`zkcw:${clientAddress}`, codec.encode({
+        post: "ready",
+        params: { key: workerAddress },
+    }));
+    const response = codec.decode(msg.data);
+    console.log("Response: ", response);
+    // disconnect and clean all pending
+    await nc.drain();
+    return response;
+}
+exports.postReadyMessage = postReadyMessage;
+async function postDoneMessage(clientAddress, encrypted) {
+    // connect to the NATS server and send a 'ready' request
+    const nc = await (0, nats_1.connect)({ servers: NATS_SERVER });
+    const msg = await nc.request(`zkcw:${clientAddress}`, codec.encode({
+        post: "done",
+        params: { result: encrypted },
+    }));
+    const response = codec.decode(msg.data);
+    console.log("Response: ", response);
+    // disconnect and clean all pending
+    await nc.drain();
+    return response;
+}
+exports.postDoneMessage = postDoneMessage;

package/lib/ts/src/encryption/nats-client.d.ts

@@ -0,0 +1 @@
+export declare function listen(subject: string): Promise<void>;

package/lib/ts/src/encryption/nats-client.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listen = void 0;
+const nats_1 = require("nats");
+const o1js_1 = require("o1js");
+const encryption_1 = require("./encryption");
+const config_1 = __importDefault(require("../config"));
+const { NATS_SERVER } = config_1.default;
+async function listen(subject) {
+    // Create a JSON codec for encoding and decoding messages
+    const codec = (0, nats_1.JSONCodec)();
+    const connection = await (0, nats_1.connect)({ servers: NATS_SERVER });
+    // Subscribe to the subject
+    const subscription = connection.subscribe(subject);
+    console.log(`Subscribed to subject ${subject}`);
+    // Process messages received on the subscribed subject
+    (async () => {
+        // Error decoding message:  Error: Could not encrypt message={}
+        // Error: Poseidon.Sponge(): bindings are not initialized, try calling `await initializeBindings()` first.
+        // This shouldn't have happened and indicates an internal bug.
+        await (0, o1js_1.initializeBindings)();
+        for await (const msg of subscription) {
+            try {
+                const data = codec.decode(msg.data);
+                //console.log(`Received message on subject ${subject}:`, data);
+                // Perform processing logic here
+                const { post, params } = data;
+                // console.log(`Post: `, post, params);
+                switch (post) {
+                    case "ready":
+                        {
+                            // the workers announces it is ready
+                            // and we receive the worker's publicKey
+                            let workerKey = params.key || "";
+                            console.log("Received 'ready' message from worker");
+                            console.log("Worker publicKey: ", workerKey);
+                            // we will use its key to encrypt the message
+                            const encryptedPayload = encryption_1.CipherText.encrypt(JSON.stringify({
+                                value: Math.ceil(Math.random() * 100).toString(),
+                            }), workerKey);
+                            console.log("Encrypted payload: ", encryptedPayload);
+                            // we reply with the command we want the worker to execute
+                            // and with the encrypted payload
+                            msg.respond(codec.encode({
+                                success: true,
+                                data: {
+                                    command: "execute",
+                                    encrypted: encryptedPayload,
+                                },
+                                error: undefined,
+                            }));
+                        }
+                        break;
+                    case "done":
+                        {
+                            let result = params.result || "";
+                            console.log("Received 'done' message from worker");
+                            msg.respond(codec.encode({
+                                success: true,
+                                data: { status: "closed" },
+                                error: undefined,
+                            }));
+                            // we want to insure that messages that are in flight
+                            // get processed, so we are going to drain the
+                            // connection. Drain is the same as close, but makes
+                            // sure that all messages in flight get seen
+                            // by the iterator. After calling drain on the connection
+                            // the connection closes.
+                            setTimeout(async () => {
+                                await connection.drain();
+                            }, 1000);
+                        }
+                        break;
+                }
+            }
+            catch (err) {
+                console.error("Error decoding message: ", err);
+            }
+        }
+    })();
+}
+exports.listen = listen;

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

@@ -8,3 +8,6 @@ export * from "./fee";
 export * from "./fetch";
 export * from "./networks";
 export * from "./api/client-api";
+export * from "./encryption/encryption";
+export * from "./encryption/nats-client";
+export * from "./encryption/messages";

package/lib/ts/src/index.js

@@ -24,3 +24,6 @@ __exportStar(require("./fee"), exports);
 __exportStar(require("./fetch"), exports);
 __exportStar(require("./networks"), exports);
 __exportStar(require("./api/client-api"), exports);
+__exportStar(require("./encryption/encryption"), exports);
+__exportStar(require("./encryption/nats-client"), exports);
+__exportStar(require("./encryption/messages"), exports);