zkcloudworker 0.18.2 → 0.18.5

package/src/mina/transactions/send.ts

@@ -0,0 +1,186 @@
+import { checkZkappTransaction } from "o1js";
+import { Mina } from "o1js";
+import { sleep, blockchain } from "../../cloud/index.js";
+import { fetchMinaAccount, getCurrentNetwork } from "../index.js";
+
+/**
+ * The function `sendTx` sends a transaction, checks account updates, and waits for
+ * confirmation on the blockchain.
+ * @param params The parameters object
+ * @param params.tx The transaction to send
+ * @param params.description A description of the transaction
+ * @param params.verbose Whether to log verbose information
+ * @param params.wait Whether to wait for the transaction to be included in a block
+ * @param params.chain The blockchain to send the transaction on
+ * @returns The `sendTx` function returns a `Mina.IncludedTransaction`, `Mina.PendingTransaction`,
+ * `Mina.RejectedTransaction`, or `undefined` if there was an error during the process.
+ */
+export async function sendTx(params: {
+  tx: Mina.Transaction<false, true> | Mina.Transaction<true, true>;
+  description?: string;
+  verbose?: boolean;
+  wait?: boolean;
+  chain?: blockchain;
+}): Promise<
+  | Mina.IncludedTransaction
+  | Mina.PendingTransaction
+  | Mina.RejectedTransaction
+  | undefined
+> {
+  const {
+    tx,
+    description = "",
+    verbose = true,
+    wait = true,
+    chain = getCurrentNetwork().network.chainId,
+  } = params;
+  // flatten accountUpdates
+  const accountUpdates = JSON.parse(tx.toJSON()).accountUpdates;
+  const auCount: {
+    publicKey: string;
+    tokenId: string | undefined;
+    count: number;
+  }[] = [];
+  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 sleep(10000);
+      } else {
+        console.error(
+          `${description} tx NOT sent: hash: ${txSent?.hash} status: ${txSent?.status}`,
+          txSent.errors
+        );
+        return txSent;
+      }
+    }
+    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 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 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);
+  }
+}
+
+export async function getTxStatusFast(params: {
+  hash: string;
+  chain?: blockchain;
+}): Promise<{ success: boolean; result?: boolean; error?: string }> {
+  const { hash, chain = getCurrentNetwork().network.chainId } = params;
+  if (chain === "local" || chain === "zeko")
+    return { success: true, result: true };
+
+  try {
+    const txStatus = await checkZkappTransaction(hash);
+    return {
+      success: true,
+      result: txStatus?.success ?? false,
+    };
+  } catch (error: any) {
+    console.error(
+      "getTxStatusFast error while getting tx status - catch",
+      hash,
+      error
+    );
+    return { success: false, error: error?.message ?? "Cannot get tx status" };
+  }
+}

package/src/mina/transactions/tiny-contract.ts

@@ -0,0 +1,9 @@
+import { Field, SmartContract, method, state, State } from "o1js";
+
+export class TinyContract extends SmartContract {
+  @state(Field) value = State<Field>();
+
+  @method async setValue(value: Field) {
+    this.value.set(value);
+  }
+}

package/src/mina/transactions/transaction.ts

@@ -0,0 +1,255 @@
+import { Field, PublicKey, Transaction, Mina, UInt64 } from "o1js";
+import { fieldToBase64, fieldFromBase64 } from "../utils/base64.js";
+
+interface ForestSerialized {
+  length: number;
+  restoredItems?: number;
+  items: {
+    h?: string; // hash
+    p?: string; // previousHash
+    i?: number; // id
+    c?: string; // callData
+  }[];
+}
+
+export function transactionParams(
+  serializedTransaction: string,
+  signedJson: any
+): {
+  fee: UInt64;
+  sender: PublicKey;
+  nonce: number;
+  memo: string;
+} {
+  const { sender, nonce, tx } = JSON.parse(serializedTransaction);
+  const transaction = Mina.Transaction.fromJSON(JSON.parse(tx));
+  const memo = transaction.transaction.memo;
+  return {
+    fee: UInt64.from(signedJson.zkappCommand.feePayer.body.fee),
+    sender: PublicKey.fromBase58(sender),
+    nonce: Number(signedJson.zkappCommand.feePayer.body.nonce),
+    memo,
+  };
+}
+
+export function deserializeTransaction(
+  serializedTransaction: string,
+  txNew: Mina.Transaction<false, false>,
+  signedJson: any
+): Transaction<false, true> {
+  //console.log("new transaction", txNew);
+  const { tx, blindingValues, length, forestJSONs } = JSON.parse(
+    serializedTransaction
+  );
+  const transaction = Mina.Transaction.fromJSON(JSON.parse(tx));
+  const forests: ForestSerialized[] = forestJSONs.map(
+    (f: string) => JSON.parse(f) as ForestSerialized
+  );
+  //console.log("transaction", transaction);
+  if (length !== txNew.transaction.accountUpdates.length) {
+    throw new Error("New Transaction length mismatch");
+  }
+  if (length !== transaction.transaction.accountUpdates.length) {
+    throw new Error("Serialized Transaction length mismatch");
+  }
+  for (let i = 0; i < length; i++) {
+    transaction.transaction.accountUpdates[i].lazyAuthorization =
+      txNew.transaction.accountUpdates[i].lazyAuthorization;
+    if (blindingValues[i] !== "") {
+      if (
+        transaction.transaction.accountUpdates[i].lazyAuthorization ===
+          undefined ||
+        (transaction.transaction.accountUpdates[i].lazyAuthorization as any)
+          .blindingValue === undefined
+      ) {
+        throw new Error(
+          `Lazy authorization blinding value is undefined for item ${i}`
+        );
+      }
+      (
+        transaction.transaction.accountUpdates[i].lazyAuthorization as any
+      ).blindingValue = Field.fromJSON(blindingValues[i]);
+    }
+    if (forests[i].length > 0) {
+      if (
+        transaction.transaction.accountUpdates[i].lazyAuthorization ===
+          undefined ||
+        (transaction.transaction.accountUpdates[i].lazyAuthorization as any)
+          .args === undefined
+      ) {
+        throw new Error(`Lazy authorization args is undefined for item ${i}`);
+      }
+      deserializeLazyAuthorization(
+        (transaction.transaction.accountUpdates[i].lazyAuthorization as any)
+          .args,
+        forests[i]
+      );
+      if (forests[i].restoredItems !== forests[i].length) {
+        throw new Error(`Forest ${i} not fully restored`);
+      }
+    }
+  }
+  transaction.transaction.feePayer.authorization =
+    signedJson.zkappCommand.feePayer.authorization;
+  transaction.transaction.feePayer.body.fee = UInt64.from(
+    signedJson.zkappCommand.feePayer.body.fee
+  );
+  for (let i = 0; i < length; i++) {
+    const signature =
+      signedJson.zkappCommand.accountUpdates[i].authorization.signature;
+    if (signature !== undefined && signature !== null) {
+      transaction.transaction.accountUpdates[i].authorization.signature =
+        signedJson.zkappCommand.accountUpdates[i].authorization.signature;
+    }
+  }
+  return transaction;
+}
+
+export function serializeTransaction(
+  tx: Mina.Transaction<false, false>
+): string {
+  const length = tx.transaction.accountUpdates.length;
+  let i;
+  const blindingValues = [];
+  const forests: ForestSerialized[] = [];
+  for (i = 0; i < length; i++) {
+    const la = tx.transaction.accountUpdates[i].lazyAuthorization;
+    if (
+      la !== undefined &&
+      (la as any).blindingValue !== undefined &&
+      la.kind === "lazy-proof"
+    )
+      blindingValues.push(la.blindingValue.toJSON());
+    else blindingValues.push("");
+    const forest: ForestSerialized = { length: 0, items: [] };
+    serializeLazyAuthorization(
+      (tx.transaction.accountUpdates[i].lazyAuthorization as any)?.args,
+      forest
+    );
+    forests.push(forest);
+  }
+  const serializedTransaction = JSON.stringify(
+    {
+      tx: tx.toJSON(),
+      blindingValues,
+      forestJSONs: forests.map((f) => JSON.stringify(f)),
+      length,
+      fee: tx.transaction.feePayer.body.fee.toJSON(),
+      sender: tx.transaction.feePayer.body.publicKey.toBase58(),
+      nonce: tx.transaction.feePayer.body.nonce.toBigint().toString(),
+    },
+    null,
+    2
+  );
+  return serializedTransaction;
+}
+
+function serializeLazyAuthorization(
+  lazyAuthorization: any,
+  serialized: ForestSerialized
+): void {
+  if (lazyAuthorization?.hash !== undefined && lazyAuthorization.hash.toJSON) {
+    serialized.items.push({
+      h: fieldToBase64(lazyAuthorization.hash),
+    });
+  }
+
+  if (
+    lazyAuthorization?.previousHash !== undefined &&
+    lazyAuthorization.previousHash.toJSON
+  ) {
+    serialized.items.push({
+      p: fieldToBase64(lazyAuthorization.previousHash),
+    });
+  }
+  if (
+    lazyAuthorization?.callData !== undefined &&
+    lazyAuthorization.callData.toJSON
+  ) {
+    serialized.items.push({
+      c: fieldToBase64(lazyAuthorization.callData),
+    });
+  }
+
+  if (lazyAuthorization?.id !== undefined) {
+    serialized.items.push({
+      i: lazyAuthorization.id,
+    });
+  }
+
+  if (Array.isArray(lazyAuthorization)) {
+    for (const item of lazyAuthorization) {
+      serializeLazyAuthorization(item, serialized);
+    }
+  }
+  if (typeof lazyAuthorization === "object") {
+    for (const key in lazyAuthorization) {
+      serializeLazyAuthorization(lazyAuthorization[key], serialized);
+    }
+  }
+  serialized.length = serialized.items.length;
+}
+
+function deserializeLazyAuthorization(
+  lazyAuthorization: any,
+  serialized: ForestSerialized
+): void {
+  if (serialized.restoredItems === undefined) serialized.restoredItems = 0;
+  if (lazyAuthorization?.hash !== undefined && lazyAuthorization.hash.toJSON) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const hash = serialized.items[serialized.restoredItems].h;
+    if (hash === undefined)
+      throw new Error(`Hash is undefined for item ${serialized.restoredItems}`);
+    lazyAuthorization.hash = fieldFromBase64(hash);
+
+    serialized.restoredItems++;
+  }
+  if (
+    lazyAuthorization?.previousHash !== undefined &&
+    lazyAuthorization.previousHash.toJSON
+  ) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const previousHash = serialized.items[serialized.restoredItems].p;
+    if (previousHash === undefined)
+      throw new Error(
+        `Previous hash is undefined for item ${serialized.restoredItems}`
+      );
+    lazyAuthorization.previousHash = fieldFromBase64(previousHash);
+    serialized.restoredItems++;
+  }
+  if (
+    lazyAuthorization?.callData !== undefined &&
+    lazyAuthorization.callData.toJSON
+  ) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const callData = serialized.items[serialized.restoredItems].c;
+    if (callData === undefined)
+      throw new Error(
+        `Call data is undefined for item ${serialized.restoredItems}`
+      );
+    lazyAuthorization.callData = fieldFromBase64(callData);
+    serialized.restoredItems++;
+  }
+  if (lazyAuthorization?.id !== undefined) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const id = serialized.items[serialized.restoredItems].i;
+    if (id === undefined)
+      throw new Error(`Id is undefined for item ${serialized.restoredItems}`);
+    lazyAuthorization.id = id;
+    serialized.restoredItems++;
+  }
+  if (Array.isArray(lazyAuthorization)) {
+    for (const item of lazyAuthorization) {
+      deserializeLazyAuthorization(item, serialized);
+    }
+  }
+  if (typeof lazyAuthorization === "object") {
+    for (const key in lazyAuthorization) {
+      deserializeLazyAuthorization(lazyAuthorization[key], serialized);
+    }
+  }
+}

package/src/mina/transactions/txstatus.ts

@@ -0,0 +1,26 @@
+import { BlockBerryChain } from "./chain.js";
+import { getZkAppTxFromBlockBerry } from "./blockberry.js";
+const TIMEOUT = 1000 * 60 * 21;
+
+export async function txStatusBlockberry(params: {
+  hash: string;
+  time: number;
+  chain: BlockBerryChain;
+  blockBerryApiKey: string;
+  timeout?: number;
+}): Promise<string> {
+  const { hash, chain, time, blockBerryApiKey } = params;
+
+  const tx = await getZkAppTxFromBlockBerry({ hash, chain, blockBerryApiKey });
+  if (tx?.txStatus) return tx?.txStatus;
+  if (Date.now() - time > (params.timeout ?? TIMEOUT)) {
+    console.error(
+      "txStatus: Timeout while checking tx with blockberry",
+      chain,
+      hash
+    );
+    return "replaced";
+  } else {
+    return "pending";
+  }
+}

package/src/mina/utils/base64.ts

@@ -0,0 +1,34 @@
+import { Field } from "o1js";
+import { toBase, fromBase } from "../../cloud/utils/base64.js";
+
+// URL friendly base64 encoding
+const TABLE =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+export function fieldToBase56(field: Field): string {
+  const digits = toBase(field.toBigInt(), 56n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function fieldFromBase56(str: string): Field {
+  const base56Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base56Digits, 56n);
+  return Field(x);
+}
+
+export function fieldToBase64(field: Field): string {
+  const digits = toBase(field.toBigInt(), 64n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function fieldFromBase64(str: string): Field {
+  const base64Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base64Digits, 64n);
+  return Field(x);
+}

package/src/mina/utils/fee.ts

@@ -0,0 +1,11 @@
+import { UInt64 } from "o1js";
+import config from "../../cloud/config.js";
+
+/**
+ * Calculate the fee for a transaction
+ * @returns the fee for a transaction
+ */
+export async function fee(): Promise<UInt64> {
+  //TODO: update after mainnet launch and resolution of the issue https://github.com/o1-labs/o1js/issues/1626
+  return UInt64.fromJSON(config.MINAFEE);
+}

package/src/mina/utils/fetch.ts

@@ -0,0 +1,126 @@
+import {
+  PublicKey,
+  Field,
+  Mina,
+  fetchAccount,
+  checkZkappTransaction,
+} from "o1js";
+import { sleep } from "../../cloud/utils/index.js";
+
+/**
+ * Fetches the Mina account for a given public key with error handling
+ * @param params the parameters for fetching the account
+ * @param params.publicKey the public key of the account
+ * @param params.tokenId the token id of the account
+ * @param params.force whether to force the fetch - use it only if you are sure the account exists
+ * @returns the account object
+ */
+export async function fetchMinaAccount(params: {
+  publicKey: string | PublicKey;
+  tokenId?: string | Field | undefined;
+  force?: boolean;
+}) {
+  const { publicKey, tokenId, force = false } = params;
+  const timeout = 1000 * 60 * 3; // 3 minutes
+  let attempt = 0;
+  const startTime = Date.now();
+  let result = { account: undefined };
+  while (Date.now() - startTime < timeout) {
+    try {
+      const result = await fetchAccount({
+        publicKey,
+        tokenId,
+      });
+      return result;
+    } catch (error: any) {
+      if (force === true)
+        console.log("Error in fetchMinaAccount:", {
+          error,
+          publicKey:
+            typeof publicKey === "string" ? publicKey : publicKey.toBase58(),
+          tokenId: tokenId?.toString(),
+          force,
+        });
+      else {
+        console.log("fetchMinaAccount error", {
+          error,
+          publicKey:
+            typeof publicKey === "string" ? publicKey : publicKey.toBase58(),
+          tokenId: tokenId?.toString(),
+          force,
+        });
+        return result;
+      }
+    }
+    attempt++;
+    await sleep(1000 * 6 * attempt); // to handle rate limit we increase the interval
+  }
+  if (force === true)
+    throw new Error(
+      `fetchMinaAccount timeout
+      ${{
+        publicKey:
+          typeof publicKey === "string" ? publicKey : publicKey.toBase58(),
+        tokenId: tokenId?.toString(),
+        force,
+      }}`
+    );
+  else
+    console.log(
+      "fetchMinaAccount timeout",
+      typeof publicKey === "string" ? publicKey : publicKey.toBase58(),
+      tokenId?.toString(),
+      force
+    );
+  return result;
+}
+
+/**
+ * Fetches the Mina actions for a given public key with error handling
+ * @param publicKey the public key of the contract
+ * @param fromActionState the starting action state
+ * @param endActionState the ending action state
+ * @returns the actions array
+ */
+
+export async function fetchMinaActions(
+  publicKey: PublicKey,
+  fromActionState: Field,
+  endActionState?: Field
+) {
+  const timeout = 1000 * 60 * 600; // 10 hours
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      let actions = await Mina.fetchActions(publicKey, {
+        fromActionState,
+        endActionState,
+      });
+      if (Array.isArray(actions)) return actions;
+      else console.log("Cannot fetch actions - wrong format");
+    } catch (error: any) {
+      console.log(
+        "Error in fetchMinaActions",
+        error.toString().substring(0, 300)
+      );
+    }
+    await sleep(1000 * 60 * 2);
+  }
+  console.log("Timeout in fetchMinaActions");
+  return undefined;
+}
+
+/**
+ * Fetches the Mina transaction for a given hash with error handling
+ * @param hash the hash of the transaction
+ * @returns the transaction object
+ */
+export async function checkMinaZkappTransaction(hash: string) {
+  try {
+    const result = await checkZkappTransaction(hash);
+    return result;
+  } catch (error) {
+    console.error("Error in checkZkappTransaction:", error);
+    return { success: false };
+  }
+}

package/src/mina/utils/fields.ts

@@ -0,0 +1,39 @@
+import { Field, Poseidon } from "o1js";
+import { fieldToBase64, fieldFromBase64 } from "./base64.js";
+
+/**
+ * Serialize fields to a string using base64 URL-friendly encoding
+ * @param fields the fields array to serialize
+ * @returns the serialized string
+ */
+export function serializeFields(fields: Field[]): string {
+  const hash = Poseidon.hash(fields);
+  const value = [Field(fields.length), hash, ...fields];
+  //return value.map((f) => f.toBigInt().toString(36)).join(".");
+  return value.map((f) => fieldToBase64(f)).join(".");
+}
+
+/**
+ * Deserialize fields from a string using base64 URL-friendly encoding
+ * @param s the string to deserialize
+ * @returns the deserialized fields array
+ */
+export function deserializeFields(s: string): Field[] {
+  try {
+    //const value = s.split(".").map((n) => Field(BigInt(convert(n, 36))));
+    const value = s.split(".").map((n) => fieldFromBase64(n));
+    const length = value[0];
+    if (
+      Field(value.length - 2)
+        .equals(length)
+        .toBoolean() === false
+    )
+      throw new Error("deserializeFields: invalid length");
+    const hash = Poseidon.hash(value.slice(2));
+    if (hash.equals(value[1]).toBoolean()) {
+      return value.slice(2);
+    } else throw new Error("deserializeFields: invalid hash: data mismatch");
+  } catch (e: any) {
+    throw new Error(`deserializeFields: invalid string: ${s}: ${e}`);
+  }
+}

package/src/mina/utils/index.ts

@@ -0,0 +1,6 @@
+export * from "./base64.js";
+export * from "./fetch.js";
+export * from "./fields.js";
+export * from "./fee.js";
+export * from "./mina.js";
+export * from "./indexed-map.js";