zkcloudworker 0.17.2 → 0.17.5

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

@@ -0,0 +1,3 @@
+export * from "./ipfs";
+export * from "./pinata";
+export * from "./storage";

package/lib/ts/src/mina/storage/index.js

@@ -0,0 +1,19 @@
+"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("./ipfs"), exports);
+__exportStar(require("./pinata"), exports);
+__exportStar(require("./storage"), exports);

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

@@ -0,0 +1,6 @@
+export declare function pinJSON(params: {
+    data: string | object;
+    name: string;
+    keyvalues?: object;
+    auth: string;
+}): Promise<string | undefined>;

package/lib/ts/src/mina/storage/pinata.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pinJSON = pinJSON;
+async function pinJSON(params) {
+    const { data, name, keyvalues, auth } = params;
+    try {
+        const pinataData = {
+            pinataOptions: {
+                cidVersion: 1,
+            },
+            pinataMetadata: {
+                name,
+                keyvalues,
+            },
+            pinataContent: data,
+        };
+        const res = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: "Bearer " + auth,
+            },
+            body: JSON.stringify(pinataData),
+        });
+        if (!res.ok) {
+            throw new Error(`Pinata error: status: ${res.status} ${res.statusText}`);
+        }
+        const responseData = await res.json();
+        console.log("saveToIPFS result:", responseData);
+        return responseData?.IpfsHash;
+    }
+    catch (error) {
+        console.error("saveToIPFS error:", error?.message);
+        return undefined;
+    }
+}

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

@@ -0,0 +1,75 @@
+import { Field, Bool } from "o1js";
+declare const Storage_base: (new (value: {
+    url: import("o1js/dist/node/lib/provable/field").Field[];
+}) => {
+    url: import("o1js/dist/node/lib/provable/field").Field[];
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    url: import("o1js/dist/node/lib/provable/field").Field[];
+}, {
+    url: bigint[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        url: import("o1js/dist/node/lib/provable/field").Field[];
+    };
+} & {
+    fromValue: (value: {
+        url: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+    }) => {
+        url: import("o1js/dist/node/lib/provable/field").Field[];
+    };
+    toInput: (x: {
+        url: import("o1js/dist/node/lib/provable/field").Field[];
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        url: import("o1js/dist/node/lib/provable/field").Field[];
+    }) => {
+        url: string[];
+    };
+    fromJSON: (x: {
+        url: string[];
+    }) => {
+        url: import("o1js/dist/node/lib/provable/field").Field[];
+    };
+    empty: () => {
+        url: import("o1js/dist/node/lib/provable/field").Field[];
+    };
+};
+/**
+ * Represents the off-chain storage information,
+ * such as an IPFS hash.
+ */
+export declare class Storage extends Storage_base {
+    constructor(value: {
+        url: [Field, Field];
+    });
+    /**
+     * Asserts that two Storage instances are equal.
+     * @param a The first Storage instance.
+     * @param b The second Storage instance.
+     */
+    static assertEquals(a: Storage, b: Storage): void;
+    /**
+     * Checks if two Storage instances are equal.
+     * @param a The first Storage instance.
+     * @param b The second Storage instance.
+     * @returns A Bool indicating whether the two instances are equal.
+     */
+    static equals(a: Storage, b: Storage): Bool;
+    /**
+     * Creates a Storage instance from a string.
+     * @param url The string representing the storage URL.
+     * @returns A new Storage instance.
+     */
+    static fromString(url: string): Storage;
+    /**
+     * Converts the Storage instance to a string.
+     * @returns The string representation of the storage URL.
+     */
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+const o1js_1 = require("o1js");
+/**
+ * Represents the off-chain storage information,
+ * such as an IPFS hash.
+ */
+class Storage extends (0, o1js_1.Struct)({
+    url: o1js_1.Provable.Array(o1js_1.Field, 2),
+}) {
+    constructor(value) {
+        super(value);
+    }
+    /**
+     * Asserts that two Storage instances are equal.
+     * @param a The first Storage instance.
+     * @param b The second Storage instance.
+     */
+    static assertEquals(a, b) {
+        a.url[0].assertEquals(b.url[0]);
+        a.url[1].assertEquals(b.url[1]);
+    }
+    /**
+     * Checks if two Storage instances are equal.
+     * @param a The first Storage instance.
+     * @param b The second Storage instance.
+     * @returns A Bool indicating whether the two instances are equal.
+     */
+    static equals(a, b) {
+        return a.url[0].equals(b.url[0]).and(a.url[1].equals(b.url[1]));
+    }
+    /**
+     * Creates a Storage instance from a string.
+     * @param url The string representing the storage URL.
+     * @returns A new Storage instance.
+     */
+    static fromString(url) {
+        const fields = o1js_1.Encoding.stringToFields(url);
+        if (fields.length !== 2)
+            throw new Error("Invalid string length");
+        return new Storage({ url: [fields[0], fields[1]] });
+    }
+    /**
+     * Converts the Storage instance to a string.
+     * @returns The string representation of the storage URL.
+     */
+    toString() {
+        if (this.url[0].toBigInt() === 0n && this.url[1].toBigInt() === 0n) {
+            throw new Error("Invalid string");
+        }
+        return o1js_1.Encoding.stringFromFields([this.url[0], this.url[1]]);
+    }
+}
+exports.Storage = Storage;

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

@@ -0,0 +1,4 @@
+import { PublicKey, Field } from "o1js";
+export declare function accountExists(address: string | PublicKey, tokenId?: Field): Promise<boolean>;
+export declare function accountBalance(address: string | PublicKey, tokenId?: Field): Promise<number | undefined>;
+export declare function checkAddress(address: string | undefined): Promise<boolean>;

package/lib/ts/src/mina/transactions/accont.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountExists = accountExists;
+exports.accountBalance = accountBalance;
+exports.checkAddress = checkAddress;
+const __1 = require("..");
+const o1js_1 = require("o1js");
+async function accountExists(address, tokenId) {
+    try {
+        const publicKey = typeof address === "string" ? o1js_1.PublicKey.fromBase58(address) : address;
+        await (0, __1.fetchMinaAccount)({ publicKey, tokenId, force: false });
+        return o1js_1.Mina.hasAccount(publicKey, tokenId);
+    }
+    catch (error) {
+        return false;
+    }
+}
+async function accountBalance(address, tokenId) {
+    try {
+        const publicKey = typeof address === "string" ? o1js_1.PublicKey.fromBase58(address) : address;
+        await (0, __1.fetchMinaAccount)({ publicKey, tokenId, force: false });
+        return o1js_1.Mina.hasAccount(publicKey, tokenId)
+            ? Number(o1js_1.Mina.getAccount(publicKey, tokenId).balance.toBigInt())
+            : undefined;
+    }
+    catch (error) {
+        console.error("Cannot fetch account balance", error);
+        return undefined;
+    }
+}
+async function checkAddress(address) {
+    if (!address || typeof address !== "string") {
+        console.error("checkAddress params are invalid:", address);
+        return false;
+    }
+    try {
+        const publicKey = o1js_1.PublicKey.fromBase58(address);
+        if (address !== publicKey.toBase58()) {
+            console.log("checkAddress: address is not valid", address, publicKey.toBase58());
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error("checkAddress catch", { address, error });
+        return false;
+    }
+}

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

@@ -4,3 +4,4 @@ export * from "./txstatus";
 export * from "./chain";
 export * from "./blockberry";
 export * from "./tiny-contract";
+export * from "./send";

package/lib/ts/src/mina/transactions/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./txstatus"), exports);
 __exportStar(require("./chain"), exports);
 __exportStar(require("./blockberry"), exports);
 __exportStar(require("./tiny-contract"), exports);
+__exportStar(require("./send"), exports);

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

@@ -1,4 +1,5 @@
 import { BlockBerryChain } from "./chain";
+import { blockchain } from "../../cloud";
 export declare function getNonce(params: {
     account: string;
     chain: BlockBerryChain;
@@ -8,3 +9,9 @@ export declare function getNonce(params: {
     nonce: number;
     message?: string;
 }>;
+export declare function getAccountNonce(params: {
+    account: string;
+    chain?: blockchain;
+    blockBerryApiKey?: string;
+    verbose?: boolean;
+}): Promise<number>;

package/lib/ts/src/mina/transactions/nonce.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNonce = getNonce;
+exports.getAccountNonce = getAccountNonce;
 const blockberry_1 = require("./blockberry");
+const __1 = require("..");
+const o1js_1 = require("o1js");
 async function getNonce(params) {
     const { account, chain, blockBerryApiKey } = params;
     try {
@@ -58,3 +61,33 @@ async function getNonce(params) {
         };
     }
 }
+async function getAccountNonce(params) {
+    const { account, chain = (0, __1.getCurrentNetwork)().network.chainId, blockBerryApiKey, verbose = true, } = params;
+    const canUseBlockBerry = blockBerryApiKey !== undefined &&
+        (chain === "devnet" || chain === "mainnet");
+    if (chain === "zeko") {
+        const publicKey = o1js_1.PublicKey.fromBase58(account);
+        await (0, __1.fetchMinaAccount)({ publicKey });
+        const nonce = Number(o1js_1.Mina.getAccount(publicKey).nonce.toBigint());
+        return nonce;
+    }
+    else {
+        const blockberryNoncePromise = canUseBlockBerry
+            ? getNonce({
+                account,
+                blockBerryApiKey,
+                chain,
+            })
+            : undefined;
+        const publicKey = o1js_1.PublicKey.fromBase58(account);
+        await (0, __1.fetchMinaAccount)({ publicKey });
+        const senderNonce = Number(o1js_1.Mina.getAccount(publicKey).nonce.toBigint());
+        const blockberryNonce = blockberryNoncePromise
+            ? (await blockberryNoncePromise).nonce ?? -1
+            : -1;
+        const nonce = Math.max(senderNonce, blockberryNonce + 1);
+        if (verbose && nonce > senderNonce)
+            console.log(`Nonce changed from ${senderNonce} to ${nonce} for ${account}`);
+        return nonce;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Mina } from "o1js";
+import { blockchain } from "../../cloud";
+export declare function sendTx(params: {
+    tx: Mina.Transaction<false, true> | Mina.Transaction<true, true>;
+    description?: string;
+    verbose?: boolean;
+    wait?: boolean;
+    chain?: blockchain;
+}): Promise<Mina.PendingTransaction | Mina.RejectedTransaction | Mina.IncludedTransaction | undefined>;
+export declare function getTxStatusFast(params: {
+    hash: string;
+    chain?: blockchain;
+}): Promise<{
+    success: boolean;
+    result?: boolean;
+    error?: string;
+}>;

package/lib/ts/src/mina/transactions/send.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTx = sendTx;
+exports.getTxStatusFast = getTxStatusFast;
+const o1js_1 = require("o1js");
+const cloud_1 = require("../../cloud");
+const __1 = require("..");
+async function sendTx(params) {
+    const { tx, description = "", verbose = true, wait = true, chain = (0, __1.getCurrentNetwork)().network.chainId, } = params;
+    // flatten accountUpdates
+    const accountUpdates = JSON.parse(tx.toJSON()).accountUpdates;
+    const auCount = [];
+    let proofAuthorizationCount = 0;
+    // Calculate the number of account updates for each { publicKey, tokenId }
+    for (const au of accountUpdates) {
+        const { publicKey, tokenId, authorizationKind } = au.body;
+        if (au.authorization.proof) {
+            proofAuthorizationCount++;
+            if (authorizationKind.isProved === false)
+                console.error("Proof authorization exists but isProved is false");
+        }
+        else if (authorizationKind.isProved === true)
+            console.error("isProved is true but no proof authorization");
+        const index = auCount.findIndex((item) => item.publicKey === publicKey && item.tokenId === tokenId);
+        if (index === -1)
+            auCount.push({ publicKey, tokenId, count: 1 });
+        else
+            auCount[index].count++;
+    }
+    if (verbose)
+        console.log(`Account updates for ${description ?? "tx"}: ${auCount.length}, proof authorizations: ${proofAuthorizationCount}`);
+    for (const au of auCount) {
+        if (au.count > 1)
+            if (verbose)
+                console.log(`DUPLICATE AU ${description ?? ""}: ${au.publicKey}  ${au.tokenId !== "wSHV2S4qX9jFsLjQo8r1BsMLH2ZRKsZx6EJd1sbozGPieEC4Jf"
+                    ? "tokenId: " + au.tokenId
+                    : ""} count: ${au.count}`);
+    }
+    try {
+        let txSent;
+        let sent = false;
+        while (!sent) {
+            txSent = await tx.safeSend();
+            if (txSent.status == "pending") {
+                sent = true;
+                if (verbose)
+                    console.log(`${description ?? ""} tx sent: hash: ${txSent.hash} status: ${txSent.status}`);
+            }
+            else if (chain === "zeko") {
+                if (verbose)
+                    console.log("Retrying Zeko tx");
+                await (0, cloud_1.sleep)(10000);
+            }
+            else {
+                console.error(`${description} tx NOT sent: hash: ${txSent?.hash} status: ${txSent?.status}`, txSent.errors);
+                return undefined;
+            }
+        }
+        if (txSent === undefined)
+            throw new Error("txSent is undefined");
+        if (txSent.errors.length > 0) {
+            console.error(`${description ?? ""} tx error: hash: ${txSent.hash} status: ${txSent.status}  errors: ${txSent.errors}`);
+        }
+        if (txSent.status === "pending" && wait !== false && chain !== "zeko") {
+            if (verbose)
+                console.log(`Waiting for tx inclusion...`);
+            const txIncluded = await txSent.safeWait();
+            if (txIncluded.status === "included")
+                if (verbose)
+                    console.log(`${description ?? ""} tx included into block: hash: ${txIncluded.hash} status: ${txIncluded.status}`);
+                else
+                    console.error(`${description ?? ""} tx NOT included into block: hash: ${txIncluded.hash} status: ${txIncluded.status}`);
+            if (chain !== "local") {
+                // we still wait for the tx to be included in the block by checking the nonce
+                // even in the case of tx NOT included
+                // because the tx might still be included in the block in the case of devnet instability
+                const { publicKey, nonce } = tx.transaction.feePayer.body;
+                const started = Date.now();
+                while (Date.now() - started < 1000 * 60 * 10) {
+                    const newNonce = (await (0, __1.fetchMinaAccount)({
+                        publicKey,
+                        force: true,
+                    })).account?.nonce;
+                    if (newNonce &&
+                        Number(newNonce.toBigint()) > Number(nonce.toBigint()))
+                        return txIncluded;
+                    if (verbose)
+                        console.log(`Waiting for ${chain} to update state for ${Math.floor((Date.now() - started) / 1000)} sec...`);
+                    await (0, cloud_1.sleep)(10000);
+                }
+                // finally, if the tx is still not included, show an error
+                console.error(`${chain} do not reflect nonce update for tx ${txIncluded.hash} with status ${txIncluded.status}`);
+            }
+            return txIncluded;
+        }
+        else
+            return txSent;
+    }
+    catch (error) {
+        if (chain !== "zeko")
+            console.error("Error sending tx", error);
+    }
+}
+async function getTxStatusFast(params) {
+    const { hash, chain = (0, __1.getCurrentNetwork)().network.chainId } = params;
+    if (chain === "local" || chain === "zeko")
+        return { success: true, result: true };
+    try {
+        const txStatus = await (0, o1js_1.checkZkappTransaction)(hash);
+        return {
+            success: true,
+            result: txStatus?.success ?? false,
+        };
+    }
+    catch (error) {
+        console.error("getTxStatusFast error while getting tx status - catch", hash, error);
+        return { success: false, error: error?.message ?? "Cannot get tx status" };
+    }
+}

package/lib/ts/src/mina/transactions/transaction.js

@@ -43,11 +43,12 @@ function deserializeTransaction(serializedTransaction, txNew, signedJson) {
         if (forests[i].length > 0) {
             if (transaction.transaction.accountUpdates[i].lazyAuthorization ===
                 undefined ||
-                tx.transaction.accountUpdates[i].lazyAuthorization.args ===
-                    undefined) {
+                transaction.transaction.accountUpdates[i].lazyAuthorization
+                    .args === undefined) {
                 throw new Error(`Lazy authorization args is undefined for item ${i}`);
             }
-            deserializeLazyAuthorization(tx.transaction.accountUpdates[i].lazyAuthorization.args, forests[i]);
+            deserializeLazyAuthorization(transaction.transaction.accountUpdates[i].lazyAuthorization
+                .args, forests[i]);
             if (forests[i].restoredItems !== forests[i].length) {
                 throw new Error(`Forest ${i} not fully restored`);
             }

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

@@ -1,5 +1,5 @@
 import { BlockBerryChain } from "./chain";
-export declare function txStatus(params: {
+export declare function txStatusBlockberry(params: {
     hash: string;
     time: number;
     chain: BlockBerryChain;

package/lib/ts/src/mina/transactions/txstatus.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.txStatus = txStatus;
+exports.txStatusBlockberry = txStatusBlockberry;
 const blockberry_1 = require("./blockberry");
 const TIMEOUT = 1000 * 60 * 21;
-async function txStatus(params) {
+async function txStatusBlockberry(params) {
     const { hash, chain, time, blockBerryApiKey } = params;
     const tx = await (0, blockberry_1.getZkAppTxFromBlockBerry)({ hash, chain, blockBerryApiKey });
     if (tx?.txStatus)

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

@@ -3,5 +3,4 @@ export * from "./fetch";
 export * from "./fields";
 export * from "./fee";
 export * from "./mina";
-export * from "./ipfs";
 export * from "./indexed-map";

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

@@ -19,5 +19,4 @@ __exportStar(require("./fetch"), exports);
 __exportStar(require("./fields"), exports);
 __exportStar(require("./fee"), exports);
 __exportStar(require("./mina"), exports);
-__exportStar(require("./ipfs"), exports);
 __exportStar(require("./indexed-map"), exports);

package/lib/ts/src/mina/utils/indexed-map.d.ts

@@ -12,6 +12,15 @@ export declare function loadIndexedMerkleMap(params: {
     url: string;
     type: ReturnType<typeof IndexedMerkleMap>;
 }): Promise<import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase>;
+export declare function saveIndexedMerkleMap(params: {
+    map: IndexedMerkleMap;
+    name?: string;
+    keyvalues?: {
+        key: string;
+        value: string;
+    }[];
+    auth: string;
+}): Promise<string | undefined>;
 export declare function serializeIndexedMap(map: IndexedMerkleMap): IndexedMapSerialized;
 export declare function deserializeIndexedMerkleMap(params: {
     serializedIndexedMap: IndexedMapSerialized;

package/lib/ts/src/mina/utils/indexed-map.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadIndexedMerkleMap = loadIndexedMerkleMap;
+exports.saveIndexedMerkleMap = saveIndexedMerkleMap;
 exports.serializeIndexedMap = serializeIndexedMap;
 exports.deserializeIndexedMerkleMap = deserializeIndexedMerkleMap;
 exports.parseIndexedMapSerialized = parseIndexedMapSerialized;
 const o1js_1 = require("o1js");
 const cloud_1 = require("../../cloud");
+const pinata_1 = require("../storage/pinata");
 const { IndexedMerkleMap } = o1js_1.Experimental;
 async function loadIndexedMerkleMap(params) {
     const { url, type } = params;
@@ -23,6 +25,17 @@ async function loadIndexedMerkleMap(params) {
     }
     return map;
 }
+async function saveIndexedMerkleMap(params) {
+    const { map, name = "indexed-map", keyvalues, auth } = params;
+    const serialized = serializeIndexedMap(map);
+    const ipfsHash = await (0, pinata_1.pinJSON)({
+        data: serialized,
+        name,
+        keyvalues,
+        auth,
+    });
+    return ipfsHash;
+}
 function serializeIndexedMap(map) {
     return {
         height: map.height,