zkcloudworker 0.5.7 → 0.6.0

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

@@ -6,7 +6,7 @@ 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 mina_1 = require("../utils/mina");
 const local_1 = require("../cloud/local");
 const config_1 = __importDefault(require("../config"));
 const { ZKCLOUDWORKER_AUTH, ZKCLOUDWORKER_API } = config_1.default;
@@ -50,17 +50,28 @@ class zkCloudWorkerClient {
      */
     async recursiveProof(data) {
         const result = await this.apiHub("recursiveProof", data);
-        if (result.data === "error")
+        if (result.data === "error" ||
+            (typeof result.data === "string" && result.data.startsWith("error")))
             return {
                 success: false,
                 error: result.error,
             };
-        else
+        else if (result.success === false || result.data?.success === false)
+            return {
+                success: false,
+                error: result.error ?? result.data?.error ?? "recursiveProof call failed",
+            };
+        else if (result.success === true && result.data?.success === true)
             return {
                 success: result.success,
-                jobId: result.data,
+                jobId: result.data.jobId,
                 error: result.error,
             };
+        else
+            return {
+                success: false,
+                error: "recursiveProof call error",
+            };
     }
     /**
      * Starts a new job for the function call using serverless api call

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

@@ -1,11 +1,19 @@
 /// <reference types="node" />
-import { Cache, PrivateKey, PublicKey, SmartContract } from "o1js";
+import type { Cache } from "o1js";
 import { blockchain } from "../networks";
 import { JobData } from "./job";
 export interface DeployedSmartContract {
-    address: PublicKey;
-    contract: SmartContract;
+    address: string;
+    name: string;
     chain: blockchain;
+    verificationKey: {
+        hash: string;
+        data: string;
+    };
+}
+export interface DeployerKeyPair {
+    publicKey: string;
+    privateKey: string;
 }
 export interface CloudTransaction {
     txId: string;
@@ -41,9 +49,11 @@ export declare abstract class Cloud {
         isLocalCloud?: boolean;
         chain: blockchain;
     });
-    abstract getDeployer(): Promise<PrivateKey | undefined>;
-    abstract releaseDeployer(txsHashes: string[]): Promise<void>;
-    abstract log(msg: string): void;
+    abstract getDeployer(): Promise<DeployerKeyPair | undefined>;
+    abstract releaseDeployer(params: {
+        publicKey: string;
+        txsHashes: string[];
+    }): Promise<void>;
     abstract getDataByKey(key: string): Promise<string | undefined>;
     abstract saveDataByKey(key: string, value: string | undefined): Promise<void>;
     abstract saveFile(filename: string, value: Buffer): Promise<void>;

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

@@ -0,0 +1,5 @@
+export * from "./cloud";
+export * from "./files";
+export * from "./job";
+export * from "./task";
+export * from "./local";

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

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cloud"), exports);
+__exportStar(require("./files"), exports);
+__exportStar(require("./job"), exports);
+__exportStar(require("./task"), exports);
+__exportStar(require("./local"), exports);

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

@@ -1,10 +1,10 @@
 /// <reference types="node" />
-import { Cache, PrivateKey } from "o1js";
+import { Cache } from "o1js";
 import { Cloud, zkCloudWorker } from "./cloud";
 import { JobData } from "./job";
 import { TaskData } from "./task";
 import { blockchain } from "../networks";
-import { CloudTransaction } from "./cloud";
+import { CloudTransaction, DeployerKeyPair } from "./cloud";
 import { ApiCommand } from "../api/api";
 export declare class LocalCloud extends Cloud {
     readonly localWorker: (cloud: Cloud) => Promise<zkCloudWorker>;
@@ -15,8 +15,11 @@ export declare class LocalCloud extends Cloud {
         stepId?: string;
         localWorker: (cloud: Cloud) => Promise<zkCloudWorker>;
     });
-    getDeployer(): Promise<PrivateKey | undefined>;
-    releaseDeployer(txsHashes: string[]): Promise<void>;
+    getDeployer(): Promise<DeployerKeyPair | undefined>;
+    releaseDeployer(params: {
+        publicKey: string;
+        txsHashes: string[];
+    }): Promise<void>;
     log(msg: string): Promise<void>;
     getDataByKey(key: string): Promise<string | undefined>;
     saveDataByKey(key: string, value: string | undefined): Promise<void>;

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

@@ -3,7 +3,7 @@ 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 mina_1 = require("../utils/mina");
 const files_1 = require("./files");
 class LocalCloud extends cloud_1.Cloud {
     constructor(params) {
@@ -28,10 +28,21 @@ class LocalCloud extends cloud_1.Cloud {
     }
     async getDeployer() {
         const deployer = process.env.DEPLOYER;
-        return deployer === undefined ? undefined : o1js_1.PrivateKey.fromBase58(deployer);
+        try {
+            return deployer === undefined
+                ? undefined
+                : {
+                    privateKey: deployer,
+                    publicKey: o1js_1.PrivateKey.fromBase58(deployer).toPublicKey().toBase58(),
+                };
+        }
+        catch (error) {
+            console.error(`getDeployer: process.env.DEPLOYER has wrong encoding, should be base58 private key ("EKE...")`, error);
+            return undefined;
+        }
     }
-    async releaseDeployer(txsHashes) {
-        console.log("LocalCloud: releaseDeployer", txsHashes);
+    async releaseDeployer(params) {
+        console.log("LocalCloud: releaseDeployer", params);
     }
     async log(msg) {
         console.log("LocalCloud:", msg);

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

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

package/lib/ts/src/config.js

@@ -4,6 +4,5 @@ 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/client.d.ts

@@ -0,0 +1,19 @@
+export interface INATSClient {
+    address: string;
+    secret: string;
+    callme: {
+        onOptions: (params: any) => void;
+        onReady: (params: any) => void;
+        onDone: (params: any) => void;
+    };
+}
+export declare function NATSClient(callme: {
+    onOptions: (params: any) => void;
+    onReady: (params: any) => void;
+    onDone: (params: any) => void;
+}): Promise<INATSClient>;
+export declare function listen(subject: string, callme: {
+    onOptions: (params: any) => void;
+    onReady: (params: any) => void;
+    onDone: (params: any) => void;
+}): Promise<void>;

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listen = exports.NATSClient = void 0;
+const o1js_1 = require("o1js");
+const nats_1 = require("nats");
+const o1js_2 = require("o1js");
+const encryption_1 = require("./encryption");
+const connections_1 = require("./connections");
+async function NATSClient(callme) {
+    // create some client address, this will be done by
+    // the web API BEFORE calling a worker
+    const secret = o1js_1.PrivateKey.random();
+    let address = secret.toPublicKey().toBase58();
+    console.log("Client address ", address);
+    // now subscribe and listen in this Address
+    // we use the 'zkcw' prefix for zkCloudWorkers subscriptions
+    await listen(`zkcw:${address}`, callme);
+    return {
+        address: address,
+        secret: secret.toBase58(),
+        callme: callme,
+    };
+}
+exports.NATSClient = NATSClient;
+async function listen(subject, callme) {
+    // Create a JSON codec for encoding and decoding messages
+    const codec = (0, nats_1.JSONCodec)();
+    const connection = await (0, nats_1.connect)({ servers: connections_1.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_2.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 "options":
+                        {
+                            // the workers announces it is ready
+                            // and we receive the worker's publicKey
+                            let workerKey = params.key || "";
+                            console.log("\nReceived 'options' message from worker");
+                            console.log("Worker publicKey: ", workerKey);
+                            let options = callme.onOptions(params);
+                            console.log("options:", options);
+                            // we will use its key to encrypt the message
+                            const encryptedOptions = encryption_1.CipherText.encrypt(JSON.stringify(options), workerKey);
+                            console.log("Encrypted options: ", encryptedOptions);
+                            // we reply with the command we want the worker to execute
+                            // and with the encrypted payload
+                            msg.respond(codec.encode({
+                                success: true,
+                                data: {
+                                    command: "options",
+                                    encrypted: encryptedOptions,
+                                },
+                                error: undefined,
+                            }));
+                        }
+                        break;
+                    case "ready":
+                        {
+                            // the workers announces it is ready
+                            // and we receive the worker's publicKey
+                            let workerKey = params.key || "";
+                            console.log("\nReceived 'ready' message from worker");
+                            console.log("Worker publicKey: ", workerKey);
+                            let payload = callme.onReady(params);
+                            console.log("payload:", payload);
+                            // we will use its key to encrypt the message
+                            const encryptedPayload = encryption_1.CipherText.encrypt(JSON.stringify(payload), 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("\nReceived 'done' message from worker");
+                            let done = callme.onDone(params);
+                            console.log("done: ", done);
+                            msg.respond(codec.encode({
+                                success: true,
+                                data: {
+                                    command: "close",
+                                    status: JSON.stringify(done),
+                                },
+                                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;
+/*
+async function main(args: string[]) {
+  const nc = await connect({ servers: NATS_SERVER });
+
+  // create some client address, this will be done by
+  // the web API when calling a worker
+  const clientSecret = PrivateKey.random();
+  let clientAddress = clientSecret.toPublicKey().toBase58();
+  console.log("Client address ", clientAddress);
+  
+  clientAddress = "B62qrYPDY555koJFAdNaUyw21WCNUgie9bmsBs2gCh6DSdhQmuN4qu6";
+  
+  // now subscribe and listen in this Address
+  listen(nc, `zkcw:${clientAddress}`);
+
+  // 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.
+  //await nc.drain();
+}
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(error);
+});
+*/

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

@@ -0,0 +1 @@
+export declare const NATS_SERVER = "nats.socialcap.dev:4222";

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATS_SERVER = void 0;
+exports.NATS_SERVER = "nats.socialcap.dev:4222";

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

@@ -1,9 +1,10 @@
 import { Field, Group } from "o1js";
-export interface CipherTextObject {
+export { CipherText };
+interface CipherTextObject {
     cipherText: Field[];
     publicKey: Group;
 }
-export declare class CipherText {
+declare class CipherText {
     static stringify(cipherText: CipherTextObject): string;
     static parse(jsonStr: string): CipherTextObject;
     static encrypt(message: string, publicId: string): string;

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

@@ -16,8 +16,8 @@ class CipherText {
     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);
+            let encripted = o1js_1.Encryption.encrypt(fields, o1js_1.PublicKey.fromBase58(publicId));
+            return CipherText.stringify(encripted);
         }
         catch (err) {
             throw Error(`Could not encrypt message='${message}' using key='${publicId}'.` +

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

@@ -0,0 +1,4 @@
+export { NATS_SERVER } from "./connections";
+export { CipherText } from "./encryption";
+export { NATSClient, listen } from "./client";
+export { postReadyMessage, postDoneMessage, postOptionsMessage, } from "./messages";

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postOptionsMessage = exports.postDoneMessage = exports.postReadyMessage = exports.listen = exports.NATSClient = exports.CipherText = exports.NATS_SERVER = void 0;
+var connections_1 = require("./connections");
+Object.defineProperty(exports, "NATS_SERVER", { enumerable: true, get: function () { return connections_1.NATS_SERVER; } });
+var encryption_1 = require("./encryption");
+Object.defineProperty(exports, "CipherText", { enumerable: true, get: function () { return encryption_1.CipherText; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "NATSClient", { enumerable: true, get: function () { return client_1.NATSClient; } });
+Object.defineProperty(exports, "listen", { enumerable: true, get: function () { return client_1.listen; } });
+var messages_1 = require("./messages");
+Object.defineProperty(exports, "postReadyMessage", { enumerable: true, get: function () { return messages_1.postReadyMessage; } });
+Object.defineProperty(exports, "postDoneMessage", { enumerable: true, get: function () { return messages_1.postDoneMessage; } });
+Object.defineProperty(exports, "postOptionsMessage", { enumerable: true, get: function () { return messages_1.postOptionsMessage; } });

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

@@ -1,2 +1,3 @@
+export declare function postOptionsMessage(clientAddress: string, workerAddress: string): Promise<any>;
 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

@@ -1,38 +1,51 @@
 "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;
+exports.postDoneMessage = exports.postReadyMessage = exports.postOptionsMessage = void 0;
 const nats_1 = require("nats");
-const config_1 = __importDefault(require("../config"));
-const { NATS_SERVER } = config_1.default;
+const connections_1 = require("./connections");
 const codec = (0, nats_1.JSONCodec)();
+async function postOptionsMessage(clientAddress, workerAddress) {
+    // connect to the NATS server and send a 'ready' request
+    const nc = await (0, nats_1.connect)({ servers: connections_1.NATS_SERVER });
+    const msg = await nc.request(`zkcw:${clientAddress}`, codec.encode({
+        "post": "options",
+        "params": { "key": workerAddress }
+    }));
+    const response = codec.decode(msg.data);
+    console.log("Response: ", response);
+    // disconect and clean all pendings
+    await nc.drain();
+    return response;
+}
+exports.postOptionsMessage = postOptionsMessage;
+;
 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 nc = await (0, nats_1.connect)({ servers: connections_1.NATS_SERVER });
     const msg = await nc.request(`zkcw:${clientAddress}`, codec.encode({
-        post: "ready",
-        params: { key: workerAddress },
+        "post": "ready",
+        "params": { "key": workerAddress }
     }));
     const response = codec.decode(msg.data);
     console.log("Response: ", response);
-    // disconnect and clean all pending
+    // disconect and clean all pendings
     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 nc = await (0, nats_1.connect)({ servers: connections_1.NATS_SERVER });
     const msg = await nc.request(`zkcw:${clientAddress}`, codec.encode({
-        post: "done",
-        params: { result: encrypted },
+        "post": "done",
+        "params": { "result": encrypted }
     }));
     const response = codec.decode(msg.data);
     console.log("Response: ", response);
-    // disconnect and clean all pending
+    // disconect and clean all pendings
     await nc.drain();
     return response;
 }
 exports.postDoneMessage = postDoneMessage;
+;

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

@@ -1,14 +1,5 @@
 export * from "./api/api";
-export * from "./cloud/cloud";
-export * from "./cloud/local";
-export * from "./cloud/job";
-export * from "./cloud/task";
-export * from "./mina";
-export * from "./fee";
+export * from "./cloud";
 export * from "./networks";
-export * from "./encryption/encryption";
-export * from "./encryption/nats-client";
-export * from "./encryption/messages";
-export * from "./utils/fields";
-export * from "./utils/base64";
-export * from "./utils/fetch";
+export * from "./encryption";
+export * from "./utils";

package/lib/ts/src/index.js

@@ -15,16 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 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("./cloud/task"), exports);
-__exportStar(require("./mina"), exports);
-__exportStar(require("./fee"), exports);
+__exportStar(require("./cloud"), exports);
 __exportStar(require("./networks"), exports);
-__exportStar(require("./encryption/encryption"), exports);
-__exportStar(require("./encryption/nats-client"), exports);
-__exportStar(require("./encryption/messages"), exports);
-__exportStar(require("./utils/fields"), exports);
-__exportStar(require("./utils/base64"), exports);
-__exportStar(require("./utils/fetch"), exports);
+__exportStar(require("./encryption"), exports);
+__exportStar(require("./utils"), exports);

package/lib/ts/src/networks.d.ts

@@ -8,6 +8,7 @@ interface MinaNetwork {
     accountManager?: string;
     explorerAccountUrl?: string;
     explorerTransactionUrl?: string;
+    faucet?: string;
 }
 declare const Mainnet: MinaNetwork;
 declare const Local: MinaNetwork;

package/lib/ts/src/networks.js

@@ -26,12 +26,17 @@ const Devnet = {
     explorerTransactionUrl: "https://minascan.io/devnet/tx/",
     chainId: "devnet",
     name: "Devnet",
+    faucet: "https://faucet.minaprotocol.com",
 };
 exports.Devnet = Devnet;
 const Zeko = {
-    mina: ["http://sequencer-zeko-dev.dcspark.io/graphql"],
+    mina: ["https://devnet.zeko.io/graphql"],
     archive: [],
+    explorerAccountUrl: "https://zekoscan.io/devnet/account/",
+    explorerTransactionUrl: "https://zekoscan.io/devnet/tx/",
     chainId: "zeko",
+    name: "Zeko",
+    faucet: "https://zeko.io/faucet",
 };
 exports.Zeko = Zeko;
 const Lightnet = {

package/lib/ts/src/{fee.js → utils/fee.js}

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fee = void 0;
 const o1js_1 = require("o1js");
-const config_1 = __importDefault(require("./config"));
+const config_1 = __importDefault(require("../config"));
 async function fee() {
     //TODO: update after mainnet launch
     return o1js_1.UInt64.fromJSON(config_1.default.MINAFEE);

package/lib/ts/src/utils/fetch.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkMinaZkappTransaction = exports.fetchMinaActions = exports.fetchMinaAccount = void 0;
 const o1js_1 = require("o1js");
-const mina_1 = require("../mina");
+const mina_1 = require("./mina");
 async function fetchMinaAccount(params) {
     const { publicKey, tokenId, force } = params;
     const timeout = 1000 * 60 * 2; // 2 minutes

package/lib/ts/src/utils/graphql.d.ts

@@ -0,0 +1,11 @@
+export declare const defaultToken = "wSHV2S4qX9jFsLjQo8r1BsMLH2ZRKsZx6EJd1sbozGPieEC4Jf";
+export declare function getBalanceFromGraphQL(params: {
+    publicKey: string;
+    tokenId?: string;
+    mina: string[];
+}): Promise<bigint>;
+export declare function getAccountFromGraphQL(params: {
+    publicKey: string;
+    tokenId?: string;
+    mina: string[];
+}): Promise<any>;