zkcloudworker 0.7.15 → 0.8.1

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

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const config = {
     MINAFEE: "200000000",
     ZKCLOUDWORKER_AUTH: "M6t4jtbBAFFXhLERHQWyEB9JA9xi4cWqmYduaCXtbrFjb7yaY7TyaXDunKDJNiUTBEcyUomNXJgC",
-    ZKCLOUDWORKER_API: "https://cuq99yahhi.execute-api.eu-west-1.amazonaws.com/dev/zkcloudworker",
+    ZKCLOUDWORKER_API: "https://cuq99yahhi.execute-api.eu-west-1.amazonaws.com/dev/",
 };
 exports.default = config;

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

@@ -0,0 +1,7 @@
+export declare function stringHash(jsonString: string): string;
+export declare function bigintToBase56(value: bigint): string;
+export declare function bigintFromBase56(str: string): bigint;
+export declare function bigintToBase64(value: bigint): string;
+export declare function bigintFromBase64(str: string): bigint;
+export declare function fromBase(digits: bigint[], base: bigint): bigint;
+export declare function toBase(x: bigint, base: bigint): bigint[];

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

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase = exports.fromBase = exports.bigintFromBase64 = exports.bigintToBase64 = exports.bigintFromBase56 = exports.bigintToBase56 = exports.stringHash = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+function stringHash(jsonString) {
+    if (typeof jsonString !== "string")
+        throw new Error("stringHash: input must be a string");
+    return bigintToBase56(BigInt("0x" + crypto_1.default.createHash("sha256").update(jsonString).digest("hex")));
+}
+exports.stringHash = stringHash;
+// URL friendly base64 encoding
+const TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function bigintToBase56(value) {
+    const digits = toBase(value, 56n);
+    //console.log("digits:", digits);
+    const str = digits.map((x) => TABLE[Number(x)]).join("");
+    //console.log("str:", str);
+    return str;
+}
+exports.bigintToBase56 = bigintToBase56;
+function bigintFromBase56(str) {
+    const base56Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+    const x = fromBase(base56Digits, 56n);
+    return x;
+}
+exports.bigintFromBase56 = bigintFromBase56;
+function bigintToBase64(value) {
+    const digits = toBase(value, 64n);
+    //console.log("digits:", digits);
+    const str = digits.map((x) => TABLE[Number(x)]).join("");
+    //console.log("str:", str);
+    return str;
+}
+exports.bigintToBase64 = bigintToBase64;
+function bigintFromBase64(str) {
+    const base64Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+    const x = fromBase(base64Digits, 64n);
+    return x;
+}
+exports.bigintFromBase64 = bigintFromBase64;
+function fromBase(digits, base) {
+    if (base <= 0n)
+        throw Error("fromBase: base must be positive");
+    // compute powers base, base^2, base^4, ..., base^(2^k)
+    // with largest k s.t. n = 2^k < digits.length
+    let basePowers = [];
+    for (let power = base, n = 1; n < digits.length; power **= 2n, n *= 2) {
+        basePowers.push(power);
+    }
+    let k = basePowers.length;
+    // pad digits array with zeros s.t. digits.length === 2^k
+    digits = digits.concat(Array(2 ** k - digits.length).fill(0n));
+    // accumulate [x0, x1, x2, x3, ...] -> [x0 + base*x1, x2 + base*x3, ...] -> [x0 + base*x1 + base^2*(x2 + base*x3), ...] -> ...
+    // until we end up with a single element
+    for (let i = 0; i < k; i++) {
+        let newDigits = Array(digits.length >> 1);
+        let basePower = basePowers[i];
+        for (let j = 0; j < newDigits.length; j++) {
+            newDigits[j] = digits[2 * j] + basePower * digits[2 * j + 1];
+        }
+        digits = newDigits;
+    }
+    console.assert(digits.length === 1);
+    let [digit] = digits;
+    return digit;
+}
+exports.fromBase = fromBase;
+function toBase(x, base) {
+    if (base <= 0n)
+        throw Error("toBase: base must be positive");
+    // compute powers base, base^2, base^4, ..., base^(2^k)
+    // with largest k s.t. base^(2^k) < x
+    let basePowers = [];
+    for (let power = base; power <= x; power **= 2n) {
+        basePowers.push(power);
+    }
+    let digits = [x]; // single digit w.r.t base^(2^(k+1))
+    // successively split digits w.r.t. base^(2^j) into digits w.r.t. base^(2^(j-1))
+    // until we arrive at digits w.r.t. base
+    let k = basePowers.length;
+    for (let i = 0; i < k; i++) {
+        let newDigits = Array(2 * digits.length);
+        let basePower = basePowers[k - 1 - i];
+        for (let j = 0; j < digits.length; j++) {
+            let x = digits[j];
+            let high = x / basePower;
+            newDigits[2 * j + 1] = high;
+            newDigits[2 * j] = x - high * basePower;
+        }
+        digits = newDigits;
+    }
+    // pop "leading" zero digits
+    while (digits[digits.length - 1] === 0n) {
+        digits.pop();
+    }
+    return digits;
+}
+exports.toBase = toBase;

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

@@ -1,3 +1,4 @@
 export * from "./files";
 export * from "./graphql";
 export * from "./utils";
+export * from "./hash";

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./files"), exports);
 __exportStar(require("./graphql"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./hash"), exports);

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

@@ -43,6 +43,7 @@ export interface CloudTransaction {
     txId: string;
     transaction: string;
     timeReceived: number;
+    status: string;
 }
 export declare abstract class Cloud {
     readonly id: string;
@@ -202,7 +203,7 @@ export declare abstract class Cloud {
      * Abstract method to send the transactions
      * @param transactions
      */
-    abstract sendTransactions(transactions: string[] | CloudTransaction[]): Promise<string[]>;
+    abstract sendTransactions(transactions: string[] | CloudTransaction[]): Promise<CloudTransaction[]>;
     /**
      * Abstract method to delete the transaction
      * Used to delete the transaction

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

@@ -22,7 +22,7 @@ export type ApiCommand = "recursiveProof" | "execute" | "sendTransactions" | "jo
  */
 export declare class zkCloudWorkerClient {
     readonly jwt: string;
-    readonly endpoint: string;
+    readonly endpoint?: string;
     readonly chain: blockchain;
     readonly webhook?: string;
     readonly localWorker?: (cloud: Cloud) => Promise<zkCloudWorker>;

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

@@ -28,10 +28,14 @@ class zkCloudWorkerClient {
      * @param params.webhook The webhook for the serverless api to get the results
      */
     constructor(params) {
-        const { jwt, zkcloudworker, chain, webhook } = params;
+        const { jwt, zkcloudworker, webhook } = params;
         this.jwt = jwt;
-        this.endpoint = ZKCLOUDWORKER_API;
-        this.chain = chain ?? "devnet";
+        const chain = params.chain ?? "devnet";
+        this.chain = chain;
+        this.endpoint =
+            chain === "devnet" || chain === "zeko"
+                ? ZKCLOUDWORKER_API + chain
+                : undefined;
         this.webhook = webhook;
         if (jwt === "local") {
             if (zkcloudworker === undefined)
@@ -423,6 +427,8 @@ class zkCloudWorkerClient {
             }
         }
         else {
+            if (this.endpoint === undefined)
+                throw new Error("zkCloudWorker supports only devnet and zeko chains in the cloud.");
             const apiData = {
                 auth: ZKCLOUDWORKER_AUTH,
                 command: command,

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

@@ -81,13 +81,13 @@ export declare class LocalCloud extends Cloud {
      * @param transactions the transactions to add
      * @returns the transaction ids
      */
-    sendTransactions(transactions: string[]): Promise<string[]>;
+    sendTransactions(transactions: string[]): Promise<CloudTransaction[]>;
     /**
      * Adds transactions to the local cloud
      * @param transactions the transactions to add
      * @returns the transaction ids
      */
-    static addTransactions(transactions: string[] | CloudTransaction[]): Promise<string[]>;
+    static addTransactions(transactions: string[] | CloudTransaction[]): Promise<CloudTransaction[]>;
     /**
      * Deletes a transaction from the local cloud
      * @param txId the transaction id to delete
@@ -238,10 +238,7 @@ export declare class LocalStorage {
         [key: string]: string;
     };
     static transactions: {
-        [key: string]: {
-            transaction: string;
-            timeReceived: number;
-        };
+        [key: string]: CloudTransaction;
     };
     static tasks: {
         [key: string]: TaskData;

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

@@ -4,6 +4,7 @@ exports.LocalStorage = exports.LocalCloud = void 0;
 const cloud_1 = require("../../cloud");
 const cloud_2 = require("../../cloud");
 const cloud_3 = require("../../cloud");
+const cloud_4 = require("../../cloud");
 /**
  * LocalCloud is a cloud that runs on the local machine for testing and development
  * It uses LocalStorage to store jobs, tasks, transactions, and data
@@ -115,8 +116,9 @@ class LocalCloud extends cloud_1.Cloud {
      * Generates an id for local cloud
      * @returns generated unique id
      */
-    static generateId() {
-        return "local." + Date.now().toString() + "." + (0, cloud_2.makeString)(32);
+    static generateId(tx = undefined) {
+        const data = tx ?? JSON.stringify({ time: Date.now(), data: (0, cloud_2.makeString)(32) });
+        return (0, cloud_4.stringHash)(data);
     }
     /**
      * Send transactions to the local cloud
@@ -133,19 +135,25 @@ class LocalCloud extends cloud_1.Cloud {
      */
     static async addTransactions(transactions) {
         const timeReceived = Date.now();
-        const txId = [];
+        const txs = [];
         transactions.forEach((tx) => {
             if (typeof tx === "string") {
-                const id = LocalCloud.generateId();
-                LocalStorage.transactions[id] = { transaction: tx, timeReceived };
-                txId.push(id);
+                const txId = LocalCloud.generateId(JSON.stringify({ tx, time: timeReceived }));
+                const transaction = {
+                    txId,
+                    transaction: tx,
+                    timeReceived,
+                    status: "accepted",
+                };
+                LocalStorage.transactions[txId] = transaction;
+                txs.push(transaction);
             }
             else {
                 LocalStorage.transactions[tx.txId] = tx;
-                txId.push(tx.txId);
+                txs.push(tx);
             }
         });
-        return txId;
+        return txs;
     }
     /**
      * Deletes a transaction from the local cloud
@@ -158,12 +166,7 @@ class LocalCloud extends cloud_1.Cloud {
     }
     async getTransactions() {
         const txs = Object.keys(LocalStorage.transactions).map((txId) => {
-            const { transaction, timeReceived } = LocalStorage.transactions[txId];
-            return {
-                txId,
-                transaction,
-                timeReceived,
-            };
+            return LocalStorage.transactions[txId];
         });
         return txs;
     }

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

@@ -1,11 +1,5 @@
 import { Field } from "o1js";
 export declare function fieldToBase56(field: Field): string;
-export declare function bigintToBase56(value: bigint): string;
 export declare function fieldFromBase56(str: string): Field;
-export declare function bigintFromBase56(str: string): bigint;
 export declare function fieldToBase64(field: Field): string;
-export declare function bigintToBase64(value: bigint): string;
 export declare function fieldFromBase64(str: string): Field;
-export declare function bigintFromBase64(str: string): bigint;
-export declare function fromBase(digits: bigint[], base: bigint): bigint;
-export declare function toBase(x: bigint, base: bigint): bigint[];

package/lib/ts/src/mina/utils/base64.js

@@ -1,120 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBase = exports.fromBase = exports.bigintFromBase64 = exports.fieldFromBase64 = exports.bigintToBase64 = exports.fieldToBase64 = exports.bigintFromBase56 = exports.fieldFromBase56 = exports.bigintToBase56 = exports.fieldToBase56 = void 0;
+exports.fieldFromBase64 = exports.fieldToBase64 = exports.fieldFromBase56 = exports.fieldToBase56 = void 0;
 const o1js_1 = require("o1js");
+const hash_1 = require("../../cloud/utils/hash");
 // URL friendly base64 encoding
 const TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 function fieldToBase56(field) {
-    const digits = toBase(field.toBigInt(), 56n);
+    const digits = (0, hash_1.toBase)(field.toBigInt(), 56n);
     //console.log("digits:", digits);
     const str = digits.map((x) => TABLE[Number(x)]).join("");
     //console.log("str:", str);
     return str;
 }
 exports.fieldToBase56 = fieldToBase56;
-function bigintToBase56(value) {
-    const digits = toBase(value, 56n);
-    //console.log("digits:", digits);
-    const str = digits.map((x) => TABLE[Number(x)]).join("");
-    //console.log("str:", str);
-    return str;
-}
-exports.bigintToBase56 = bigintToBase56;
 function fieldFromBase56(str) {
     const base56Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
-    const x = fromBase(base56Digits, 56n);
+    const x = (0, hash_1.fromBase)(base56Digits, 56n);
     return (0, o1js_1.Field)(x);
 }
 exports.fieldFromBase56 = fieldFromBase56;
-function bigintFromBase56(str) {
-    const base56Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
-    const x = fromBase(base56Digits, 56n);
-    return x;
-}
-exports.bigintFromBase56 = bigintFromBase56;
 function fieldToBase64(field) {
-    const digits = toBase(field.toBigInt(), 64n);
+    const digits = (0, hash_1.toBase)(field.toBigInt(), 64n);
     //console.log("digits:", digits);
     const str = digits.map((x) => TABLE[Number(x)]).join("");
     //console.log("str:", str);
     return str;
 }
 exports.fieldToBase64 = fieldToBase64;
-function bigintToBase64(value) {
-    const digits = toBase(value, 64n);
-    //console.log("digits:", digits);
-    const str = digits.map((x) => TABLE[Number(x)]).join("");
-    //console.log("str:", str);
-    return str;
-}
-exports.bigintToBase64 = bigintToBase64;
 function fieldFromBase64(str) {
     const base64Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
-    const x = fromBase(base64Digits, 64n);
+    const x = (0, hash_1.fromBase)(base64Digits, 64n);
     return (0, o1js_1.Field)(x);
 }
 exports.fieldFromBase64 = fieldFromBase64;
-function bigintFromBase64(str) {
-    const base64Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
-    const x = fromBase(base64Digits, 64n);
-    return x;
-}
-exports.bigintFromBase64 = bigintFromBase64;
-function fromBase(digits, base) {
-    if (base <= 0n)
-        throw Error("fromBase: base must be positive");
-    // compute powers base, base^2, base^4, ..., base^(2^k)
-    // with largest k s.t. n = 2^k < digits.length
-    let basePowers = [];
-    for (let power = base, n = 1; n < digits.length; power **= 2n, n *= 2) {
-        basePowers.push(power);
-    }
-    let k = basePowers.length;
-    // pad digits array with zeros s.t. digits.length === 2^k
-    digits = digits.concat(Array(2 ** k - digits.length).fill(0n));
-    // accumulate [x0, x1, x2, x3, ...] -> [x0 + base*x1, x2 + base*x3, ...] -> [x0 + base*x1 + base^2*(x2 + base*x3), ...] -> ...
-    // until we end up with a single element
-    for (let i = 0; i < k; i++) {
-        let newDigits = Array(digits.length >> 1);
-        let basePower = basePowers[i];
-        for (let j = 0; j < newDigits.length; j++) {
-            newDigits[j] = digits[2 * j] + basePower * digits[2 * j + 1];
-        }
-        digits = newDigits;
-    }
-    console.assert(digits.length === 1);
-    let [digit] = digits;
-    return digit;
-}
-exports.fromBase = fromBase;
-function toBase(x, base) {
-    if (base <= 0n)
-        throw Error("toBase: base must be positive");
-    // compute powers base, base^2, base^4, ..., base^(2^k)
-    // with largest k s.t. base^(2^k) < x
-    let basePowers = [];
-    for (let power = base; power <= x; power **= 2n) {
-        basePowers.push(power);
-    }
-    let digits = [x]; // single digit w.r.t base^(2^(k+1))
-    // successively split digits w.r.t. base^(2^j) into digits w.r.t. base^(2^(j-1))
-    // until we arrive at digits w.r.t. base
-    let k = basePowers.length;
-    for (let i = 0; i < k; i++) {
-        let newDigits = Array(2 * digits.length);
-        let basePower = basePowers[k - 1 - i];
-        for (let j = 0; j < digits.length; j++) {
-            let x = digits[j];
-            let high = x / basePower;
-            newDigits[2 * j + 1] = high;
-            newDigits[2 * j] = x - high * basePower;
-        }
-        digits = newDigits;
-    }
-    // pop "leading" zero digits
-    while (digits[digits.length - 1] === 0n) {
-        digits.pop();
-    }
-    return digits;
-}
-exports.toBase = toBase;