zkcloudworker 0.18.2 → 0.18.4

package/src/cloud/utils/base64.ts

@@ -0,0 +1,87 @@
+// URL friendly base64 encoding
+const TABLE =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+export function bigintToBase56(value: bigint): string {
+  const digits = toBase(value, 56n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function bigintFromBase56(str: string): bigint {
+  const base56Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base56Digits, 56n);
+  return x;
+}
+
+export function bigintToBase64(value: bigint): string {
+  const digits = toBase(value, 64n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function bigintFromBase64(str: string): bigint {
+  const base64Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base64Digits, 64n);
+  return x;
+}
+
+export function fromBase(digits: bigint[], base: bigint) {
+  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;
+}
+
+export function toBase(x: bigint, base: bigint) {
+  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;
+}

package/src/cloud/utils/graphql.ts

@@ -0,0 +1,252 @@
+type QueryType = "balance" | "account";
+
+export const defaultToken =
+  "wSHV2S4qX9jFsLjQo8r1BsMLH2ZRKsZx6EJd1sbozGPieEC4Jf";
+
+export async function getBalanceFromGraphQL(params: {
+  publicKey: string;
+  tokenId?: string;
+  mina: string[];
+}): Promise<bigint> {
+  const { publicKey, mina } = params;
+  const tokenId = params.tokenId ?? defaultToken;
+  if (mina.length === 0) throw new Error("no mina endpoints provided");
+  const account = await fetchAccountInternal({
+    publicKey,
+    tokenId,
+    mina,
+    queryType: "balance",
+  });
+  //console.log("getBalanceFromGraphQL account:", account);
+  const balance = (account as any)?.account?.balance?.total;
+  return balance ? BigInt(balance) : 0n;
+}
+
+export async function getAccountFromGraphQL(params: {
+  publicKey: string;
+  tokenId?: string;
+  mina: string[];
+}) {
+  const { publicKey, mina } = params;
+  const tokenId = params.tokenId ?? defaultToken;
+  if (mina.length === 0) throw new Error("no mina endpoints provided");
+  const account = await fetchAccountInternal({
+    publicKey,
+    tokenId,
+    mina,
+    queryType: "account",
+  });
+  return (account as any)?.account;
+}
+
+async function fetchAccountInternal(params: {
+  publicKey: string;
+  tokenId: string;
+  mina: string[];
+  timeout?: number;
+  queryType: QueryType;
+}) {
+  const { publicKey, tokenId, mina, timeout, queryType } = params;
+  const query =
+    queryType === "balance"
+      ? balanceQuery(publicKey, tokenId)
+      : accountQuery(publicKey, tokenId);
+  let [response, error] = await makeGraphqlRequest({
+    query,
+    mina,
+    timeout,
+  });
+  if (error !== undefined) return { account: undefined, error };
+  const account = (response as any)?.data?.account;
+  if (!account) {
+    return {
+      account: undefined,
+      error: {
+        statusCode: 404,
+        statusText: `fetchAccount: Account with public key ${publicKey} does not exist.`,
+      },
+    };
+  }
+  return {
+    account,
+    error: undefined,
+  };
+}
+
+async function makeGraphqlRequest(params: {
+  query: string;
+  mina: string[];
+  timeout?: number;
+}) {
+  const defaultTimeout = 5 * 60 * 1000; // 5 minutes
+  const timeout = params.timeout ?? defaultTimeout;
+  const { query, mina } = params;
+  const graphqlEndpoint = mina[0];
+  const fallbackEndpoints: string[] = mina.slice(1);
+  if (graphqlEndpoint === "none")
+    throw Error(
+      "Should have made a graphql request, but don't know to which endpoint."
+    );
+  let timeouts: NodeJS.Timeout[] = [];
+  const clearTimeouts = () => {
+    timeouts.forEach((t) => clearTimeout(t));
+    timeouts = [];
+  };
+
+  const makeRequest = async (url: string) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    timeouts.push(timer);
+    let body = JSON.stringify({
+      operationName: null,
+      query,
+      variables: {},
+    });
+    try {
+      let response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: controller.signal,
+      });
+      return checkResponseStatus(response);
+    } finally {
+      clearTimeouts();
+    }
+  };
+  // try to fetch from endpoints in pairs
+  let timeoutErrors: { url1: string; url2: string; error: any }[] = [];
+  let urls = [graphqlEndpoint, ...fallbackEndpoints];
+  for (let i = 0; i < urls.length; i += 2) {
+    let url1 = urls[i];
+    let url2 = urls[i + 1];
+    if (url2 === undefined) {
+      try {
+        return await makeRequest(url1);
+      } catch (error) {
+        return [undefined, inferError(error)] as [undefined, object];
+      }
+    }
+    try {
+      return await Promise.race([makeRequest(url1), makeRequest(url2)]);
+    } catch (unknownError) {
+      let error = inferError(unknownError);
+      if (error.statusCode === 408) {
+        // If the request timed out, try the next 2 endpoints
+        timeoutErrors.push({ url1, url2, error });
+      } else {
+        // If the request failed for some other reason (e.g. o1js error), return the error
+        return [undefined, error];
+      }
+    }
+  }
+  const statusText = timeoutErrors
+    .map(
+      ({ url1, url2, error }) =>
+        `Request to ${url1} and ${url2} timed out. Error: ${error}`
+    )
+    .join("\n");
+  return [undefined, { statusCode: 408, statusText }];
+}
+
+function inferError(error: unknown) {
+  let errorMessage = JSON.stringify(error);
+  if (error instanceof AbortSignal) {
+    return { statusCode: 408, statusText: `Request Timeout: ${errorMessage}` };
+  } else {
+    return {
+      statusCode: 500,
+      statusText: `Unknown Error: ${errorMessage}`,
+    };
+  }
+}
+
+async function checkResponseStatus(
+  response: Response
+): Promise<[object, undefined] | [undefined, object]> {
+  if (response.ok) {
+    const jsonResponse = (await response.json()) as any;
+    if (jsonResponse.errors && jsonResponse.errors.length > 0) {
+      return [
+        undefined,
+        {
+          statusCode: response.status,
+          statusText: jsonResponse.errors
+            .map((error: any) => error.message)
+            .join("\n"),
+        },
+      ];
+    } else if (jsonResponse.data === undefined) {
+      return [
+        undefined,
+        {
+          statusCode: response.status,
+          statusText: `GraphQL response data is undefined`,
+        },
+      ];
+    }
+    return [jsonResponse, undefined];
+  } else {
+    return [
+      undefined,
+      {
+        statusCode: response.status,
+        statusText: response.statusText,
+      },
+    ];
+  }
+}
+
+const balanceQuery = (publicKey: string, tokenId: string) => `{
+  account(publicKey: "${publicKey}", token: "${tokenId}") {
+    balance { total }
+  }
+}
+`;
+
+const accountQuery = (publicKey: string, tokenId: string) => `{
+  account(publicKey: "${publicKey}", token: "${tokenId}") {
+    publicKey
+    token
+    nonce
+    balance { total }
+    tokenSymbol
+    receiptChainHash
+    timing {
+      initialMinimumBalance
+      cliffTime
+      cliffAmount
+      vestingPeriod
+      vestingIncrement
+    }
+    permissions {
+      editState
+      access
+      send
+      receive
+      setDelegate
+      setPermissions
+      setVerificationKey {
+        auth
+        txnVersion
+      }
+      setZkappUri
+      editActionState
+      setTokenSymbol
+      incrementNonce
+      setVotingFor
+      setTiming
+    }
+    delegateAccount { publicKey }
+    votingFor
+    zkappState
+    verificationKey {
+      verificationKey
+      hash
+    }
+    actionState
+    provedState
+    zkappUri
+  }
+}
+`;

package/src/cloud/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./graphql.js";
+export * from "./utils.js";
+export * from "./base64.js";

package/src/cloud/utils/utils.ts

@@ -0,0 +1,79 @@
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function makeString(length: number): string {
+  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+  let outString: string = ``;
+  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+  const inOptions: string = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`;
+
+  for (let i = 0; i < length; i++) {
+    outString += inOptions.charAt(Math.floor(Math.random() * inOptions.length));
+  }
+
+  return outString;
+}
+
+export function formatTime(ms: number): string {
+  if (ms === undefined) return "";
+  if (ms < 1000) return ms.toString() + " ms";
+  if (ms < 60 * 1000)
+    return parseInt((ms / 1000).toString()).toString() + " sec";
+  if (ms < 60 * 60 * 1000) {
+    const minutes = parseInt((ms / 1000 / 60).toString());
+    const seconds = parseInt(((ms - minutes * 60 * 1000) / 1000).toString());
+    return minutes.toString() + " min " + seconds.toString() + " sec";
+  } else {
+    const hours = parseInt((ms / 1000 / 60 / 60).toString());
+    const minutes = parseInt(
+      ((ms - hours * 60 * 60 * 1000) / 1000 / 60).toString()
+    );
+    return hours.toString() + " h " + minutes.toString() + " min";
+  }
+}
+
+export class Memory {
+  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+  static rss: number = 0;
+  constructor() {
+    Memory.rss = 0;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+  public static info(description: string = ``, fullInfo: boolean = false) {
+    const memoryData = process.memoryUsage();
+    const formatMemoryUsage = (data: number) =>
+      `${Math.round(data / 1024 / 1024)} MB`;
+    const oldRSS = Memory.rss;
+    Memory.rss = Math.round(memoryData.rss / 1024 / 1024);
+
+    const memoryUsage = fullInfo
+      ? {
+          step: `${description}:`,
+          rssDelta: `${(oldRSS === 0
+            ? 0
+            : Memory.rss - oldRSS
+          ).toString()} MB -> Resident Set Size memory change`,
+          rss: `${formatMemoryUsage(
+            memoryData.rss
+          )} -> Resident Set Size - total memory allocated`,
+          heapTotal: `${formatMemoryUsage(
+            memoryData.heapTotal
+          )} -> total size of the allocated heap`,
+          heapUsed: `${formatMemoryUsage(
+            memoryData.heapUsed
+          )} -> actual memory used during the execution`,
+          external: `${formatMemoryUsage(
+            memoryData.external
+          )} -> V8 external memory`,
+        }
+      : `RSS memory ${description}: ${formatMemoryUsage(memoryData.rss)}${
+          oldRSS === 0
+            ? ``
+            : `, changed by ` + (Memory.rss - oldRSS).toString() + ` MB`
+        }`;
+
+    console.log(memoryUsage);
+  }
+}