zkcloudworker 0.18.12 → 0.18.15

package/dist/node/index.cjs

@@ -0,0 +1,4055 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/node/index.js
+var node_exports = {};
+__export(node_exports, {
+  Cloud: () => Cloud,
+  Devnet: () => Devnet,
+  FungibleToken: () => FungibleToken,
+  FungibleTokenAdmin: () => FungibleTokenAdmin,
+  FungibleTokenBidContract: () => FungibleTokenBidContract,
+  FungibleTokenOfferContract: () => FungibleTokenOfferContract,
+  FungibleTokenWhitelistedAdmin: () => FungibleTokenWhitelistedAdmin,
+  LAUNCH_FEE: () => LAUNCH_FEE,
+  Lightnet: () => Lightnet,
+  Local: () => Local,
+  LocalCloud: () => LocalCloud,
+  LocalStorage: () => LocalStorage,
+  Mainnet: () => Mainnet,
+  Memory: () => Memory,
+  Storage: () => Storage,
+  TRANSACTION_FEE: () => TRANSACTION_FEE,
+  TinyContract: () => TinyContract,
+  TokenAPI: () => TokenAPI,
+  UInt64Option: () => UInt64Option,
+  Whitelist: () => Whitelist,
+  WhitelistMap: () => WhitelistMap,
+  WhitelistMapOption: () => WhitelistMapOption,
+  WhitelistedAddress: () => WhitelistedAddress,
+  WhitelistedFungibleToken: () => WhitelistedFungibleToken,
+  Zeko: () => Zeko,
+  accountBalance: () => accountBalance,
+  accountBalanceMina: () => accountBalanceMina,
+  accountExists: () => accountExists,
+  bigintFromBase56: () => bigintFromBase56,
+  bigintFromBase64: () => bigintFromBase64,
+  bigintToBase56: () => bigintToBase56,
+  bigintToBase64: () => bigintToBase64,
+  buildTokenDeployTransaction: () => buildTokenDeployTransaction,
+  buildTokenTransaction: () => buildTokenTransaction,
+  checkAddress: () => checkAddress,
+  checkMinaZkappTransaction: () => checkMinaZkappTransaction,
+  createIpfsURL: () => createIpfsURL,
+  currentNetwork: () => currentNetwork,
+  defaultToken: () => defaultToken,
+  deserializeFields: () => deserializeFields,
+  deserializeIndexedMerkleMap: () => deserializeIndexedMerkleMap,
+  deserializeTransaction: () => deserializeTransaction,
+  fee: () => fee,
+  fetchMinaAccount: () => fetchMinaAccount,
+  fetchMinaActions: () => fetchMinaActions,
+  fieldFromBase56: () => fieldFromBase56,
+  fieldFromBase64: () => fieldFromBase64,
+  fieldToBase56: () => fieldToBase56,
+  fieldToBase64: () => fieldToBase64,
+  formatTime: () => formatTime,
+  fromBase: () => fromBase,
+  fungibleTokenVerificationKeys: () => fungibleTokenVerificationKeys,
+  getAccountFromGraphQL: () => getAccountFromGraphQL,
+  getAccountNonce: () => getAccountNonce,
+  getBalanceFromGraphQL: () => getBalanceFromGraphQL,
+  getCurrentNetwork: () => getCurrentNetwork,
+  getDeployer: () => getDeployer,
+  getNetworkIdHash: () => getNetworkIdHash,
+  getNonce: () => getNonce,
+  getPaymentTxsFromBlockBerry: () => getPaymentTxsFromBlockBerry,
+  getTokenSymbolAndAdmin: () => getTokenSymbolAndAdmin,
+  getTxStatusFast: () => getTxStatusFast,
+  getZkAppFromBlockBerry: () => getZkAppFromBlockBerry,
+  getZkAppTxFromBlockBerry: () => getZkAppTxFromBlockBerry,
+  getZkAppTxsFromBlockBerry: () => getZkAppTxsFromBlockBerry,
+  initBlockchain: () => initBlockchain,
+  loadIndexedMerkleMap: () => loadIndexedMerkleMap,
+  makeString: () => makeString,
+  networks: () => networks,
+  parseIndexedMapSerialized: () => parseIndexedMapSerialized,
+  pinJSON: () => pinJSON,
+  saveIndexedMerkleMap: () => saveIndexedMerkleMap,
+  sendTx: () => sendTx,
+  serializeFields: () => serializeFields,
+  serializeIndexedMap: () => serializeIndexedMap,
+  serializeTransaction: () => serializeTransaction,
+  sleep: () => sleep,
+  toBase: () => toBase,
+  tokenBalance: () => tokenBalance,
+  tokenVerificationKeys: () => tokenVerificationKeys,
+  transactionParams: () => transactionParams,
+  txStatusBlockberry: () => txStatusBlockberry,
+  zkCloudWorker: () => zkCloudWorker,
+  zkCloudWorkerClient: () => zkCloudWorkerClient
+});
+module.exports = __toCommonJS(node_exports);
+
+// dist/node/cloud/utils/graphql.js
+var defaultToken = "wSHV2S4qX9jFsLjQo8r1BsMLH2ZRKsZx6EJd1sbozGPieEC4Jf";
+async function getBalanceFromGraphQL(params) {
+  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"
+  });
+  const balance = account?.account?.balance?.total;
+  return balance ? BigInt(balance) : 0n;
+}
+async function getAccountFromGraphQL(params) {
+  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?.account;
+}
+async function fetchAccountInternal(params) {
+  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 !== void 0)
+    return { account: void 0, error };
+  const account = response?.data?.account;
+  if (!account) {
+    return {
+      account: void 0,
+      error: {
+        statusCode: 404,
+        statusText: `fetchAccount: Account with public key ${publicKey} does not exist.`
+      }
+    };
+  }
+  return {
+    account,
+    error: void 0
+  };
+}
+async function makeGraphqlRequest(params) {
+  const defaultTimeout = 5 * 60 * 1e3;
+  const timeout = params.timeout ?? defaultTimeout;
+  const { query, mina } = params;
+  const graphqlEndpoint = mina[0];
+  const fallbackEndpoints = mina.slice(1);
+  if (graphqlEndpoint === "none")
+    throw Error("Should have made a graphql request, but don't know to which endpoint.");
+  let timeouts = [];
+  const clearTimeouts = () => {
+    timeouts.forEach((t) => clearTimeout(t));
+    timeouts = [];
+  };
+  const makeRequest = async (url) => {
+    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();
+    }
+  };
+  let timeoutErrors = [];
+  let urls = [graphqlEndpoint, ...fallbackEndpoints];
+  for (let i = 0; i < urls.length; i += 2) {
+    let url1 = urls[i];
+    let url2 = urls[i + 1];
+    if (url2 === void 0) {
+      try {
+        return await makeRequest(url1);
+      } catch (error) {
+        return [void 0, inferError(error)];
+      }
+    }
+    try {
+      return await Promise.race([makeRequest(url1), makeRequest(url2)]);
+    } catch (unknownError) {
+      let error = inferError(unknownError);
+      if (error.statusCode === 408) {
+        timeoutErrors.push({ url1, url2, error });
+      } else {
+        return [void 0, error];
+      }
+    }
+  }
+  const statusText = timeoutErrors.map(({ url1, url2, error }) => `Request to ${url1} and ${url2} timed out. Error: ${error}`).join("\n");
+  return [void 0, { statusCode: 408, statusText }];
+}
+function inferError(error) {
+  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) {
+  if (response.ok) {
+    const jsonResponse = await response.json();
+    if (jsonResponse.errors && jsonResponse.errors.length > 0) {
+      return [
+        void 0,
+        {
+          statusCode: response.status,
+          statusText: jsonResponse.errors.map((error) => error.message).join("\n")
+        }
+      ];
+    } else if (jsonResponse.data === void 0) {
+      return [
+        void 0,
+        {
+          statusCode: response.status,
+          statusText: `GraphQL response data is undefined`
+        }
+      ];
+    }
+    return [jsonResponse, void 0];
+  } else {
+    return [
+      void 0,
+      {
+        statusCode: response.status,
+        statusText: response.statusText
+      }
+    ];
+  }
+}
+var balanceQuery = (publicKey, tokenId) => `{
+  account(publicKey: "${publicKey}", token: "${tokenId}") {
+    balance { total }
+  }
+}
+`;
+var accountQuery = (publicKey, tokenId) => `{
+  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
+  }
+}
+`;
+
+// dist/node/cloud/utils/utils.js
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function makeString(length) {
+  let outString = ``;
+  const inOptions = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`;
+  for (let i = 0; i < length; i++) {
+    outString += inOptions.charAt(Math.floor(Math.random() * inOptions.length));
+  }
+  return outString;
+}
+function formatTime(ms) {
+  if (ms === void 0)
+    return "";
+  if (ms < 1e3)
+    return ms.toString() + " ms";
+  if (ms < 60 * 1e3)
+    return parseInt((ms / 1e3).toString()).toString() + " sec";
+  if (ms < 60 * 60 * 1e3) {
+    const minutes = parseInt((ms / 1e3 / 60).toString());
+    const seconds = parseInt(((ms - minutes * 60 * 1e3) / 1e3).toString());
+    return minutes.toString() + " min " + seconds.toString() + " sec";
+  } else {
+    const hours = parseInt((ms / 1e3 / 60 / 60).toString());
+    const minutes = parseInt(((ms - hours * 60 * 60 * 1e3) / 1e3 / 60).toString());
+    return hours.toString() + " h " + minutes.toString() + " min";
+  }
+}
+var Memory = class _Memory {
+  constructor() {
+    _Memory.rss = 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
+  static info(description = ``, fullInfo = false) {
+    const memoryData = process.memoryUsage();
+    const formatMemoryUsage = (data) => `${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);
+  }
+};
+Memory.rss = 0;
+
+// dist/node/cloud/utils/base64.js
+var TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function bigintToBase56(value) {
+  const digits = toBase(value, 56n);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  return str;
+}
+function bigintFromBase56(str) {
+  const base56Digits = str.split("").map((x2) => BigInt(TABLE.indexOf(x2)));
+  const x = fromBase(base56Digits, 56n);
+  return x;
+}
+function bigintToBase64(value) {
+  const digits = toBase(value, 64n);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  return str;
+}
+function bigintFromBase64(str) {
+  const base64Digits = str.split("").map((x2) => BigInt(TABLE.indexOf(x2)));
+  const x = fromBase(base64Digits, 64n);
+  return x;
+}
+function fromBase(digits, base) {
+  if (base <= 0n)
+    throw Error("fromBase: base must be positive");
+  let basePowers = [];
+  for (let power = base, n = 1; n < digits.length; power **= 2n, n *= 2) {
+    basePowers.push(power);
+  }
+  let k = basePowers.length;
+  digits = digits.concat(Array(2 ** k - digits.length).fill(0n));
+  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;
+}
+function toBase(x, base) {
+  if (base <= 0n)
+    throw Error("toBase: base must be positive");
+  let basePowers = [];
+  for (let power = base; power <= x; power **= 2n) {
+    basePowers.push(power);
+  }
+  let digits = [x];
+  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 x2 = digits[j];
+      let high = x2 / basePower;
+      newDigits[2 * j + 1] = high;
+      newDigits[2 * j] = x2 - high * basePower;
+    }
+    digits = newDigits;
+  }
+  while (digits[digits.length - 1] === 0n) {
+    digits.pop();
+  }
+  return digits;
+}
+
+// dist/node/cloud/worker/cloud.js
+var Cloud = class {
+  /**
+   * Constructor for the Cloud class
+   * @param params the parameters for the Cloud class
+   * @param params.id the id of the user
+   * @param params.jobId the job id
+   * @param params.stepId the step id
+   * @param params.taskId the task id
+   * @param params.cache the cache folder. Use it to get the Cache object: cache = Cache.FileSystem(this.cloud.cache);
+   * @param params.developer the developer id
+   * @param params.repo the repo id
+   * @param params.task the task id
+   * @param params.userId the user id
+   * @param params.args the arguments, should be a string or serialized JSON
+   * @param params.metadata the metadata, should be a string or serialized JSON
+   * @param params.chain the blockchain network
+   * @param params.isLocalCloud a boolean to check if the cloud is local or not
+   */
+  constructor(params) {
+    const { id, jobId, stepId, taskId, cache, developer, repo, task, userId, args, metadata, isLocalCloud, chain } = params;
+    this.id = id;
+    this.jobId = jobId;
+    this.stepId = stepId;
+    this.taskId = taskId;
+    this.cache = cache;
+    this.developer = developer;
+    this.repo = repo;
+    this.task = task;
+    this.userId = userId;
+    this.args = args;
+    this.metadata = metadata;
+    this.isLocalCloud = isLocalCloud ?? false;
+    this.chain = chain;
+  }
+};
+
+// dist/node/cloud/worker/worker.js
+var zkCloudWorker = class {
+  /**
+   * Constructor for the zkCloudWorker class
+   * @param cloud the cloud instance provided by the zkCloudWorker in the local environment or in the cloud
+   */
+  constructor(cloud) {
+    this.cloud = cloud;
+  }
+  // Those methods should be implemented for recursive proofs calculations
+  /**
+   * Creates a new proof from a transaction
+   * @param transaction the transaction
+   * @returns the serialized proof
+   */
+  async create(transaction) {
+    return void 0;
+  }
+  /**
+   * Merges two proofs
+   * @param proof1 the first proof
+   * @param proof2 the second proof
+   * @returns the merged proof
+   */
+  async merge(proof1, proof2) {
+    return void 0;
+  }
+  // Those methods should be implemented for anything except for recursive proofs
+  /**
+   * Executes the transactions
+   * @param transactions the transactions, can be empty list
+   * @returns the result
+   */
+  async execute(transactions) {
+    return void 0;
+  }
+  /* Process the transactions received by the cloud
+   * @param transactions: the transactions
+   */
+  async processTransactions(transactions) {
+  }
+  /**
+   * process the task defined by the developer
+   * @returns the result
+   */
+  async task() {
+    return void 0;
+  }
+};
+
+// dist/node/cloud/config.js
+var config = {
+  MINAFEE: "200000000",
+  ZKCLOUDWORKER_AUTH: "M6t4jtbBAFFXhLERHQWyEB9JA9xi4cWqmYduaCXtbrFjb7yaY7TyaXDunKDJNiUTBEcyUomNXJgC",
+  ZKCLOUDWORKER_API: "https://api.zkcloudworker.com/v1/",
+  ZKCLOUDWORKER_NATS: "https://cloud.zkcloudworker.com:4222",
+  ZKCLOUDWORKER_NATS_WS: "wss://cloud.zkcloudworker.com:4223"
+};
+var config_default = config;
+
+// dist/node/cloud/networks.js
+var Mainnet = {
+  mina: [
+    //"https://proxy.devnet.minaexplorer.com/graphql",
+    "https://api.minascan.io/node/mainnet/v1/graphql"
+  ],
+  archive: [
+    "https://api.minascan.io/archive/mainnet/v1/graphql"
+    //"https://archive.devnet.minaexplorer.com",
+  ],
+  explorerAccountUrl: "https://minascan.io/mainnet/account/",
+  explorerTransactionUrl: "https://minascan.io/mainnet/tx/",
+  chainId: "mainnet",
+  name: "Mainnet"
+};
+var Local = {
+  mina: [],
+  archive: [],
+  chainId: "local"
+};
+var Devnet = {
+  mina: [
+    "https://api.minascan.io/node/devnet/v1/graphql"
+    //"https://proxy.devnet.minaexplorer.com/graphql",
+  ],
+  archive: [
+    "https://api.minascan.io/archive/devnet/v1/graphql"
+    //"https://archive.devnet.minaexplorer.com",
+  ],
+  explorerAccountUrl: "https://minascan.io/devnet/account/",
+  explorerTransactionUrl: "https://minascan.io/devnet/tx/",
+  chainId: "devnet",
+  name: "Devnet",
+  faucet: "https://faucet.minaprotocol.com"
+};
+var Zeko = {
+  mina: ["https://devnet.zeko.io/graphql"],
+  archive: ["https://devnet.zeko.io/graphql"],
+  explorerAccountUrl: "https://zekoscan.io/devnet/account/",
+  explorerTransactionUrl: "https://zekoscan.io/devnet/tx/",
+  chainId: "zeko",
+  name: "Zeko",
+  faucet: "https://zeko.io/faucet"
+};
+var Lightnet = {
+  mina: ["http://localhost:8080/graphql"],
+  archive: ["http://localhost:8282"],
+  accountManager: "http://localhost:8181",
+  chainId: "lightnet",
+  name: "Lightnet"
+};
+var networks = [Mainnet, Local, Devnet, Zeko, Lightnet];
+
+// dist/node/mina/api/api.js
+var import_axios = __toESM(require("axios"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+
+// dist/node/mina/local/local.js
+var LocalCloud = class _LocalCloud extends Cloud {
+  /**
+   * Constructor for LocalCloud
+   * @param params the parameters to create the LocalCloud
+   * @param params.job the job data
+   * @param params.chain the blockchain to execute the job on, can be any blockchain, not only local
+   * @param params.cache the cache folder
+   * @param params.stepId the step id
+   * @param params.localWorker the worker to execute the tasks
+   */
+  constructor(params) {
+    const { job, chain, cache, stepId, localWorker } = params;
+    const { id, jobId, developer, repo, task, userId, args, metadata, taskId } = job;
+    super({
+      id,
+      jobId,
+      stepId: stepId ?? "stepId",
+      taskId: taskId ?? "taskId",
+      cache: cache ?? "./cache",
+      developer,
+      repo,
+      task,
+      userId,
+      args,
+      metadata,
+      isLocalCloud: true,
+      chain
+    });
+    this.localWorker = localWorker;
+  }
+  /**
+   * Provides the deployer key pair for testing and development
+   * @returns the deployer key pair
+   */
+  async getDeployer() {
+    const privateKey = process.env.DEPLOYER_PRIVATE_KEY;
+    const publicKey = process.env.DEPLOYER_PUBLIC_KEY;
+    try {
+      return privateKey === void 0 || publicKey === void 0 ? void 0 : {
+        privateKey,
+        publicKey
+      };
+    } catch (error) {
+      console.error(`getDeployer: error getting deployer key pair: ${error}`, error);
+      return void 0;
+    }
+  }
+  /**
+   * Releases the deployer key pair
+   */
+  async releaseDeployer(params) {
+    console.log("LocalCloud: releaseDeployer", params);
+  }
+  /**
+   * Gets the data by key
+   * @param key the key to get the data
+   * @returns the data
+   */
+  async getDataByKey(key) {
+    const value = LocalStorage.data[key];
+    return value;
+  }
+  /**
+   * Saves the data by key
+   * @param key the key to save the data
+   * @param value the value to save
+   */
+  async saveDataByKey(key, value) {
+    if (value !== void 0)
+      LocalStorage.data[key] = value;
+    else
+      delete LocalStorage.data[key];
+  }
+  /**
+   * Saves the file
+   * @param filename the filename to save
+   * @param value the value to save
+   */
+  async saveFile(filename, value) {
+    LocalStorage.files[filename] = value;
+  }
+  /**
+   * Loads the file
+   * @param filename
+   * @returns the file data
+   */
+  async loadFile(filename) {
+    return LocalStorage.files[filename];
+  }
+  /**
+   * Encrypts the data
+   * @param params
+   * @param params.data the data
+   * @param params.context the context
+   * @param params.keyId the key id, optional
+   * @returns encrypted data
+   */
+  async encrypt(params) {
+    return JSON.stringify(params);
+  }
+  /**
+   * Decrypts the data
+   * @param params
+   * @param params.data the data
+   * @param params.context the context
+   * @param params.keyId the key id, optional
+   * @returns
+   */
+  async decrypt(params) {
+    const { data, context, keyId } = JSON.parse(params.data);
+    if (context !== params.context) {
+      console.error("decrypt: context mismatch");
+      return void 0;
+    }
+    if (keyId !== params.keyId) {
+      console.error("decrypt: keyId mismatch");
+      return void 0;
+    }
+    return data;
+  }
+  /**
+   * Generates an id for local cloud
+   * @returns generated unique id
+   */
+  static generateId(tx = void 0) {
+    return Date.now() + "." + makeString(32);
+  }
+  /**
+   * Send transactions to the local cloud
+   * @param transactions the transactions to add
+   * @returns the transaction ids
+   */
+  async sendTransactions(transactions) {
+    return await _LocalCloud.addTransactions(transactions);
+  }
+  /**
+   * Adds transactions to the local cloud
+   * @param transactions the transactions to add
+   * @returns the transaction ids
+   */
+  static async addTransactions(transactions) {
+    const timeReceived = Date.now();
+    const txs = [];
+    transactions.forEach((tx) => {
+      if (typeof tx === "string") {
+        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;
+        txs.push(tx);
+      }
+    });
+    return txs;
+  }
+  /**
+   * Deletes a transaction from the local cloud
+   * @param txId the transaction id to delete
+   */
+  async deleteTransaction(txId) {
+    if (LocalStorage.transactions[txId] === void 0)
+      throw new Error(`deleteTransaction: Transaction ${txId} not found`);
+    delete LocalStorage.transactions[txId];
+  }
+  async getTransactions() {
+    const txs = Object.keys(LocalStorage.transactions).map((txId) => {
+      return LocalStorage.transactions[txId];
+    });
+    return txs;
+  }
+  /**
+   * Publish the transaction metadata in human-readable format
+   * @param params
+   * @param params.txId the transaction id
+   * @param params.metadata the metadata
+   */
+  async publishTransactionMetadata(params) {
+    console.log("publishTransactionMetadata:", params);
+  }
+  /**
+   * Runs the worker in the local cloud
+   * @param params the parameters to run the worker
+   * @param params.command the command to run
+   * @param params.data the data to use
+   * @param params.chain the blockchain to execute the job on
+   * @param params.localWorker the worker to execute the tasks
+   * @returns the job id
+   */
+  static async run(params) {
+    const { command, data, chain, localWorker } = params;
+    const { developer, repo, transactions, task, userId, args, metadata } = data;
+    const timeCreated = Date.now();
+    const jobId = _LocalCloud.generateId();
+    const job = {
+      id: "local",
+      jobId,
+      developer,
+      repo,
+      task,
+      userId,
+      args,
+      metadata,
+      txNumber: command === "recursiveProof" ? transactions.length : 1,
+      timeCreated,
+      timeStarted: timeCreated,
+      chain
+    };
+    const cloud = new _LocalCloud({
+      job,
+      chain,
+      localWorker
+    });
+    const worker = await localWorker(cloud);
+    if (worker === void 0)
+      throw new Error("worker is undefined");
+    const result = command === "recursiveProof" ? await _LocalCloud.sequencer({
+      worker,
+      data
+    }) : command === "execute" ? await worker.execute(transactions) : void 0;
+    const timeFinished = Date.now();
+    if (result !== void 0) {
+      LocalStorage.jobEvents[jobId] = {
+        jobId,
+        jobStatus: "finished",
+        eventTime: timeFinished,
+        result
+      };
+      job.timeFinished = timeFinished;
+      job.jobStatus = "finished";
+      job.result = result;
+    } else {
+      LocalStorage.jobEvents[jobId] = {
+        jobId,
+        jobStatus: "failed",
+        eventTime: timeFinished
+      };
+      job.timeFailed = timeFinished;
+      job.jobStatus = "failed";
+    }
+    job.billedDuration = timeFinished - timeCreated;
+    LocalStorage.jobs[jobId] = job;
+    return jobId;
+  }
+  /**
+   * Runs the recursive proof in the local cloud
+   * @param data the data to use
+   * @param data.transactions the transactions to process
+   * @param data.task the task to execute
+   * @param data.userId the user id
+   * @param data.args the arguments for the job
+   * @param data.metadata the metadata for the job
+   * @returns the job id
+   */
+  async recursiveProof(data) {
+    return await _LocalCloud.run({
+      command: "recursiveProof",
+      data: {
+        developer: this.developer,
+        repo: this.repo,
+        transactions: data.transactions,
+        task: data.task ?? "recursiveProof",
+        userId: data.userId,
+        args: data.args,
+        metadata: data.metadata
+      },
+      chain: this.chain,
+      localWorker: this.localWorker
+    });
+  }
+  /**
+   * Executes the task in the local cloud
+   * @param data the data to use
+   * @param data.transactions the transactions to process
+   * @param data.task the task to execute
+   * @param data.userId the user id
+   * @param data.args the arguments for the job
+   * @param data.metadata the metadata for the job
+   * @returns the job id
+   */
+  async execute(data) {
+    return await _LocalCloud.run({
+      command: "execute",
+      data: {
+        developer: this.developer,
+        repo: this.repo,
+        transactions: data.transactions,
+        task: data.task,
+        userId: data.userId,
+        args: data.args,
+        metadata: data.metadata
+      },
+      chain: this.chain,
+      localWorker: this.localWorker
+    });
+  }
+  /**
+   * Gets the job result
+   * @param jobId the job id
+   * @returns the job data
+   */
+  async jobResult(jobId) {
+    return LocalStorage.jobs[jobId];
+  }
+  /**
+   * Adds a task to the local cloud
+   * @param data the data to use
+   * @param data.task the task to execute
+   * @param data.startTime the start time for the task
+   * @param data.userId the user id
+   * @param data.args the arguments for the job
+   * @param data.metadata the metadata for the job
+   * @returns the task id
+   */
+  async addTask(data) {
+    const taskId = _LocalCloud.generateId();
+    LocalStorage.tasks[taskId] = {
+      ...data,
+      id: "local",
+      taskId,
+      timeCreated: Date.now(),
+      developer: this.developer,
+      repo: this.repo,
+      chain: this.chain
+    };
+    return taskId;
+  }
+  /**
+   * Deletes a task from the local cloud
+   * @param taskId the task id to delete
+   */
+  async deleteTask(taskId) {
+    if (LocalStorage.tasks[taskId] === void 0)
+      throw new Error(`deleteTask: Task ${taskId} not found`);
+    delete LocalStorage.tasks[taskId];
+  }
+  /**
+   * Processes the tasks in the local cloud
+   */
+  async processTasks() {
+    await _LocalCloud.processLocalTasks({
+      developer: this.developer,
+      repo: this.repo,
+      localWorker: this.localWorker,
+      chain: this.chain
+    });
+  }
+  /**
+   * Processes the local tasks
+   * @param params the parameters to process the local tasks
+   * @param params.developer the developer of the repo
+   * @param params.repo the repo
+   * @param params.localWorker the worker to execute the tasks
+   * @param params.chain the blockchain to execute the job on
+   */
+  static async processLocalTasks(params) {
+    const { developer, repo, localWorker, chain } = params;
+    for (const taskId in LocalStorage.tasks) {
+      const data = LocalStorage.tasks[taskId];
+      const jobId = _LocalCloud.generateId();
+      const timeCreated = Date.now();
+      if (data.startTime !== void 0 && data.startTime < timeCreated)
+        continue;
+      const job = {
+        id: "local",
+        jobId,
+        taskId,
+        developer,
+        repo,
+        task: data.task,
+        userId: data.userId,
+        args: data.args,
+        metadata: data.metadata,
+        txNumber: 1,
+        timeCreated
+      };
+      const cloud = new _LocalCloud({
+        job,
+        chain,
+        localWorker
+      });
+      const worker = await localWorker(cloud);
+      const result = await worker.task();
+      const timeFinished = Date.now();
+      if (result !== void 0) {
+        LocalStorage.jobEvents[jobId] = {
+          jobId,
+          jobStatus: "finished",
+          eventTime: timeFinished,
+          result
+        };
+        job.timeFinished = timeFinished;
+      } else {
+        LocalStorage.jobEvents[jobId] = {
+          jobId,
+          jobStatus: "failed",
+          eventTime: timeFinished
+        };
+        job.timeFailed = timeFinished;
+      }
+      job.billedDuration = timeFinished - timeCreated;
+      LocalStorage.jobs[jobId] = job;
+    }
+    let count = 0;
+    for (const task in LocalStorage.tasks)
+      count++;
+    return count;
+  }
+  /**
+   * Runs the sequencer in the local cloud
+   * @param params the parameters to run the sequencer
+   * @param params.worker the worker to execute the tasks
+   * @param params.data the data to use
+   * @returns the proof
+   */
+  static async sequencer(params) {
+    const { worker, data } = params;
+    const { transactions } = data;
+    if (transactions.length === 0)
+      throw new Error("No transactions to process");
+    const proofs = [];
+    for (const transaction of transactions) {
+      const result = await worker.create(transaction);
+      if (result === void 0)
+        throw new Error("Failed to create proof");
+      proofs.push(result);
+    }
+    let proof = proofs[0];
+    for (let i = 1; i < proofs.length; i++) {
+      const result = await worker.merge(proof, proofs[i]);
+      if (result === void 0)
+        throw new Error("Failed to merge proofs");
+      proof = result;
+    }
+    return proof;
+  }
+  /**
+   * forces the worker to restart
+   */
+  async forceWorkerRestart() {
+    throw new Error("forceWorkerRestart called in LocalCloud");
+  }
+};
+var LocalStorage = class _LocalStorage {
+  /**
+   * Saves the data.
+   * @param name The name to save the data under.
+   * @throws Error Method not implemented to keep web compatibility.
+   */
+  static async saveData(name) {
+    throw new Error("Method not implemented to keep web compatibility.");
+    const data = {
+      jobs: _LocalStorage.jobs,
+      data: _LocalStorage.data,
+      transactions: _LocalStorage.transactions,
+      tasks: _LocalStorage.tasks
+    };
+    const filename = name + ".cloud";
+  }
+  /**
+   * Loads the data.
+   * @param name The name to load the data from.
+   * @throws Error Method not implemented to keep web compatibility.
+   */
+  static async loadData(name) {
+    throw new Error("Method not implemented to keep web compatibility.");
+    const filename = name + ".cloud";
+  }
+};
+LocalStorage.jobs = {};
+LocalStorage.jobEvents = {};
+LocalStorage.data = {};
+LocalStorage.files = {};
+LocalStorage.transactions = {};
+LocalStorage.tasks = {};
+
+// dist/node/mina/api/api.js
+var { ZKCLOUDWORKER_AUTH, ZKCLOUDWORKER_API } = config_default;
+var zkCloudWorkerClient = class {
+  /**
+   * Constructor for the API class
+   * @param params the parameters for the API class
+   * @param params.jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
+   * @param params.zkcloudworker The local worker for the serverless api to test the code locally
+   * @param params.chain The blockchain network to use
+   * @param params.webhook The webhook for the serverless api to get the results
+   */
+  constructor(params) {
+    const { jwt, zkcloudworker, webhook } = params;
+    this.jwt = jwt;
+    const chain = params.chain ?? "devnet";
+    this.chain = chain;
+    this.endpoint = chain === "devnet" || chain === "zeko" ? ZKCLOUDWORKER_API + chain : void 0;
+    this.webhook = webhook;
+    if (jwt === "local") {
+      if (zkcloudworker === void 0)
+        throw new Error("worker is required for local mode");
+      this.localWorker = zkcloudworker;
+    }
+  }
+  /**
+   * Starts a new job for the proof calculation using serverless api call
+   * @param data the data for the proof call
+   * @param data.developer the developer
+   * @param data.repo the repo to use
+   * @param data.transactions the transactions
+   * @param data.task the task of the job
+   * @param data.userId the userId of the job
+   * @param data.args the arguments of the job, should be serialized JSON or string
+   * @param data.metadata the metadata of the job, should be serialized JSON or string
+   * @param data.webhook the webhook for the job
+   * @returns { success: boolean, error?: string, jobId?: string }
+   * where jonId is the jobId of the job
+   *
+   * The developers repo should provide a zkcloudworker function
+   * that can be called with the given parameters, see the examples
+   */
+  async recursiveProof(data) {
+    const result = await this.apiHub("recursiveProof", data);
+    if (result.data === "error" || typeof result.data === "string" && result.data.startsWith("error"))
+      return {
+        success: false,
+        error: result.error
+      };
+    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 && result.data?.jobId !== void 0)
+      return {
+        success: result.success,
+        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
+   * @param data the data for the proof call
+   * @param data.developer the developer
+   * @param data.repo the repo to use
+   * @param data.transactions the transactions
+   * @param data.task the task of the job
+   * @param data.userId the userId of the job
+   * @param data.args the arguments of the job
+   * @param data.metadata the metadata of the job
+   * @param data.mode the mode of the job execution: "sync" will not create a job, it will execute the function synchronously within 30 seconds and with the memory limit of 256 MB
+   * @returns { success: boolean, error?: string, jobId?: string, result?: any }
+   * where jonId is the jobId of the job (for async calls), result is the result of the job (for sync calls)
+   */
+  async execute(data) {
+    const result = await this.apiHub("execute", data);
+    if (result.data === "error" || typeof result.data === "string" && result.data.startsWith("error"))
+      return {
+        success: false,
+        error: result.error
+      };
+    else if (result.success === false || result.data?.success === false)
+      return {
+        success: false,
+        error: result.error ?? result.data?.error ?? "execute call failed"
+      };
+    else if (result.success === true && data.mode === "sync" && result.data !== void 0)
+      return {
+        success: result.success,
+        jobId: void 0,
+        result: result.data,
+        error: result.error
+      };
+    else if (result.success === true && data.mode !== "sync" && result.data?.success === true && result.data?.jobId !== void 0)
+      return {
+        success: result.success,
+        jobId: result.data.jobId,
+        result: void 0,
+        error: result.error
+      };
+    else
+      return {
+        success: false,
+        error: "execute call error"
+      };
+  }
+  /**
+   * Sends transactions to the blockchain using serverless api call
+   * @param data the data for the proof call
+   * @param data.developer the developer
+   * @param data.repo the repo to use
+   * @param data.transactions the transactions
+   * @returns { success: boolean, error?: string, txId?: string[] }
+   * where txId is the transaction id of the transaction, in the sequence of the input transactions
+   */
+  async sendTransactions(data) {
+    const result = await this.apiHub("sendTransactions", data);
+    if (result.data === "error")
+      return {
+        success: false,
+        error: result.error
+      };
+    else
+      return {
+        success: result.success,
+        txId: result.data,
+        error: result.error
+      };
+  }
+  /**
+   * Gets the result of the job using serverless api call
+   * @param data the data for the jobResult call
+   * @param data.jobId the jobId of the job
+   * @param data.includeLogs include logs in the result, default is false
+   * @returns { success: boolean, error?: string, result?: any }
+   * where result is the result of the job
+   * if the job is not finished yet, the result will be undefined
+   * if the job failed, the result will be undefined and error will be set
+   * if the job is finished, the result will be set and error will be undefined
+   * if the job is not found, the result will be undefined and error will be set
+   */
+  async jobResult(data) {
+    const result = await this.apiHub("jobResult", data);
+    if (this.isError(result.data))
+      return {
+        success: false,
+        error: result.error,
+        result: result.data
+      };
+    else
+      return {
+        success: result.success,
+        error: result.error,
+        result: result.success ? result.data : result.data
+      };
+  }
+  /**
+   * Deploys the code to the cloud using serverless api call
+   * @param data the data for the deploy call
+   * @param data.repo the repo to use
+   * @param data.developer the developer
+   * @param data.packageManager the package manager to use
+   * @returns { success: boolean, error?: string, jobId?: string}
+   * where jobId is the jobId of the job
+   */
+  async deploy(data) {
+    const { repo, developer, packageManager } = data;
+    const result = await this.apiHub("deploy", {
+      developer,
+      repo,
+      args: packageManager
+    });
+    if (result.data === "error" || typeof result.data === "string" && result.data.startsWith("error"))
+      return {
+        success: false,
+        error: result.error
+      };
+    else
+      return {
+        success: result.success && result.data?.success,
+        jobId: result.data?.jobId,
+        error: result.error
+      };
+  }
+  /**
+   * Gets the billing report for the jobs sent using JWT
+   * @returns { success: boolean, error?: string, result?: any }
+   * where result is the billing report
+   */
+  async queryBilling() {
+    const result = await this.apiHub("queryBilling", {});
+    if (this.isError(result.data))
+      return {
+        success: false,
+        error: result.error,
+        result: result.data
+      };
+    else
+      return {
+        success: result.success,
+        error: result.error,
+        result: result.data
+      };
+  }
+  /**
+   * Gets the remaining balance
+   * @returns { success: boolean, error?: string, result?: any }
+   * where result is the balance
+   */
+  async getBalance() {
+    const result = await this.apiHub("getBalance", {});
+    if (this.isError(result.data))
+      return {
+        success: false,
+        error: result.error,
+        result: result.data
+      };
+    else
+      return {
+        success: result.success,
+        error: result.error,
+        result: result.data
+      };
+  }
+  /**
+   * Waits for the job to finish
+   * @param data the data for the waitForJobResult call
+   * @param data.jobId the jobId of the job
+   * @param data.maxAttempts the maximum number of attempts, default is 360 (2 hours)
+   * @param data.interval the interval between attempts, default is 20000 (20 seconds)
+   * @param data.maxErrors the maximum number of network errors, default is 10
+   * @param data.printLogs print logs, default is true
+   * @returns { success: boolean, error?: string, result?: any }
+   * where result is the result of the job
+   */
+  async waitForJobResult(data) {
+    if (this.jwt === "local")
+      return this.jobResult({ jobId: data.jobId });
+    const maxAttempts = data?.maxAttempts ?? 360;
+    const interval = data?.interval ?? 1e4;
+    const maxErrors = data?.maxErrors ?? 10;
+    const errorDelay = 3e4;
+    const printedLogs = [];
+    const printLogs = data.printLogs ?? true;
+    function print(logs) {
+      logs.forEach((log) => {
+        if (printedLogs.includes(log) === false) {
+          printedLogs.push(log);
+          if (printLogs) {
+            const text = log.replace(/error/gi, (matched) => import_chalk.default.red(matched));
+            console.log(text);
+          }
+        }
+      });
+    }
+    let attempts = 0;
+    let errors = 0;
+    while (attempts < maxAttempts) {
+      const result = await this.apiHub("jobResult", {
+        jobId: data.jobId,
+        includeLogs: printLogs
+      });
+      const isAllLogsFetched = result?.data?.isFullLog === true || printLogs === false;
+      if (printLogs === true && result?.data?.logs !== void 0 && result?.data?.logs !== null && Array.isArray(result.data.logs) === true)
+        print(result.data.logs);
+      if (result.success === false) {
+        errors++;
+        if (errors > maxErrors) {
+          return {
+            success: false,
+            error: "Too many network errors",
+            result: void 0
+          };
+        }
+        await sleep(errorDelay * errors);
+      } else {
+        if (this.isError(result.data) && isAllLogsFetched)
+          return {
+            success: false,
+            error: result.error,
+            result: result.data
+          };
+        else if (result.data?.result !== void 0 && isAllLogsFetched) {
+          return {
+            success: result.success,
+            error: result.error,
+            result: result.data
+          };
+        } else if (result.data?.jobStatus === "failed" && isAllLogsFetched) {
+          return {
+            success: false,
+            error: "Job failed",
+            result: result.data
+          };
+        }
+        await sleep(interval);
+      }
+      attempts++;
+    }
+    return {
+      success: false,
+      error: "Timeout",
+      result: void 0
+    };
+  }
+  /**
+   * Calls the serverless API
+   * @param command the command of the API
+   * @param data the data of the API
+   * */
+  async apiHub(command, data) {
+    if (this.jwt === "local") {
+      if (this.localWorker === void 0)
+        throw new Error("localWorker is undefined");
+      switch (command) {
+        case "recursiveProof": {
+          const jobId = await LocalCloud.run({
+            command: "recursiveProof",
+            data,
+            chain: this.chain,
+            localWorker: this.localWorker
+          });
+          return {
+            success: true,
+            data: { success: true, jobId }
+          };
+        }
+        case "execute": {
+          const jobId = await LocalCloud.run({
+            command: "execute",
+            data,
+            chain: this.chain,
+            localWorker: this.localWorker
+          });
+          if (data.mode === "sync")
+            return {
+              success: true,
+              data: LocalStorage.jobEvents[jobId].result
+            };
+          else
+            return {
+              success: true,
+              data: { success: true, jobId }
+            };
+        }
+        case "jobResult": {
+          const job = LocalStorage.jobs[data.jobId];
+          if (job === void 0) {
+            return {
+              success: false,
+              error: "local job not found"
+            };
+          } else {
+            return {
+              success: true,
+              data: job
+            };
+          }
+        }
+        case "sendTransactions": {
+          return {
+            success: true,
+            data: await LocalCloud.addTransactions(data.transactions)
+          };
+        }
+        case "deploy":
+          return {
+            success: true,
+            data: "local_deploy"
+          };
+        case "queryBilling":
+          return {
+            success: true,
+            data: "local_queryBilling"
+          };
+        default:
+          return {
+            success: false,
+            error: "local_error"
+          };
+      }
+    } else {
+      if (this.endpoint === void 0)
+        throw new Error("zkCloudWorker supports only devnet and zeko chains in the cloud.");
+      const apiData = {
+        auth: ZKCLOUDWORKER_AUTH,
+        command,
+        jwtToken: this.jwt,
+        data,
+        chain: this.chain,
+        webhook: this.webhook
+        // TODO: implement webhook code on AWS
+      };
+      try {
+        const response = await import_axios.default.post(this.endpoint, apiData);
+        return { success: true, data: response.data };
+      } catch (error) {
+        console.error("apiHub error:", error.message ?? error);
+        return { success: false, error };
+      }
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  isError(data) {
+    if (data === "error")
+      return true;
+    if (data?.jobStatus === "failed")
+      return true;
+    if (typeof data === "string" && data.toLowerCase().startsWith("error"))
+      return true;
+    if (data !== void 0 && data.error !== void 0)
+      return true;
+    return false;
+  }
+};
+
+// dist/node/mina/utils/base64.js
+var import_o1js = require("o1js");
+var TABLE2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function fieldToBase56(field) {
+  const digits = toBase(field.toBigInt(), 56n);
+  const str = digits.map((x) => TABLE2[Number(x)]).join("");
+  return str;
+}
+function fieldFromBase56(str) {
+  const base56Digits = str.split("").map((x2) => BigInt(TABLE2.indexOf(x2)));
+  const x = fromBase(base56Digits, 56n);
+  return (0, import_o1js.Field)(x);
+}
+function fieldToBase64(field) {
+  const digits = toBase(field.toBigInt(), 64n);
+  const str = digits.map((x) => TABLE2[Number(x)]).join("");
+  return str;
+}
+function fieldFromBase64(str) {
+  const base64Digits = str.split("").map((x2) => BigInt(TABLE2.indexOf(x2)));
+  const x = fromBase(base64Digits, 64n);
+  return (0, import_o1js.Field)(x);
+}
+
+// dist/node/mina/utils/fetch.js
+var import_o1js2 = require("o1js");
+async function fetchMinaAccount(params) {
+  const { publicKey, tokenId, force = false } = params;
+  const timeout = 1e3 * 60 * 3;
+  let attempt = 0;
+  const startTime = Date.now();
+  let result = { account: void 0 };
+  while (Date.now() - startTime < timeout) {
+    try {
+      const result2 = await (0, import_o1js2.fetchAccount)({
+        publicKey,
+        tokenId
+      });
+      return result2;
+    } catch (error) {
+      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(1e3 * 6 * attempt);
+  }
+  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;
+}
+async function fetchMinaActions(publicKey, fromActionState, endActionState) {
+  const timeout = 1e3 * 60 * 600;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      let actions = await import_o1js2.Mina.fetchActions(publicKey, {
+        fromActionState,
+        endActionState
+      });
+      if (Array.isArray(actions))
+        return actions;
+      else
+        console.log("Cannot fetch actions - wrong format");
+    } catch (error) {
+      console.log("Error in fetchMinaActions", error.toString().substring(0, 300));
+    }
+    await sleep(1e3 * 60 * 2);
+  }
+  console.log("Timeout in fetchMinaActions");
+  return void 0;
+}
+async function checkMinaZkappTransaction(hash) {
+  try {
+    const result = await (0, import_o1js2.checkZkappTransaction)(hash);
+    return result;
+  } catch (error) {
+    console.error("Error in checkZkappTransaction:", error);
+    return { success: false };
+  }
+}
+
+// dist/node/mina/utils/fields.js
+var import_o1js3 = require("o1js");
+function serializeFields(fields) {
+  const hash = import_o1js3.Poseidon.hash(fields);
+  const value = [(0, import_o1js3.Field)(fields.length), hash, ...fields];
+  return value.map((f) => fieldToBase64(f)).join(".");
+}
+function deserializeFields(s) {
+  try {
+    const value = s.split(".").map((n) => fieldFromBase64(n));
+    const length = value[0];
+    if ((0, import_o1js3.Field)(value.length - 2).equals(length).toBoolean() === false)
+      throw new Error("deserializeFields: invalid length");
+    const hash = import_o1js3.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) {
+    throw new Error(`deserializeFields: invalid string: ${s}: ${e}`);
+  }
+}
+
+// dist/node/mina/utils/fee.js
+var import_o1js4 = require("o1js");
+async function fee() {
+  return import_o1js4.UInt64.fromJSON(config_default.MINAFEE);
+}
+
+// dist/node/mina/utils/mina.js
+var import_o1js5 = require("o1js");
+var currentNetwork = void 0;
+function getNetworkIdHash() {
+  if (currentNetwork === void 0) {
+    throw new Error("Network is not initialized");
+  }
+  return currentNetwork.networkIdHash;
+}
+function getCurrentNetwork() {
+  if (currentNetwork === void 0) {
+    throw new Error("Network is not initialized");
+  }
+  return currentNetwork;
+}
+function getDeployer() {
+  if (currentNetwork === void 0) {
+    throw new Error("Network is not initialized");
+  }
+  if (currentNetwork.keys.length < 1)
+    return void 0;
+  return currentNetwork.keys[0];
+}
+async function initBlockchain(instance, deployersNumber = 0) {
+  if (currentNetwork !== void 0) {
+    if (currentNetwork?.network.chainId === instance) {
+      return currentNetwork;
+    } else {
+      throw new Error(`Network is already initialized to different chain ${currentNetwork.network.chainId}, cannot initialize to ${instance}`);
+    }
+  }
+  const networkIdHash = import_o1js5.CircuitString.fromString(instance).hash();
+  if (instance === "local") {
+    const local = await import_o1js5.Mina.LocalBlockchain({
+      proofsEnabled: true
+    });
+    import_o1js5.Mina.setActiveInstance(local);
+    if (deployersNumber > local.testAccounts.length)
+      throw new Error("Not enough test accounts");
+    currentNetwork = {
+      keys: local.testAccounts,
+      network: Local,
+      networkIdHash
+    };
+    return currentNetwork;
+  }
+  const network = networks.find((n) => n.chainId === instance);
+  if (network === void 0) {
+    throw new Error("Unknown network");
+  }
+  const networkInstance = import_o1js5.Mina.Network({
+    mina: network.mina,
+    archive: network.archive,
+    lightnetAccountManager: network.accountManager,
+    networkId: instance === "mainnet" ? "mainnet" : "testnet"
+  });
+  import_o1js5.Mina.setActiveInstance(networkInstance);
+  const keys = [];
+  if (deployersNumber > 0) {
+    if (instance === "lightnet") {
+      for (let i = 0; i < deployersNumber; i++) {
+        const keyPair = await import_o1js5.Lightnet.acquireKeyPair();
+        const key = import_o1js5.Mina.TestPublicKey(keyPair.privateKey);
+        keys.push(key);
+      }
+    } else {
+      const deployers = process.env.DEPLOYERS;
+      if (deployers === void 0 || Array.isArray(deployers) === false || deployers.length < deployersNumber)
+        throw new Error("Deployers are not set");
+      for (let i = 0; i < deployersNumber; i++) {
+        const privateKey = import_o1js5.PrivateKey.fromBase58(deployers[i]);
+        const key = import_o1js5.Mina.TestPublicKey(privateKey);
+        keys.push(key);
+      }
+    }
+  }
+  currentNetwork = {
+    keys,
+    network,
+    networkIdHash
+  };
+  return currentNetwork;
+}
+async function accountBalance(address) {
+  await (0, import_o1js5.fetchAccount)({ publicKey: address });
+  if (import_o1js5.Mina.hasAccount(address))
+    return import_o1js5.Mina.getBalance(address);
+  else
+    return import_o1js5.UInt64.from(0);
+}
+async function accountBalanceMina(address) {
+  return Number((await accountBalance(address)).toBigInt()) / 1e9;
+}
+
+// dist/node/mina/utils/indexed-map.js
+var import_o1js6 = require("o1js");
+
+// dist/node/mina/storage/pinata.js
+async function pinJSON(params) {
+  const { data, name = "data.json", keyvalues = [{ key: "library", value: "zkcloudworker" }] } = params;
+  const auth = params.auth ?? process.env.PINATA_JWT ?? process.env.NEXT_PUBLIC_PINATA_JWT ?? process.env.REACT_APP_PINATA_JWT;
+  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 void 0;
+  }
+}
+
+// dist/node/mina/utils/indexed-map.js
+var { IndexedMerkleMap } = import_o1js6.Experimental;
+async function loadIndexedMerkleMap(params) {
+  const { url, type, timeout = 6e4, attempts = 5 } = params;
+  let attempt = 0;
+  const start = Date.now();
+  let response = await fetch(url);
+  while (!response.ok && attempt < attempts && Date.now() - start < timeout) {
+    attempt++;
+    await sleep(5e3 * attempt);
+    response = await fetch(url);
+  }
+  if (!response.ok) {
+    throw new Error("Failed to fetch IndexedMerkleMap");
+  }
+  const json = await response.json();
+  const serializedIndexedMap = json.map;
+  if (!serializedIndexedMap)
+    throw new Error("wrong IndexedMerkleMap json format");
+  const map = deserializeIndexedMerkleMapInternal({
+    serializedIndexedMap,
+    type
+  });
+  if (!map) {
+    throw new Error("Failed to deserialize whitelist");
+  }
+  return map;
+}
+async function saveIndexedMerkleMap(params) {
+  const { map, name = "indexed-map", keyvalues, auth } = params;
+  const serialized = serializeIndexedMap(map);
+  const ipfsHash = await pinJSON({
+    data: { map: serialized },
+    name,
+    keyvalues,
+    auth
+  });
+  return ipfsHash;
+}
+function serializeIndexedMap(map) {
+  return {
+    height: map.height,
+    root: map.root.toJSON(),
+    length: map.length.toJSON(),
+    nodes: JSON.stringify(map.data.get().nodes, (_, v) => typeof v === "bigint" ? "n" + bigintToBase64(v) : v),
+    sortedLeaves: JSON.stringify(map.data.get().sortedLeaves.map((v) => [
+      bigintToBase64(v.key),
+      bigintToBase64(v.nextKey),
+      bigintToBase64(v.value),
+      bigintToBase64(BigInt(v.index))
+    ]))
+  };
+}
+function deserializeIndexedMerkleMap(params) {
+  try {
+    const { serializedIndexedMap, type } = params;
+    return deserializeIndexedMerkleMapInternal({
+      serializedIndexedMap,
+      type: type ?? IndexedMerkleMap(serializedIndexedMap.height)
+    });
+  } catch (error) {
+    console.error("Error deserializing map:", error?.message ?? error);
+    return void 0;
+  }
+}
+function parseIndexedMapSerialized(serializedMap) {
+  const json = JSON.parse(serializedMap);
+  if (json.height === void 0 || json.root === void 0 || json.length === void 0 || json.nodes === void 0 || json.sortedLeaves === void 0)
+    throw new Error("wrong IndexedMerkleMap json format");
+  if (typeof json.height !== "number")
+    throw new Error("wrong IndexedMerkleMap height format");
+  if (typeof json.root !== "string")
+    throw new Error("wrong IndexedMerkleMap root format");
+  if (typeof json.length !== "string")
+    throw new Error("wrong IndexedMerkleMap length format");
+  if (typeof json.nodes !== "string")
+    throw new Error("wrong IndexedMerkleMap nodes format");
+  if (typeof json.sortedLeaves !== "string")
+    throw new Error("wrong IndexedMerkleMap sortedLeaves format");
+  return json;
+}
+function deserializeIndexedMerkleMapInternal(params) {
+  const { serializedIndexedMap, type } = params;
+  const map = new type();
+  if (serializedIndexedMap.height !== map.height) {
+    throw new Error("wrong IndexedMap height");
+  }
+  const nodes = JSON.parse(serializedIndexedMap.nodes, (_, v) => {
+    if (typeof v === "string" && v[0] === "n") {
+      return bigintFromBase64(v.slice(1));
+    }
+    return v;
+  });
+  const sortedLeaves = JSON.parse(serializedIndexedMap.sortedLeaves).map((row) => {
+    return {
+      key: bigintFromBase64(row[0]),
+      nextKey: bigintFromBase64(row[1]),
+      value: bigintFromBase64(row[2]),
+      index: Number(bigintFromBase64(row[3]))
+    };
+  });
+  map.root = import_o1js6.Field.fromJSON(serializedIndexedMap.root);
+  map.length = import_o1js6.Field.fromJSON(serializedIndexedMap.length);
+  map.data.updateAsProver(() => {
+    return {
+      nodes: nodes.map((row) => [...row]),
+      sortedLeaves: [...sortedLeaves]
+    };
+  });
+  return map;
+}
+
+// dist/node/mina/token/api.js
+var TokenAPI = class {
+  constructor(params) {
+    const { jwt, zkcloudworker, chain } = params;
+    if (jwt === void 0)
+      throw new Error("jwt is undefined");
+    this.client = new zkCloudWorkerClient({
+      jwt,
+      chain,
+      zkcloudworker
+    });
+  }
+  async sendDeployTransaction(params) {
+    const { symbol } = params;
+    const transaction = JSON.stringify(params, null, 2);
+    const answer = await this.client.execute({
+      developer: "DFST",
+      repo: "token-launchpad",
+      transactions: [transaction],
+      task: "deploy",
+      args: JSON.stringify({ tokenAddress: params.tokenAddress }),
+      metadata: `deploy token ${symbol}`
+    });
+    const jobId = answer.jobId;
+    if (jobId === void 0)
+      console.error("Deploy Job ID is undefined", { answer, symbol });
+    return jobId;
+  }
+  async sendTransaction(params) {
+    const { txType, symbol } = params;
+    const transaction = JSON.stringify(params, null, 2);
+    const answer = await this.client.execute({
+      developer: "DFST",
+      repo: "token-launchpad",
+      transactions: [transaction],
+      task: txType,
+      args: JSON.stringify({ tokenAddress: params.tokenAddress }),
+      metadata: `${txType} token${symbol ? ` ${symbol}` : ""}`
+    });
+    const jobId = answer.jobId;
+    if (jobId === void 0)
+      console.error("Job ID is undefined", { answer, txType, symbol });
+    return jobId;
+  }
+  // Warning: this function will block the thread until the job is done and will print logs to the console
+  // Do not use it in "use server" functions, use getResult instead
+  async waitForJobResult(params) {
+    const deployResult = await this.client.waitForJobResult(params);
+    console.log("waitForJobResult result:", deployResult?.result?.result?.slice(0, 50));
+    return deployResult?.result?.result ?? "error";
+  }
+  async getResult(jobId) {
+    try {
+      const callResult = await this.client.jobResult({ jobId });
+      const jobStatus = callResult?.success === true ? callResult?.result?.jobStatus : void 0;
+      if (!callResult.success) {
+        return {
+          success: false,
+          error: callResult?.error,
+          jobStatus
+        };
+      }
+      const jobResult = callResult.result?.result;
+      if (callResult.error)
+        return {
+          success: false,
+          error: callResult.error,
+          jobStatus
+        };
+      if (!jobResult)
+        return { success: true, jobStatus };
+      if (jobResult.toLowerCase().startsWith("error"))
+        return {
+          success: false,
+          error: jobResult,
+          jobStatus
+        };
+      try {
+        const { success, tx, hash, error } = JSON.parse(jobResult);
+        if (success === void 0)
+          return {
+            success: false,
+            tx,
+            hash,
+            error,
+            jobStatus
+          };
+        return { success, tx, hash, error, jobStatus };
+      } catch (e) {
+        return {
+          success: false,
+          error: `Error parsing job result: ${jobResult}`
+        };
+      }
+    } catch (e) {
+      return { success: false, error: `Error getting job result: ${e}` };
+    }
+  }
+};
+
+// dist/node/mina/token/bid.js
+var import_tslib5 = require("tslib");
+var import_o1js13 = require("o1js");
+
+// dist/node/mina/token/whitelist.js
+var import_o1js8 = require("o1js");
+
+// dist/node/mina/storage/storage.js
+var import_o1js7 = require("o1js");
+var Storage = class _Storage extends (0, import_o1js7.Struct)({
+  url: import_o1js7.Provable.Array(import_o1js7.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 = import_o1js7.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 import_o1js7.Encoding.stringFromFields([this.url[0], this.url[1]]);
+  }
+};
+
+// dist/node/mina/storage/ipfs.js
+function createIpfsURL(params) {
+  let { hash, gateway, apiToken } = params;
+  gateway ??= process.env.PINATA_IPFS_GATEWAY ?? process.env.NEXT_PUBLIC_PINATA_IPFS_GATEWAY ?? process.env.REACT_APP_PINATA_IPFS_GATEWAY;
+  apiToken ??= process.env.PINATA_GATEWAY_TOKEN ?? process.env.NEXT_PUBLIC_PINATA_GATEWAY_TOKEN ?? process.env.REACT_APP_PINATA_GATEWAY_TOKEN;
+  if (!gateway) {
+    gateway = "https://gateway.pinata.cloud/ipfs/";
+  }
+  return gateway + hash + (apiToken ? "?pinataGatewayToken=" + apiToken : "");
+}
+
+// dist/node/mina/token/whitelist.js
+var { IndexedMerkleMap: IndexedMerkleMap2 } = import_o1js8.Experimental;
+var WHITELIST_HEIGHT = 20;
+var WhitelistMap = class extends IndexedMerkleMap2(WHITELIST_HEIGHT) {
+};
+var WhitelistMapOption = class extends (0, import_o1js8.Option)(WhitelistMap) {
+};
+var UInt64Option = class extends (0, import_o1js8.Option)(import_o1js8.UInt64) {
+};
+var WhitelistedAddress = class extends (0, import_o1js8.Struct)({
+  address: import_o1js8.PublicKey,
+  amount: import_o1js8.UInt64
+  // Maximum permitted amount of the transaction
+}) {
+};
+var Whitelist = class _Whitelist extends (0, import_o1js8.Struct)({
+  /** The root hash of the Merkle tree representing the whitelist. */
+  root: import_o1js8.Field,
+  /** Off-chain storage information, typically an IPFS hash pointing to the whitelist data. */
+  storage: Storage
+}) {
+  isNone() {
+    return this.root.equals((0, import_o1js8.Field)(0)).or(Storage.equals(this.storage, Storage.empty()));
+  }
+  isSome() {
+    return this.isNone().not();
+  }
+  async load() {
+    const isNone = this.isNone();
+    const map = await import_o1js8.Provable.witnessAsync(WhitelistMapOption, async () => {
+      if (isNone.toBoolean())
+        return WhitelistMapOption.none();
+      else
+        return WhitelistMapOption.fromValue(await loadIndexedMerkleMap({
+          url: createIpfsURL({ hash: this.storage.toString() }),
+          type: WhitelistMap
+        }));
+    });
+    isNone.assertEquals(map.isSome.not());
+    const root = import_o1js8.Provable.if(map.isSome, map.orElse(new WhitelistMap()).root, (0, import_o1js8.Field)(0));
+    root.equals(this.root);
+    return map;
+  }
+  /**
+   * The function fetches a whitelisted amount associated with a given address using a map and returns it
+   * as a UInt64Option.
+   * @param {PublicKey} address - The `address` parameter is of type `PublicKey`, which represents a
+   * public key used in cryptography for various purposes such as encryption, digital signatures, and
+   * authentication. In the context of the `fetchWhitelistedAmount` function, the `address` parameter is
+   * used to retrieve a whitelisted amount
+   * @returns The `fetchWhitelistedAmount` function returns a `Promise` that resolves to a `UInt64Option`
+   * object. This object contains a `value` property representing the amount retrieved from a map based
+   * on the provided address. The `isSome` property indicates whether the value is present or not.
+   * The value is not present if the whitelist is NOT empty and the address is NOT whitelisted.
+   * The value is present if the whitelist is NOT empty or the address IS whitelisted.
+   * The value is present and equals to UInt64.MAXINT() if the whitelist IS empty.
+   */
+  async getWhitelistedAmount(address) {
+    const map = await this.load();
+    const key = import_o1js8.Poseidon.hashPacked(import_o1js8.PublicKey, address);
+    const value = map.orElse(new WhitelistMap()).getOption(key);
+    const valueField = value.orElse(import_o1js8.UInt64.MAXINT().value);
+    valueField.assertLessThanOrEqual(import_o1js8.UInt64.MAXINT().value);
+    const amount = import_o1js8.UInt64.Unsafe.fromField(valueField);
+    return new UInt64Option({
+      value: amount,
+      isSome: value.isSome.or(this.isNone())
+    });
+  }
+  static empty() {
+    return new _Whitelist({
+      root: (0, import_o1js8.Field)(0),
+      storage: Storage.empty()
+    });
+  }
+  /**
+   * Creates a new whitelist and pins it to IPFS.
+   * @param params - The parameters for creating the whitelist.
+   * @returns A new `Whitelist` instance.
+   */
+  static async create(params) {
+    const { name = "whitelist.json", keyvalues = [{ key: "library", value: "zkcloudworker" }], timeout = 60 * 1e3, attempts = 5, auth } = params;
+    const list = typeof params.list[0].address === "string" ? params.list.map((item) => new WhitelistedAddress({
+      address: import_o1js8.PublicKey.fromBase58(item.address),
+      amount: item.amount ? import_o1js8.UInt64.from(item.amount) : import_o1js8.UInt64.MAXINT()
+    })) : params.list;
+    const map = new WhitelistMap();
+    for (const item of list) {
+      map.insert(import_o1js8.Poseidon.hashPacked(import_o1js8.PublicKey, item.address), item.amount.toBigInt());
+    }
+    const serializedMap = serializeIndexedMap(map);
+    const json = {
+      map: serializedMap,
+      whitelist: list.map((item) => ({
+        address: item.address.toBase58(),
+        amount: Number(item.amount.toBigInt())
+      }))
+    };
+    let attempt = 0;
+    const start = Date.now();
+    let hash = await pinJSON({
+      data: json,
+      name,
+      keyvalues,
+      auth
+    });
+    while (!hash && attempt < attempts && Date.now() - start < timeout) {
+      attempt++;
+      await sleep(5e3 * attempt);
+      hash = await pinJSON({
+        data: json,
+        name,
+        keyvalues,
+        auth
+      });
+    }
+    if (!hash)
+      throw new Error("Failed to pin whitelist");
+    return new _Whitelist({
+      root: map.root,
+      storage: Storage.fromString(hash)
+    });
+  }
+};
+
+// dist/node/mina/token/FungibleTokenContract.js
+var import_tslib = require("tslib");
+var import_o1js9 = require("o1js");
+var FungibleTokenErrors = {
+  noAdminKey: "could not fetch admin contract key",
+  noPermissionToChangeAdmin: "Not allowed to change admin contract",
+  tokenPaused: "Token is currently paused",
+  noPermissionToMint: "Not allowed to mint tokens",
+  noPermissionToPause: "Not allowed to pause token",
+  noPermissionToResume: "Not allowed to resume token",
+  noTransferFromCirculation: "Can't transfer to/from the circulation account",
+  noPermissionChangeAllowed: "Can't change permissions for access or receive on token accounts",
+  flashMinting: "Flash-minting or unbalanced transaction detected. Please make sure that your transaction is balanced, and that your `AccountUpdate`s are ordered properly, so that tokens are not received before they are sent.",
+  unbalancedTransaction: "Transaction is unbalanced"
+};
+function FungibleTokenContract(adminContract) {
+  class FungibleToken2 extends import_o1js9.TokenContract {
+    constructor() {
+      super(...arguments);
+      this.decimals = (0, import_o1js9.State)();
+      this.admin = (0, import_o1js9.State)();
+      this.paused = (0, import_o1js9.State)();
+      this.events = {
+        SetAdmin: SetAdminEvent,
+        Pause: PauseEvent,
+        Mint: MintEvent,
+        Burn: BurnEvent,
+        BalanceChange: BalanceChangeEvent
+      };
+    }
+    async deploy(props) {
+      await super.deploy(props);
+      this.paused.set((0, import_o1js9.Bool)(true));
+      this.account.zkappUri.set(props.src);
+      this.account.tokenSymbol.set(props.symbol);
+      this.account.permissions.set({
+        ...import_o1js9.Permissions.default(),
+        setVerificationKey: import_o1js9.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+        setPermissions: import_o1js9.Permissions.impossible(),
+        access: import_o1js9.Permissions.proof()
+      });
+    }
+    /** Update the verification key.
+     * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update.
+     */
+    async updateVerificationKey(vk) {
+      this.account.verificationKey.set(vk);
+    }
+    /** Initializes the account for tracking total circulation.
+     * @argument {PublicKey} admin - public key where the admin contract is deployed
+     * @argument {UInt8} decimals - number of decimals for the token
+     * @argument {Bool} startPaused - if set to `Bool(true), the contract will start in a mode where token minting and transfers are paused. This should be used for non-atomic deployments
+     */
+    async initialize(admin, decimals, startPaused) {
+      this.account.provedState.requireEquals((0, import_o1js9.Bool)(false));
+      this.admin.set(admin);
+      this.decimals.set(decimals);
+      this.paused.set((0, import_o1js9.Bool)(false));
+      this.paused.set(startPaused);
+      const accountUpdate = import_o1js9.AccountUpdate.createSigned(this.address, this.deriveTokenId());
+      let permissions = import_o1js9.Permissions.default();
+      permissions.send = import_o1js9.Permissions.none();
+      permissions.setPermissions = import_o1js9.Permissions.impossible();
+      accountUpdate.account.permissions.set(permissions);
+    }
+    async getAdminContract() {
+      const admin = await import_o1js9.Provable.witnessAsync(import_o1js9.PublicKey, async () => {
+        let pk = await this.admin.fetch();
+        (0, import_o1js9.assert)(pk !== void 0, FungibleTokenErrors.noAdminKey);
+        return pk;
+      });
+      this.admin.requireEquals(admin);
+      return new adminContract(admin);
+    }
+    async setAdmin(admin) {
+      const adminContract2 = await this.getAdminContract();
+      const canChangeAdmin = await adminContract2.canChangeAdmin(admin);
+      canChangeAdmin.assertTrue(FungibleTokenErrors.noPermissionToChangeAdmin);
+      this.admin.set(admin);
+      this.emitEvent("SetAdmin", new SetAdminEvent({ adminKey: admin }));
+    }
+    async mint(recipient, amount) {
+      this.paused.getAndRequireEquals().assertFalse(FungibleTokenErrors.tokenPaused);
+      const accountUpdate = this.internal.mint({ address: recipient, amount });
+      const adminContract2 = await this.getAdminContract();
+      const canMint = await adminContract2.canMint(accountUpdate);
+      canMint.assertTrue(FungibleTokenErrors.noPermissionToMint);
+      recipient.equals(this.address).assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+      this.approve(accountUpdate);
+      this.emitEvent("Mint", new MintEvent({ recipient, amount }));
+      const circulationUpdate = import_o1js9.AccountUpdate.create(this.address, this.deriveTokenId());
+      circulationUpdate.balanceChange = import_o1js9.Int64.fromUnsigned(amount);
+      return accountUpdate;
+    }
+    async burn(from, amount) {
+      this.paused.getAndRequireEquals().assertFalse(FungibleTokenErrors.tokenPaused);
+      const accountUpdate = this.internal.burn({ address: from, amount });
+      const circulationUpdate = import_o1js9.AccountUpdate.create(this.address, this.deriveTokenId());
+      from.equals(this.address).assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+      circulationUpdate.balanceChange = import_o1js9.Int64.fromUnsigned(amount).neg();
+      this.emitEvent("Burn", new BurnEvent({ from, amount }));
+      return accountUpdate;
+    }
+    async pause() {
+      const adminContract2 = await this.getAdminContract();
+      const canPause = await adminContract2.canPause();
+      canPause.assertTrue(FungibleTokenErrors.noPermissionToPause);
+      this.paused.set((0, import_o1js9.Bool)(true));
+      this.emitEvent("Pause", new PauseEvent({ isPaused: (0, import_o1js9.Bool)(true) }));
+    }
+    async resume() {
+      const adminContract2 = await this.getAdminContract();
+      const canResume = await adminContract2.canResume();
+      canResume.assertTrue(FungibleTokenErrors.noPermissionToResume);
+      this.paused.set((0, import_o1js9.Bool)(false));
+      this.emitEvent("Pause", new PauseEvent({ isPaused: (0, import_o1js9.Bool)(false) }));
+    }
+    async transfer(from, to, amount) {
+      this.paused.getAndRequireEquals().assertFalse(FungibleTokenErrors.tokenPaused);
+      from.equals(this.address).assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+      to.equals(this.address).assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+      this.internal.send({ from, to, amount });
+    }
+    checkPermissionsUpdate(update) {
+      let permissions = update.update.permissions;
+      let { access, receive } = permissions.value;
+      let accessIsNone = import_o1js9.Provable.equal(import_o1js9.Types.AuthRequired, access, import_o1js9.Permissions.none());
+      let receiveIsNone = import_o1js9.Provable.equal(import_o1js9.Types.AuthRequired, receive, import_o1js9.Permissions.none());
+      let updateAllowed = accessIsNone.and(receiveIsNone);
+      (0, import_o1js9.assert)(updateAllowed.or(permissions.isSome.not()), FungibleTokenErrors.noPermissionChangeAllowed);
+    }
+    /** Approve `AccountUpdate`s that have been created outside of the token contract.
+     *
+     * @argument {AccountUpdateForest} updates - The `AccountUpdate`s to approve. Note that the forest size is limited by the base token contract, @see TokenContract.MAX_ACCOUNT_UPDATES The current limit is 9.
+     */
+    async approveBase(updates) {
+      this.paused.getAndRequireEquals().assertFalse(FungibleTokenErrors.tokenPaused);
+      let totalBalance = import_o1js9.Int64.from(0);
+      this.forEachUpdate(updates, (update, usesToken) => {
+        this.checkPermissionsUpdate(update);
+        this.emitEventIf(usesToken, "BalanceChange", new BalanceChangeEvent({
+          address: update.publicKey,
+          amount: update.balanceChange
+        }));
+        update.publicKey.equals(this.address).and(usesToken).assertFalse(FungibleTokenErrors.noTransferFromCirculation);
+        totalBalance = import_o1js9.Provable.if(usesToken, totalBalance.add(update.balanceChange), totalBalance);
+        totalBalance.isPositive().assertFalse(FungibleTokenErrors.flashMinting);
+      });
+      totalBalance.assertEquals(import_o1js9.Int64.zero, FungibleTokenErrors.unbalancedTransaction);
+    }
+    async getBalanceOf(address) {
+      const account = import_o1js9.AccountUpdate.create(address, this.deriveTokenId()).account;
+      const balance = account.balance.get();
+      account.balance.requireEquals(balance);
+      return balance;
+    }
+    /** Reports the current circulating supply
+     * This does take into account currently unreduced actions.
+     */
+    async getCirculating() {
+      let circulating = await this.getBalanceOf(this.address);
+      return circulating;
+    }
+    async getDecimals() {
+      return this.decimals.getAndRequireEquals();
+    }
+  }
+  (0, import_tslib.__decorate)([
+    (0, import_o1js9.state)(import_o1js9.UInt8),
+    (0, import_tslib.__metadata)("design:type", Object)
+  ], FungibleToken2.prototype, "decimals", void 0);
+  (0, import_tslib.__decorate)([
+    (0, import_o1js9.state)(import_o1js9.PublicKey),
+    (0, import_tslib.__metadata)("design:type", Object)
+  ], FungibleToken2.prototype, "admin", void 0);
+  (0, import_tslib.__decorate)([
+    (0, import_o1js9.state)(import_o1js9.Bool),
+    (0, import_tslib.__metadata)("design:type", Object)
+  ], FungibleToken2.prototype, "paused", void 0);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method,
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.VerificationKey]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "updateVerificationKey", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method,
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.PublicKey, import_o1js9.UInt8, import_o1js9.Bool]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "initialize", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method,
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.PublicKey]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "setAdmin", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method.returns(import_o1js9.AccountUpdate),
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.PublicKey, import_o1js9.UInt64]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "mint", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method.returns(import_o1js9.AccountUpdate),
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.PublicKey, import_o1js9.UInt64]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "burn", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method,
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", []),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "pause", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method,
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", []),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "resume", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method,
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.PublicKey, import_o1js9.PublicKey, import_o1js9.UInt64]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "transfer", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method,
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.AccountUpdateForest]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "approveBase", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method.returns(import_o1js9.UInt64),
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", [import_o1js9.PublicKey]),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "getBalanceOf", null);
+  (0, import_tslib.__decorate)([
+    import_o1js9.method.returns(import_o1js9.UInt8),
+    (0, import_tslib.__metadata)("design:type", Function),
+    (0, import_tslib.__metadata)("design:paramtypes", []),
+    (0, import_tslib.__metadata)("design:returntype", Promise)
+  ], FungibleToken2.prototype, "getDecimals", null);
+  return FungibleToken2;
+}
+var SetAdminEvent = class extends (0, import_o1js9.Struct)({
+  adminKey: import_o1js9.PublicKey
+}) {
+};
+var PauseEvent = class extends (0, import_o1js9.Struct)({
+  isPaused: import_o1js9.Bool
+}) {
+};
+var MintEvent = class extends (0, import_o1js9.Struct)({
+  recipient: import_o1js9.PublicKey,
+  amount: import_o1js9.UInt64
+}) {
+};
+var BurnEvent = class extends (0, import_o1js9.Struct)({
+  from: import_o1js9.PublicKey,
+  amount: import_o1js9.UInt64
+}) {
+};
+var BalanceChangeEvent = class extends (0, import_o1js9.Struct)({
+  address: import_o1js9.PublicKey,
+  amount: import_o1js9.Int64
+}) {
+};
+
+// dist/node/mina/token/FungibleTokenAdmin.js
+var import_tslib2 = require("tslib");
+var import_o1js10 = require("o1js");
+var FungibleTokenAdmin = class extends import_o1js10.SmartContract {
+  constructor() {
+    super(...arguments);
+    this.adminPublicKey = (0, import_o1js10.State)();
+  }
+  async deploy(props) {
+    await super.deploy(props);
+    this.adminPublicKey.set(props.adminPublicKey);
+    this.account.permissions.set({
+      ...import_o1js10.Permissions.default(),
+      setVerificationKey: import_o1js10.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js10.Permissions.impossible()
+    });
+  }
+  /** Update the verification key.
+   * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update.
+   */
+  async updateVerificationKey(vk) {
+    this.account.verificationKey.set(vk);
+  }
+  async ensureAdminSignature() {
+    const admin = await import_o1js10.Provable.witnessAsync(import_o1js10.PublicKey, async () => {
+      let pk = await this.adminPublicKey.fetch();
+      (0, import_o1js10.assert)(pk !== void 0, "could not fetch admin public key");
+      return pk;
+    });
+    this.adminPublicKey.requireEquals(admin);
+    return import_o1js10.AccountUpdate.createSigned(admin);
+  }
+  async canMint(_accountUpdate) {
+    await this.ensureAdminSignature();
+    return (0, import_o1js10.Bool)(true);
+  }
+  async canChangeAdmin(_admin) {
+    await this.ensureAdminSignature();
+    return (0, import_o1js10.Bool)(true);
+  }
+  async canPause() {
+    await this.ensureAdminSignature();
+    return (0, import_o1js10.Bool)(true);
+  }
+  async canResume() {
+    await this.ensureAdminSignature();
+    return (0, import_o1js10.Bool)(true);
+  }
+};
+(0, import_tslib2.__decorate)([
+  (0, import_o1js10.state)(import_o1js10.PublicKey),
+  (0, import_tslib2.__metadata)("design:type", Object)
+], FungibleTokenAdmin.prototype, "adminPublicKey", void 0);
+(0, import_tslib2.__decorate)([
+  import_o1js10.method,
+  (0, import_tslib2.__metadata)("design:type", Function),
+  (0, import_tslib2.__metadata)("design:paramtypes", [import_o1js10.VerificationKey]),
+  (0, import_tslib2.__metadata)("design:returntype", Promise)
+], FungibleTokenAdmin.prototype, "updateVerificationKey", null);
+(0, import_tslib2.__decorate)([
+  import_o1js10.method.returns(import_o1js10.Bool),
+  (0, import_tslib2.__metadata)("design:type", Function),
+  (0, import_tslib2.__metadata)("design:paramtypes", [import_o1js10.AccountUpdate]),
+  (0, import_tslib2.__metadata)("design:returntype", Promise)
+], FungibleTokenAdmin.prototype, "canMint", null);
+(0, import_tslib2.__decorate)([
+  import_o1js10.method.returns(import_o1js10.Bool),
+  (0, import_tslib2.__metadata)("design:type", Function),
+  (0, import_tslib2.__metadata)("design:paramtypes", [import_o1js10.PublicKey]),
+  (0, import_tslib2.__metadata)("design:returntype", Promise)
+], FungibleTokenAdmin.prototype, "canChangeAdmin", null);
+(0, import_tslib2.__decorate)([
+  import_o1js10.method.returns(import_o1js10.Bool),
+  (0, import_tslib2.__metadata)("design:type", Function),
+  (0, import_tslib2.__metadata)("design:paramtypes", []),
+  (0, import_tslib2.__metadata)("design:returntype", Promise)
+], FungibleTokenAdmin.prototype, "canPause", null);
+(0, import_tslib2.__decorate)([
+  import_o1js10.method.returns(import_o1js10.Bool),
+  (0, import_tslib2.__metadata)("design:type", Function),
+  (0, import_tslib2.__metadata)("design:paramtypes", []),
+  (0, import_tslib2.__metadata)("design:returntype", Promise)
+], FungibleTokenAdmin.prototype, "canResume", null);
+
+// dist/node/mina/token/FungibleTokenWhitelistedAdmin.js
+var import_tslib3 = require("tslib");
+var import_o1js11 = require("o1js");
+var FungibleTokenWhitelistedAdmin = class extends import_o1js11.SmartContract {
+  constructor() {
+    super(...arguments);
+    this.adminPublicKey = (0, import_o1js11.State)();
+    this.whitelist = (0, import_o1js11.State)();
+    this.events = { updateWhitelist: Whitelist };
+  }
+  async deploy(props) {
+    await super.deploy(props);
+    this.adminPublicKey.set(props.adminPublicKey);
+    this.whitelist.set(props.whitelist);
+    this.account.permissions.set({
+      ...import_o1js11.Permissions.default(),
+      setVerificationKey: import_o1js11.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js11.Permissions.impossible()
+    });
+  }
+  /** Update the verification key.
+   * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update.
+   */
+  async updateVerificationKey(vk) {
+    this.account.verificationKey.set(vk);
+  }
+  async ensureAdminSignature() {
+    const admin = await import_o1js11.Provable.witnessAsync(import_o1js11.PublicKey, async () => {
+      let pk = await this.adminPublicKey.fetch();
+      (0, import_o1js11.assert)(pk !== void 0, "could not fetch admin public key");
+      return pk;
+    });
+    this.adminPublicKey.requireEquals(admin);
+    return import_o1js11.AccountUpdate.createSigned(admin);
+  }
+  async canMint(_accountUpdate) {
+    const address = _accountUpdate.body.publicKey;
+    const balanceChange = _accountUpdate.body.balanceChange;
+    balanceChange.isPositive().assertTrue();
+    const whitelist = this.whitelist.getAndRequireEquals();
+    const whitelistedAmount = await whitelist.getWhitelistedAmount(address);
+    return balanceChange.magnitude.lessThanOrEqual(
+      whitelistedAmount.orElse(import_o1js11.UInt64.from(0))
+      // here can be a minimum amount allowed by travel rule instead of 0
+    );
+  }
+  async canChangeAdmin(_admin) {
+    await this.ensureAdminSignature();
+    return (0, import_o1js11.Bool)(true);
+  }
+  async canPause() {
+    await this.ensureAdminSignature();
+    return (0, import_o1js11.Bool)(true);
+  }
+  async canResume() {
+    await this.ensureAdminSignature();
+    return (0, import_o1js11.Bool)(true);
+  }
+  async updateWhitelist(whitelist) {
+    const admin = this.adminPublicKey.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = import_o1js11.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js11.Bool)(true);
+    admin.assertEquals(sender);
+    this.whitelist.set(whitelist);
+    this.emitEvent("updateWhitelist", whitelist);
+  }
+};
+(0, import_tslib3.__decorate)([
+  (0, import_o1js11.state)(import_o1js11.PublicKey),
+  (0, import_tslib3.__metadata)("design:type", Object)
+], FungibleTokenWhitelistedAdmin.prototype, "adminPublicKey", void 0);
+(0, import_tslib3.__decorate)([
+  (0, import_o1js11.state)(Whitelist),
+  (0, import_tslib3.__metadata)("design:type", Object)
+], FungibleTokenWhitelistedAdmin.prototype, "whitelist", void 0);
+(0, import_tslib3.__decorate)([
+  import_o1js11.method,
+  (0, import_tslib3.__metadata)("design:type", Function),
+  (0, import_tslib3.__metadata)("design:paramtypes", [import_o1js11.VerificationKey]),
+  (0, import_tslib3.__metadata)("design:returntype", Promise)
+], FungibleTokenWhitelistedAdmin.prototype, "updateVerificationKey", null);
+(0, import_tslib3.__decorate)([
+  import_o1js11.method.returns(import_o1js11.Bool),
+  (0, import_tslib3.__metadata)("design:type", Function),
+  (0, import_tslib3.__metadata)("design:paramtypes", [import_o1js11.AccountUpdate]),
+  (0, import_tslib3.__metadata)("design:returntype", Promise)
+], FungibleTokenWhitelistedAdmin.prototype, "canMint", null);
+(0, import_tslib3.__decorate)([
+  import_o1js11.method.returns(import_o1js11.Bool),
+  (0, import_tslib3.__metadata)("design:type", Function),
+  (0, import_tslib3.__metadata)("design:paramtypes", [import_o1js11.PublicKey]),
+  (0, import_tslib3.__metadata)("design:returntype", Promise)
+], FungibleTokenWhitelistedAdmin.prototype, "canChangeAdmin", null);
+(0, import_tslib3.__decorate)([
+  import_o1js11.method.returns(import_o1js11.Bool),
+  (0, import_tslib3.__metadata)("design:type", Function),
+  (0, import_tslib3.__metadata)("design:paramtypes", []),
+  (0, import_tslib3.__metadata)("design:returntype", Promise)
+], FungibleTokenWhitelistedAdmin.prototype, "canPause", null);
+(0, import_tslib3.__decorate)([
+  import_o1js11.method.returns(import_o1js11.Bool),
+  (0, import_tslib3.__metadata)("design:type", Function),
+  (0, import_tslib3.__metadata)("design:paramtypes", []),
+  (0, import_tslib3.__metadata)("design:returntype", Promise)
+], FungibleTokenWhitelistedAdmin.prototype, "canResume", null);
+(0, import_tslib3.__decorate)([
+  import_o1js11.method,
+  (0, import_tslib3.__metadata)("design:type", Function),
+  (0, import_tslib3.__metadata)("design:paramtypes", [Whitelist]),
+  (0, import_tslib3.__metadata)("design:returntype", Promise)
+], FungibleTokenWhitelistedAdmin.prototype, "updateWhitelist", null);
+
+// dist/node/mina/token/offer.js
+var import_tslib4 = require("tslib");
+var import_o1js12 = require("o1js");
+var FungibleTokenOfferContract = class _FungibleTokenOfferContract extends import_o1js12.SmartContract {
+  constructor() {
+    super(...arguments);
+    this.price = (0, import_o1js12.State)();
+    this.seller = (0, import_o1js12.State)();
+    this.token = (0, import_o1js12.State)();
+    this.whitelist = (0, import_o1js12.State)();
+    this.events = {
+      offer: import_o1js12.UInt64,
+      withdraw: import_o1js12.UInt64,
+      buy: import_o1js12.UInt64,
+      updateWhitelist: Whitelist
+    };
+  }
+  async deploy(args) {
+    await super.deploy(args);
+    const verificationKey = args?.verificationKey ?? _FungibleTokenOfferContract._verificationKey;
+    (0, import_o1js12.assert)(verificationKey !== void 0);
+    const hash = typeof verificationKey.hash === "string" ? verificationKey.hash : verificationKey.hash.toJSON();
+    const networkId = import_o1js12.Mina.getNetworkId();
+    (0, import_o1js12.assert)(networkId === "mainnet" || networkId === "testnet");
+    (0, import_o1js12.assert)(hash === tokenVerificationKeys[networkId].vk.FungibleTokenOfferContract.hash);
+    (0, import_o1js12.assert)(verificationKey.data === tokenVerificationKeys[networkId].vk.FungibleTokenOfferContract.data);
+    this.whitelist.set(args.whitelist);
+    this.account.permissions.set({
+      ...import_o1js12.Permissions.default(),
+      send: import_o1js12.Permissions.proof(),
+      setVerificationKey: import_o1js12.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js12.Permissions.impossible()
+    });
+  }
+  async initialize(seller, token, amount, price) {
+    this.account.provedState.requireEquals((0, import_o1js12.Bool)(false));
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+    await tokenContract.transfer(seller, this.address, amount);
+    this.seller.set(seller);
+    this.price.set(price);
+    this.token.set(token);
+    this.emitEvent("offer", amount);
+  }
+  async offer(amount, price) {
+    const seller = this.seller.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+    const balance = this.account.balance.getAndRequireEquals();
+    const oldPrice = this.price.getAndRequireEquals();
+    price.equals(oldPrice).or(balance.equals(import_o1js12.UInt64.from(0))).assertTrue();
+    this.price.set(price);
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = import_o1js12.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js12.Bool)(true);
+    sender.assertEquals(seller);
+    await tokenContract.transfer(sender, this.address, amount);
+    this.emitEvent("offer", amount);
+  }
+  async withdraw(amount) {
+    amount.equals(import_o1js12.UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, import_o1js12.UInt64.MAXINT());
+    const seller = this.seller.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = import_o1js12.AccountUpdate.createSigned(sender, tokenId);
+    senderUpdate.body.useFullCommitment = (0, import_o1js12.Bool)(true);
+    sender.assertEquals(seller);
+    let offerUpdate = this.send({ to: senderUpdate, amount });
+    offerUpdate.body.mayUseToken = import_o1js12.AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = (0, import_o1js12.Bool)(true);
+    this.emitEvent("withdraw", amount);
+  }
+  async buy(amount) {
+    amount.equals(import_o1js12.UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, import_o1js12.UInt64.MAXINT());
+    const seller = this.seller.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const tokenContract = new FungibleToken(token);
+    const tokenId = tokenContract.deriveTokenId();
+    tokenId.assertEquals(this.tokenId);
+    const price = this.price.getAndRequireEquals();
+    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js12.Field)(1e9));
+    totalPriceField.assertLessThan(import_o1js12.UInt64.MAXINT().value, "totalPrice overflow");
+    const totalPrice = import_o1js12.UInt64.Unsafe.fromField(totalPriceField);
+    const buyer = this.sender.getUnconstrained();
+    const buyerUpdate = import_o1js12.AccountUpdate.createSigned(buyer);
+    buyerUpdate.send({ to: seller, amount: totalPrice });
+    buyerUpdate.body.useFullCommitment = (0, import_o1js12.Bool)(true);
+    let offerUpdate = this.send({ to: buyer, amount });
+    offerUpdate.body.mayUseToken = import_o1js12.AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = (0, import_o1js12.Bool)(true);
+    const whitelist = this.whitelist.getAndRequireEquals();
+    const whitelistedAmount = await whitelist.getWhitelistedAmount(buyer);
+    amount.assertLessThanOrEqual(whitelistedAmount.assertSome());
+    this.emitEvent("buy", amount);
+  }
+  async updateWhitelist(whitelist) {
+    const seller = this.seller.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = import_o1js12.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js12.Bool)(true);
+    sender.assertEquals(seller);
+    this.whitelist.set(whitelist);
+    this.emitEvent("updateWhitelist", whitelist);
+  }
+};
+(0, import_tslib4.__decorate)([
+  (0, import_o1js12.state)(import_o1js12.UInt64),
+  (0, import_tslib4.__metadata)("design:type", Object)
+], FungibleTokenOfferContract.prototype, "price", void 0);
+(0, import_tslib4.__decorate)([
+  (0, import_o1js12.state)(import_o1js12.PublicKey),
+  (0, import_tslib4.__metadata)("design:type", Object)
+], FungibleTokenOfferContract.prototype, "seller", void 0);
+(0, import_tslib4.__decorate)([
+  (0, import_o1js12.state)(import_o1js12.PublicKey),
+  (0, import_tslib4.__metadata)("design:type", Object)
+], FungibleTokenOfferContract.prototype, "token", void 0);
+(0, import_tslib4.__decorate)([
+  (0, import_o1js12.state)(Whitelist),
+  (0, import_tslib4.__metadata)("design:type", Object)
+], FungibleTokenOfferContract.prototype, "whitelist", void 0);
+(0, import_tslib4.__decorate)([
+  import_o1js12.method,
+  (0, import_tslib4.__metadata)("design:type", Function),
+  (0, import_tslib4.__metadata)("design:paramtypes", [
+    import_o1js12.PublicKey,
+    import_o1js12.PublicKey,
+    import_o1js12.UInt64,
+    import_o1js12.UInt64
+  ]),
+  (0, import_tslib4.__metadata)("design:returntype", Promise)
+], FungibleTokenOfferContract.prototype, "initialize", null);
+(0, import_tslib4.__decorate)([
+  import_o1js12.method,
+  (0, import_tslib4.__metadata)("design:type", Function),
+  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js12.UInt64, import_o1js12.UInt64]),
+  (0, import_tslib4.__metadata)("design:returntype", Promise)
+], FungibleTokenOfferContract.prototype, "offer", null);
+(0, import_tslib4.__decorate)([
+  import_o1js12.method,
+  (0, import_tslib4.__metadata)("design:type", Function),
+  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js12.UInt64]),
+  (0, import_tslib4.__metadata)("design:returntype", Promise)
+], FungibleTokenOfferContract.prototype, "withdraw", null);
+(0, import_tslib4.__decorate)([
+  import_o1js12.method,
+  (0, import_tslib4.__metadata)("design:type", Function),
+  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js12.UInt64]),
+  (0, import_tslib4.__metadata)("design:returntype", Promise)
+], FungibleTokenOfferContract.prototype, "buy", null);
+(0, import_tslib4.__decorate)([
+  import_o1js12.method,
+  (0, import_tslib4.__metadata)("design:type", Function),
+  (0, import_tslib4.__metadata)("design:paramtypes", [Whitelist]),
+  (0, import_tslib4.__metadata)("design:returntype", Promise)
+], FungibleTokenOfferContract.prototype, "updateWhitelist", null);
+
+// dist/node/mina/token/token.js
+var FungibleToken = FungibleTokenContract(FungibleTokenAdmin);
+var WhitelistedFungibleToken = FungibleTokenContract(FungibleTokenWhitelistedAdmin);
+var tokenVerificationKeys = {
+  mainnet: {
+    o1js: "2.1.0",
+    zkcloudworker: "0.18.9",
+    vk: {
+      FungibleToken: {
+        hash: "27787098481477206239805523694633411816874383698563160451006881053714904356680",
+        data: "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"
+      },
+      FungibleTokenAdmin: {
+        hash: "25901604630376752069358432490423434073212977760589721765585739320126139736123",
+        data: "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"
+      },
+      WhitelistedFungibleToken: {
+        hash: "27787098481477206239805523694633411816874383698563160451006881053714904356680",
+        data: "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"
+      },
+      FungibleTokenWhitelistedAdmin: {
+        hash: "19641412157595882526013339127483017677791543136878603715474182835463393277622",
+        data: "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"
+      },
+      FungibleTokenBidContract: {
+        hash: "13290952274336741358452297924879435304865306432909699834625876541003088475079",
+        data: "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"
+      },
+      FungibleTokenOfferContract: {
+        hash: "2858136391761960286699306196905265168181712302492280978164878175630383743048",
+        data: "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"
+      },
+      FungibleTokenAdminMF: {
+        hash: "25901604630376752069358432490423434073212977760589721765585739320126139736123",
+        data: "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"
+      },
+      FungibleTokenMF: {
+        hash: "27787098481477206239805523694633411816874383698563160451006881053714904356680",
+        data: "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"
+      }
+    }
+  },
+  testnet: {
+    o1js: "2.1.0",
+    zkcloudworker: "0.18.9",
+    vk: {
+      FungibleToken: {
+        hash: "22278758441605771858700252645311428360030262698072838723799702480887091310093",
+        data: "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"
+      },
+      FungibleTokenAdmin: {
+        hash: "15958550144671703080408884627087990244648824766878280780120011347457437134053",
+        data: "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"
+      },
+      WhitelistedFungibleToken: {
+        hash: "22278758441605771858700252645311428360030262698072838723799702480887091310093",
+        data: "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"
+      },
+      FungibleTokenWhitelistedAdmin: {
+        hash: "20172938263834569171197221661527530681186299670687606810012808881888777415767",
+        data: "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"
+      },
+      FungibleTokenBidContract: {
+        hash: "21028578844692686241145580941807588328600986400769755733788301125980472965477",
+        data: "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"
+      },
+      FungibleTokenOfferContract: {
+        hash: "12073217068283876954049572004931286804667636618982691926234972243181859812345",
+        data: "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"
+      },
+      FungibleTokenAdminMF: {
+        hash: "15958550144671703080408884627087990244648824766878280780120011347457437134053",
+        data: "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"
+      },
+      FungibleTokenMF: {
+        hash: "22278758441605771858700252645311428360030262698072838723799702480887091310093",
+        data: "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"
+      }
+    }
+  }
+};
+
+// dist/node/mina/token/bid.js
+var FungibleTokenBidContract = class _FungibleTokenBidContract extends import_o1js13.SmartContract {
+  constructor() {
+    super(...arguments);
+    this.price = (0, import_o1js13.State)();
+    this.buyer = (0, import_o1js13.State)();
+    this.token = (0, import_o1js13.State)();
+    this.whitelist = (0, import_o1js13.State)();
+    this.events = {
+      bid: import_o1js13.UInt64,
+      withdraw: import_o1js13.UInt64,
+      sell: import_o1js13.UInt64,
+      updateWhitelist: Whitelist
+    };
+  }
+  async deploy(args) {
+    await super.deploy(args);
+    const verificationKey = args?.verificationKey ?? _FungibleTokenBidContract._verificationKey;
+    (0, import_o1js13.assert)(verificationKey !== void 0);
+    const hash = typeof verificationKey.hash === "string" ? verificationKey.hash : verificationKey.hash.toJSON();
+    const networkId = import_o1js13.Mina.getNetworkId();
+    (0, import_o1js13.assert)(networkId === "mainnet" || networkId === "testnet");
+    (0, import_o1js13.assert)(hash === tokenVerificationKeys[networkId].vk.FungibleTokenBidContract.hash);
+    (0, import_o1js13.assert)(verificationKey.data === tokenVerificationKeys[networkId].vk.FungibleTokenBidContract.data);
+    this.whitelist.set(args.whitelist);
+    this.account.permissions.set({
+      ...import_o1js13.Permissions.default(),
+      send: import_o1js13.Permissions.proof(),
+      setVerificationKey: import_o1js13.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js13.Permissions.impossible()
+    });
+  }
+  async initialize(token, amount, price) {
+    this.account.provedState.requireEquals((0, import_o1js13.Bool)(false));
+    amount.equals(import_o1js13.UInt64.from(0)).assertFalse();
+    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js13.Field)(1e9));
+    totalPriceField.assertLessThan(import_o1js13.UInt64.MAXINT().value, "totalPrice overflow");
+    const totalPrice = import_o1js13.UInt64.Unsafe.fromField(totalPriceField);
+    const buyer = this.sender.getUnconstrained();
+    const buyerUpdate = import_o1js13.AccountUpdate.createSigned(buyer);
+    buyerUpdate.send({ to: this.address, amount: totalPrice });
+    buyerUpdate.body.useFullCommitment = (0, import_o1js13.Bool)(true);
+    this.buyer.set(buyer);
+    this.price.set(price);
+    this.token.set(token);
+    this.emitEvent("bid", amount);
+  }
+  async bid(amount, price) {
+    amount.equals(import_o1js13.UInt64.from(0)).assertFalse();
+    const balance = this.account.balance.getAndRequireEquals();
+    const oldPrice = this.price.getAndRequireEquals();
+    price.equals(oldPrice).or(balance.equals(import_o1js13.UInt64.from(0))).assertTrue();
+    this.price.set(price);
+    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js13.Field)(1e9));
+    totalPriceField.assertLessThan(import_o1js13.UInt64.MAXINT().value, "totalPrice overflow");
+    const totalPrice = import_o1js13.UInt64.Unsafe.fromField(totalPriceField);
+    const sender = this.sender.getUnconstrained();
+    const buyer = this.buyer.getAndRequireEquals();
+    sender.assertEquals(buyer);
+    const buyerUpdate = import_o1js13.AccountUpdate.createSigned(buyer);
+    buyerUpdate.send({ to: this.address, amount: totalPrice });
+    buyerUpdate.body.useFullCommitment = (0, import_o1js13.Bool)(true);
+    this.price.set(price);
+    this.emitEvent("bid", amount);
+  }
+  async withdraw(amountInMina) {
+    amountInMina.equals(import_o1js13.UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amountInMina, import_o1js13.UInt64.MAXINT());
+    const buyer = this.buyer.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = import_o1js13.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js13.Bool)(true);
+    sender.assertEquals(buyer);
+    let bidUpdate = this.send({ to: senderUpdate, amount: amountInMina });
+    bidUpdate.body.useFullCommitment = (0, import_o1js13.Bool)(true);
+    this.emitEvent("withdraw", amountInMina);
+  }
+  async sell(amount) {
+    amount.equals(import_o1js13.UInt64.from(0)).assertFalse();
+    const price = this.price.getAndRequireEquals();
+    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js13.Field)(1e9));
+    totalPriceField.assertLessThan(import_o1js13.UInt64.MAXINT().value, "totalPrice overflow");
+    const totalPrice = import_o1js13.UInt64.Unsafe.fromField(totalPriceField);
+    this.account.balance.requireBetween(totalPrice, import_o1js13.UInt64.MAXINT());
+    const buyer = this.buyer.getAndRequireEquals();
+    const token = this.token.getAndRequireEquals();
+    const seller = this.sender.getUnconstrained();
+    const sellerUpdate = this.send({ to: seller, amount: totalPrice });
+    sellerUpdate.body.useFullCommitment = (0, import_o1js13.Bool)(true);
+    sellerUpdate.requireSignature();
+    const tokenContract = new FungibleToken(token);
+    await tokenContract.transfer(seller, buyer, amount);
+    this.emitEvent("sell", amount);
+  }
+  async updateWhitelist(whitelist) {
+    const buyer = this.buyer.getAndRequireEquals();
+    const sender = this.sender.getUnconstrained();
+    const senderUpdate = import_o1js13.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js13.Bool)(true);
+    sender.assertEquals(buyer);
+    this.whitelist.set(whitelist);
+    this.emitEvent("updateWhitelist", whitelist);
+  }
+};
+(0, import_tslib5.__decorate)([
+  (0, import_o1js13.state)(import_o1js13.UInt64),
+  (0, import_tslib5.__metadata)("design:type", Object)
+], FungibleTokenBidContract.prototype, "price", void 0);
+(0, import_tslib5.__decorate)([
+  (0, import_o1js13.state)(import_o1js13.PublicKey),
+  (0, import_tslib5.__metadata)("design:type", Object)
+], FungibleTokenBidContract.prototype, "buyer", void 0);
+(0, import_tslib5.__decorate)([
+  (0, import_o1js13.state)(import_o1js13.PublicKey),
+  (0, import_tslib5.__metadata)("design:type", Object)
+], FungibleTokenBidContract.prototype, "token", void 0);
+(0, import_tslib5.__decorate)([
+  (0, import_o1js13.state)(Whitelist),
+  (0, import_tslib5.__metadata)("design:type", Object)
+], FungibleTokenBidContract.prototype, "whitelist", void 0);
+(0, import_tslib5.__decorate)([
+  import_o1js13.method,
+  (0, import_tslib5.__metadata)("design:type", Function),
+  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js13.PublicKey, import_o1js13.UInt64, import_o1js13.UInt64]),
+  (0, import_tslib5.__metadata)("design:returntype", Promise)
+], FungibleTokenBidContract.prototype, "initialize", null);
+(0, import_tslib5.__decorate)([
+  import_o1js13.method,
+  (0, import_tslib5.__metadata)("design:type", Function),
+  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js13.UInt64, import_o1js13.UInt64]),
+  (0, import_tslib5.__metadata)("design:returntype", Promise)
+], FungibleTokenBidContract.prototype, "bid", null);
+(0, import_tslib5.__decorate)([
+  import_o1js13.method,
+  (0, import_tslib5.__metadata)("design:type", Function),
+  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js13.UInt64]),
+  (0, import_tslib5.__metadata)("design:returntype", Promise)
+], FungibleTokenBidContract.prototype, "withdraw", null);
+(0, import_tslib5.__decorate)([
+  import_o1js13.method,
+  (0, import_tslib5.__metadata)("design:type", Function),
+  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js13.UInt64]),
+  (0, import_tslib5.__metadata)("design:returntype", Promise)
+], FungibleTokenBidContract.prototype, "sell", null);
+(0, import_tslib5.__decorate)([
+  import_o1js13.method,
+  (0, import_tslib5.__metadata)("design:type", Function),
+  (0, import_tslib5.__metadata)("design:paramtypes", [Whitelist]),
+  (0, import_tslib5.__metadata)("design:returntype", Promise)
+], FungibleTokenBidContract.prototype, "updateWhitelist", null);
+
+// dist/node/mina/token/build.js
+var import_o1js14 = require("o1js");
+async function buildTokenDeployTransaction(params) {
+  const { fee: fee2, sender, nonce, memo, tokenAddress, adminContractAddress, uri, symbol, developerAddress, developerFee, provingKey, provingFee, decimals, chain, whitelist } = params;
+  const isWhitelisted = whitelist !== void 0;
+  if (memo && typeof memo !== "string")
+    throw new Error("Memo must be a string");
+  if (memo && memo.length > 30)
+    throw new Error("Memo must be less than 30 characters");
+  if (!symbol || typeof symbol !== "string")
+    throw new Error("Symbol must be a string");
+  if (symbol.length >= 7)
+    throw new Error("Symbol must be less than 7 characters");
+  const adminContract = isWhitelisted ? FungibleTokenWhitelistedAdmin : FungibleTokenAdmin;
+  const tokenContract = isWhitelisted ? WhitelistedFungibleToken : FungibleToken;
+  const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "testnet"].vk;
+  if (!vk || !vk.FungibleTokenWhitelistedAdmin || !vk.FungibleTokenWhitelistedAdmin.hash || !vk.FungibleTokenWhitelistedAdmin.data || !vk.FungibleTokenAdmin || !vk.FungibleTokenAdmin.hash || !vk.FungibleTokenAdmin.data || !vk.WhitelistedFungibleToken || !vk.WhitelistedFungibleToken.hash || !vk.WhitelistedFungibleToken.data || !vk.FungibleToken || !vk.FungibleToken.hash || !vk.FungibleToken.data)
+    throw new Error("Cannot get verification keys");
+  const adminVerificationKey = isWhitelisted ? vk.FungibleTokenWhitelistedAdmin : vk.FungibleTokenAdmin;
+  const tokenVerificationKey = isWhitelisted ? vk.WhitelistedFungibleToken : vk.FungibleToken;
+  if (!adminVerificationKey || !tokenVerificationKey)
+    throw new Error("Cannot get verification keys");
+  await fetchMinaAccount({
+    publicKey: sender,
+    force: true
+  });
+  if (!import_o1js14.Mina.hasAccount(sender)) {
+    throw new Error("Sender does not have account");
+  }
+  console.log("Sender balance:", await accountBalanceMina(sender));
+  const whitelistedAddresses = whitelist ? await Whitelist.create({ list: whitelist, name: symbol }) : void 0;
+  const zkToken = new tokenContract(tokenAddress);
+  const zkAdmin = new adminContract(adminContractAddress);
+  const tx = await import_o1js14.Mina.transaction({ sender, fee: fee2, memo: memo ?? `deploy ${symbol}`, nonce }, async () => {
+    const feeAccountUpdate = import_o1js14.AccountUpdate.createSigned(sender);
+    feeAccountUpdate.balance.subInPlace(3e9);
+    feeAccountUpdate.send({
+      to: provingKey,
+      amount: provingFee
+    });
+    if (developerAddress && developerFee) {
+      feeAccountUpdate.send({
+        to: developerAddress,
+        amount: developerFee
+      });
+    }
+    if (isWhitelisted && !whitelistedAddresses) {
+      throw new Error("Whitelisted addresses not found");
+    }
+    await zkAdmin.deploy({
+      adminPublicKey: sender,
+      verificationKey: adminVerificationKey,
+      whitelist: whitelistedAddresses
+    });
+    zkAdmin.account.zkappUri.set(uri);
+    await zkToken.deploy({
+      symbol,
+      src: uri,
+      verificationKey: tokenVerificationKey
+    });
+    await zkToken.initialize(
+      adminContractAddress,
+      decimals,
+      // We can set `startPaused` to `Bool(false)` here, because we are doing an atomic deployment
+      // If you are not deploying the admin and token contracts in the same transaction,
+      // it is safer to start the tokens paused, and resume them only after verifying that
+      // the admin contract has been deployed
+      (0, import_o1js14.Bool)(false)
+    );
+  });
+  return {
+    tx,
+    isWhitelisted,
+    adminVerificationKey: {
+      hash: (0, import_o1js14.Field)(adminVerificationKey.hash),
+      data: adminVerificationKey.data
+    },
+    tokenVerificationKey: {
+      hash: (0, import_o1js14.Field)(tokenVerificationKey.hash),
+      data: tokenVerificationKey.data
+    }
+  };
+}
+async function buildTokenTransaction(params) {
+  const { txType, chain, fee: fee2, sender, nonce, tokenAddress, from, to, amount, price, developerAddress, developerFee, provingKey, provingFee, whitelist } = params;
+  console.log(txType, "tx for", tokenAddress.toBase58());
+  console.log("Sender:", sender.toBase58());
+  if (txType === "offer" || txType === "bid" || // direction is money direction as no token is moving
+  txType === "mint" || txType === "transfer" || txType === "sell") {
+    if (sender.toBase58() != from.toBase58())
+      throw new Error("Invalid sender");
+  }
+  if (txType === "buy" || txType === "withdrawOffer" || txType === "withdrawBid") {
+    if (sender.toBase58() != to.toBase58())
+      throw new Error("Invalid sender");
+  }
+  await fetchMinaAccount({
+    publicKey: sender,
+    force: true
+  });
+  if (!import_o1js14.Mina.hasAccount(sender)) {
+    console.error("Sender does not have account");
+    throw new Error("Sender does not have account");
+  }
+  const { symbol, adminContractAddress, adminAddress, isWhitelisted } = await getTokenSymbolAndAdmin({
+    tokenAddress,
+    chain
+  });
+  const memo = params.memo ?? `${txType} ${symbol}`;
+  const whitelistedAdminContract = new FungibleTokenWhitelistedAdmin(adminContractAddress);
+  const tokenContract = isWhitelisted ? WhitelistedFungibleToken : FungibleToken;
+  if ((txType === "whitelistAdmin" || txType === "whitelistBid" || txType === "whitelistOffer") && !whitelist) {
+    throw new Error("Whitelist is required");
+  }
+  const whitelistedAddresses = whitelist ? await Whitelist.create({ list: whitelist, name: symbol }) : void 0;
+  const zkToken = new tokenContract(tokenAddress);
+  const tokenId = zkToken.deriveTokenId();
+  if (txType === "mint" && adminAddress.toBase58() !== sender.toBase58())
+    throw new Error("Invalid sender for mint");
+  await fetchMinaAccount({
+    publicKey: tokenAddress,
+    tokenId,
+    force: true
+  });
+  await fetchMinaAccount({
+    publicKey: from,
+    tokenId,
+    force: [
+      "offer",
+      "sell",
+      "transfer",
+      "withdrawOffer"
+    ].includes(txType)
+  });
+  await fetchMinaAccount({
+    publicKey: to,
+    tokenId,
+    force: [
+      "sell",
+      "whitelistAdmin",
+      "withdrawBid",
+      "withdrawOffer"
+    ].includes(txType)
+  });
+  const isNewAccount = import_o1js14.Mina.hasAccount(to, tokenId) === false;
+  const offerContract = new FungibleTokenOfferContract([
+    "offer",
+    "whitelistOffer"
+  ].includes(txType) ? to : from, tokenId);
+  const bidContract = new FungibleTokenBidContract([
+    "bid"
+  ].includes(txType) ? from : to, tokenId);
+  const offerContractDeployment = new FungibleTokenOfferContract(to, tokenId);
+  const bidContractDeployment = new FungibleTokenBidContract(from, tokenId);
+  const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "testnet"].vk;
+  if (!vk || !vk.FungibleTokenOfferContract || !vk.FungibleTokenOfferContract.hash || !vk.FungibleTokenOfferContract.data || !vk.FungibleTokenBidContract || !vk.FungibleTokenBidContract.hash || !vk.FungibleTokenBidContract.data || !vk.FungibleTokenWhitelistedAdmin || !vk.FungibleTokenWhitelistedAdmin.hash || !vk.FungibleTokenWhitelistedAdmin.data || !vk.FungibleTokenAdmin || !vk.FungibleTokenAdmin.hash || !vk.FungibleTokenAdmin.data || !vk.WhitelistedFungibleToken || !vk.WhitelistedFungibleToken.hash || !vk.WhitelistedFungibleToken.data || !vk.FungibleToken || !vk.FungibleToken.hash || !vk.FungibleToken.data)
+    throw new Error("Cannot get verification key");
+  const adminVerificationKey = isWhitelisted ? vk.FungibleTokenWhitelistedAdmin : vk.FungibleTokenAdmin;
+  const tokenVerificationKey = isWhitelisted ? vk.WhitelistedFungibleToken : vk.FungibleToken;
+  const offerVerificationKey = FungibleTokenOfferContract._verificationKey ?? {
+    hash: (0, import_o1js14.Field)(vk.FungibleTokenOfferContract.hash),
+    data: vk.FungibleTokenOfferContract.data
+  };
+  const bidVerificationKey = FungibleTokenBidContract._verificationKey ?? {
+    hash: (0, import_o1js14.Field)(vk.FungibleTokenBidContract.hash),
+    data: vk.FungibleTokenBidContract.data
+  };
+  console.log("Sender balance:", await accountBalanceMina(sender));
+  console.log("New account:", isNewAccount);
+  const tx = await import_o1js14.Mina.transaction({ sender, fee: fee2, memo, nonce }, async () => {
+    const feeAccountUpdate = import_o1js14.AccountUpdate.createSigned(sender);
+    if (isNewAccount) {
+      feeAccountUpdate.balance.subInPlace(1e9);
+    }
+    feeAccountUpdate.send({
+      to: provingKey,
+      amount: provingFee
+    });
+    if (developerAddress && developerFee) {
+      feeAccountUpdate.send({
+        to: developerAddress,
+        amount: developerFee
+      });
+    }
+    switch (txType) {
+      case "mint":
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        await zkToken.mint(to, amount);
+        break;
+      case "transfer":
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        await zkToken.transfer(from, to, amount);
+        break;
+      case "offer":
+        if (price === void 0)
+          throw new Error("Error: Price is required");
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        if (isNewAccount) {
+          await offerContractDeployment.deploy({
+            verificationKey: offerVerificationKey,
+            whitelist: whitelistedAddresses ?? Whitelist.empty()
+          });
+          offerContract.account.zkappUri.set(`Offer for ${symbol}`);
+          await offerContract.initialize(sender, tokenAddress, amount, price);
+          await zkToken.approveAccountUpdates([
+            offerContractDeployment.self,
+            offerContract.self
+          ]);
+        } else {
+          await offerContract.offer(amount, price);
+          await zkToken.approveAccountUpdate(offerContract.self);
+        }
+        break;
+      case "buy":
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        await offerContract.buy(amount);
+        await zkToken.approveAccountUpdate(offerContract.self);
+        break;
+      case "withdrawOffer":
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        await offerContract.withdraw(amount);
+        await zkToken.approveAccountUpdate(offerContract.self);
+        break;
+      case "bid":
+        if (price === void 0)
+          throw new Error("Error: Price is required");
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        if (isNewAccount) {
+          await bidContractDeployment.deploy({
+            verificationKey: bidVerificationKey,
+            whitelist: whitelistedAddresses ?? Whitelist.empty()
+          });
+          bidContract.account.zkappUri.set(`Bid for ${symbol}`);
+          await bidContract.initialize(tokenAddress, amount, price);
+          await zkToken.approveAccountUpdates([
+            bidContractDeployment.self,
+            bidContract.self
+          ]);
+        } else {
+          await bidContract.bid(amount, price);
+          await zkToken.approveAccountUpdate(bidContract.self);
+        }
+        break;
+      case "sell":
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        await bidContract.sell(amount);
+        await zkToken.approveAccountUpdate(bidContract.self);
+        break;
+      case "withdrawBid":
+        if (amount === void 0)
+          throw new Error("Error: Amount is required");
+        await bidContract.withdraw(amount);
+        await zkToken.approveAccountUpdate(bidContract.self);
+        break;
+      case "whitelistAdmin":
+        if (!whitelistedAddresses)
+          throw new Error("Whitelist is required");
+        await whitelistedAdminContract.updateWhitelist(whitelistedAddresses);
+        break;
+      case "whitelistBid":
+        if (!whitelistedAddresses)
+          throw new Error("Whitelist is required");
+        await bidContract.updateWhitelist(whitelistedAddresses);
+        break;
+      case "whitelistOffer":
+        if (!whitelistedAddresses)
+          throw new Error("Whitelist is required");
+        await offerContract.updateWhitelist(whitelistedAddresses);
+        await zkToken.approveAccountUpdate(offerContract.self);
+        break;
+      default:
+        throw new Error(`Unknown transaction type: ${txType}`);
+    }
+  });
+  return {
+    tx,
+    isWhitelisted,
+    adminContractAddress,
+    adminAddress,
+    symbol,
+    adminVerificationKey: {
+      hash: (0, import_o1js14.Field)(adminVerificationKey.hash),
+      data: adminVerificationKey.data
+    },
+    tokenVerificationKey: {
+      hash: (0, import_o1js14.Field)(tokenVerificationKey.hash),
+      data: tokenVerificationKey.data
+    },
+    offerVerificationKey,
+    bidVerificationKey
+  };
+}
+async function getTokenSymbolAndAdmin(params) {
+  const { tokenAddress, chain } = params;
+  const vk = tokenVerificationKeys[chain === "mainnet" ? "mainnet" : "testnet"].vk;
+  class FungibleTokenState extends (0, import_o1js14.Struct)({
+    decimals: import_o1js14.UInt8,
+    admin: import_o1js14.PublicKey,
+    paused: import_o1js14.Bool
+  }) {
+  }
+  const FungibleTokenStateSize = FungibleTokenState.sizeInFields();
+  class FungibleTokenAdminState extends (0, import_o1js14.Struct)({
+    adminPublicKey: import_o1js14.PublicKey
+  }) {
+  }
+  const FungibleTokenAdminStateSize = FungibleTokenAdminState.sizeInFields();
+  await fetchMinaAccount({ publicKey: tokenAddress, force: true });
+  if (!import_o1js14.Mina.hasAccount(tokenAddress)) {
+    throw new Error("Token contract account not found");
+  }
+  const account = import_o1js14.Mina.getAccount(tokenAddress);
+  const verificationKey = account.zkapp?.verificationKey;
+  if (!verificationKey) {
+    throw new Error("Token contract verification key not found");
+  }
+  if (verificationKey.hash.toJSON() !== vk.FungibleToken.hash || verificationKey.data !== vk.FungibleToken.data || verificationKey.hash.toJSON() !== vk.WhitelistedFungibleToken.hash || verificationKey.data !== vk.WhitelistedFungibleToken.data) {
+    throw new Error("Unknown token verification key");
+  }
+  if (account.zkapp?.appState === void 0) {
+    throw new Error("Token contract state not found");
+  }
+  const state7 = FungibleTokenState.fromFields(account.zkapp?.appState.slice(0, FungibleTokenStateSize));
+  const symbol = account.tokenSymbol;
+  const adminContractPublicKey = state7.admin;
+  await fetchMinaAccount({
+    publicKey: adminContractPublicKey,
+    force: true
+  });
+  if (!import_o1js14.Mina.hasAccount(adminContractPublicKey)) {
+    throw new Error("Admin contract account not found");
+  }
+  const adminContract = import_o1js14.Mina.getAccount(adminContractPublicKey);
+  const adminVerificationKey = adminContract.zkapp?.verificationKey;
+  if (!adminVerificationKey) {
+    throw new Error("Admin verification key not found");
+  }
+  let isWhitelisted = false;
+  if (vk.FungibleTokenWhitelistedAdmin.hash === adminVerificationKey.hash.toJSON() && vk.FungibleTokenWhitelistedAdmin.data === adminVerificationKey.data) {
+    isWhitelisted = true;
+  } else if (vk.FungibleTokenAdmin.hash === adminVerificationKey.hash.toJSON() && vk.FungibleTokenAdmin.data === adminVerificationKey.data) {
+    isWhitelisted = false;
+  } else {
+    throw new Error("Unknown admin verification key");
+  }
+  const adminAddress0 = adminContract.zkapp?.appState[0];
+  const adminAddress1 = adminContract.zkapp?.appState[1];
+  if (adminAddress0 === void 0 || adminAddress1 === void 0) {
+    throw new Error("Cannot fetch admin address from admin contract");
+  }
+  const adminAddress = import_o1js14.PublicKey.fromFields([adminAddress0, adminAddress1]);
+  return {
+    adminContractAddress: adminContractPublicKey,
+    adminAddress,
+    symbol,
+    isWhitelisted
+  };
+}
+
+// dist/node/mina/token/fee.js
+var LAUNCH_FEE = 1e9;
+var TRANSACTION_FEE = 1e8;
+
+// dist/node/mina/token/vk.js
+var fungibleTokenVerificationKeys = {
+  testnet: {
+    admin: {
+      hash: "15958550144671703080408884627087990244648824766878280780120011347457437134053",
+      data: "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"
+    },
+    token: {
+      hash: "22278758441605771858700252645311428360030262698072838723799702480887091310093",
+      data: "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"
+    }
+  },
+  mainnet: {
+    admin: {
+      hash: "25901604630376752069358432490423434073212977760589721765585739320126139736123",
+      data: "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"
+    },
+    token: {
+      hash: "27787098481477206239805523694633411816874383698563160451006881053714904356680",
+      data: "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"
+    }
+  },
+  testnet_v1: {
+    admin: {
+      hash: "1200635497217107248831982322269320244173535715339356861513501242012238077174",
+      data: "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"
+    },
+    token: {
+      hash: "25084457276132306637089336910977939820654927814172888515895248592725736067489",
+      data: "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"
+    }
+  },
+  mainnet_v1: {
+    admin: {
+      hash: "16115269877914581564299853766147447229664556890591132763176560855029019233817",
+      data: "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"
+    },
+    token: {
+      hash: "12320223354843720065815824451082596238990220882343256724550451075683722289248",
+      data: "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"
+    }
+  }
+};
+
+// dist/node/mina/transactions/blockberry.js
+async function getZkAppTxsFromBlockBerry(params) {
+  const { account, chain, blockBerryApiKey } = params;
+  const options = {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-api-key": blockBerryApiKey
+    }
+  };
+  try {
+    const response = await fetch(`https://api.blockberry.one/mina-${chain}/v1/zkapps/accounts/${account}/txs?size=10&orderBy=DESC&sortBy=AGE`, options);
+    if (!response.ok) {
+      console.error("Cannot fetch zkApp txs for account:", account, chain, response.statusText);
+      return void 0;
+    }
+    const result = await response.json();
+    return result;
+  } catch (err) {
+    console.error("Cannot fetch zkApp txs for account - catch:", account, chain, err);
+    return void 0;
+  }
+}
+async function getPaymentTxsFromBlockBerry(params) {
+  const { account, chain, blockBerryApiKey } = params;
+  const options = {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-api-key": blockBerryApiKey
+    }
+  };
+  try {
+    const response = await fetch(`https://api.blockberry.one/mina-${chain}/v1/accounts/` + account + "/txs?page=0&size=1&orderBy=DESC&sortBy=AGE&direction=OUT", options);
+    if (!response.ok) {
+      console.error("Cannot fetch payment txs for account:", account, chain, response.statusText);
+      return void 0;
+    }
+    const result = await response.json();
+    return result;
+  } catch (err) {
+    console.error("Cannot fetch payment txs for account - catch:", account, chain, err);
+    return void 0;
+  }
+}
+async function getZkAppTxFromBlockBerry(params) {
+  const { hash, chain, blockBerryApiKey } = params;
+  const options = {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-api-key": blockBerryApiKey
+    }
+  };
+  try {
+    const response = await fetch(`https://api.blockberry.one/mina-${chain}/v1/zkapps/txs/${hash}`, options);
+    if (response.ok) {
+      const result = await response.json();
+      return result;
+    } else {
+      console.error("getZkAppTxFromBlockBerry error while getting hash - not ok", { hash, chain, text: response.statusText, status: response.status });
+      return void 0;
+    }
+  } catch (err) {
+    console.error("getZkAppTxFromBlockBerry error while getting mainnet hash - catch", hash, chain, err);
+    return void 0;
+  }
+}
+async function getZkAppFromBlockBerry(params) {
+  const { account, chain, blockBerryApiKey } = params;
+  const options = {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-api-key": blockBerryApiKey
+    }
+  };
+  try {
+    const response = await fetch(`https://api.blockberry.one/mina-${chain}/v1/zkapps/${account}`, options);
+    if (response.ok) {
+      const result = await response.json();
+      return result;
+    } else {
+      console.error("getZkAppFromBlockBerry error while getting account", {
+        account,
+        chain,
+        text: response.statusText,
+        status: response.status
+      });
+      return void 0;
+    }
+  } catch (err) {
+    console.error("getZkAppFromBlockBerry error while getting account - catch", account, chain, err);
+    return void 0;
+  }
+}
+
+// dist/node/mina/transactions/nonce.js
+var import_o1js15 = require("o1js");
+async function getNonce(params) {
+  const { account, chain, blockBerryApiKey } = params;
+  try {
+    if (account === void 0 || account === null || account === "") {
+      return {
+        success: false,
+        nonce: -1,
+        message: "Account is required"
+      };
+    }
+    if (blockBerryApiKey === void 0 || blockBerryApiKey === null || blockBerryApiKey === "") {
+      return {
+        success: false,
+        nonce: -1,
+        message: "blockBerryApiKey is required"
+      };
+    }
+    const zkAppTxsPromise = getZkAppTxsFromBlockBerry({
+      account,
+      chain,
+      blockBerryApiKey
+    });
+    const paymentTxs = getPaymentTxsFromBlockBerry({
+      account,
+      chain,
+      blockBerryApiKey
+    });
+    const paymentNonce = (await paymentTxs)?.data[0]?.nonce ?? -1;
+    let zkNonce = -1;
+    let found = false;
+    const zkAppTxs = await zkAppTxsPromise;
+    const size = zkAppTxs?.data?.length ?? 0;
+    let i = 0;
+    while (!found && i < size) {
+      if (zkAppTxs?.data[i]?.proverAddress === account) {
+        zkNonce = zkAppTxs?.data[i]?.nonce;
+        found = true;
+      }
+      i++;
+    }
+    const nonce = Math.max(zkNonce, paymentNonce);
+    return {
+      success: true,
+      nonce
+    };
+  } catch (error) {
+    return {
+      success: false,
+      nonce: -1,
+      message: String(error)
+    };
+  }
+}
+async function getAccountNonce(params) {
+  const { account, chain = getCurrentNetwork().network.chainId, blockBerryApiKey, verbose = true } = params;
+  const canUseBlockBerry = blockBerryApiKey !== void 0 && (chain === "devnet" || chain === "mainnet");
+  if (chain === "zeko") {
+    const publicKey = import_o1js15.PublicKey.fromBase58(account);
+    await fetchMinaAccount({ publicKey });
+    const nonce = Number(import_o1js15.Mina.getAccount(publicKey).nonce.toBigint());
+    return nonce;
+  } else {
+    const blockberryNoncePromise = canUseBlockBerry ? getNonce({
+      account,
+      blockBerryApiKey,
+      chain
+    }) : void 0;
+    const publicKey = import_o1js15.PublicKey.fromBase58(account);
+    await fetchMinaAccount({ publicKey });
+    const senderNonce = Number(import_o1js15.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;
+  }
+}
+
+// dist/node/mina/transactions/transaction.js
+var import_o1js16 = require("o1js");
+function transactionParams(serializedTransaction, signedJson) {
+  const { sender, nonce, tx } = JSON.parse(serializedTransaction);
+  const transaction = import_o1js16.Mina.Transaction.fromJSON(JSON.parse(tx));
+  const memo = transaction.transaction.memo;
+  return {
+    fee: import_o1js16.UInt64.from(signedJson.zkappCommand.feePayer.body.fee),
+    sender: import_o1js16.PublicKey.fromBase58(sender),
+    nonce: Number(signedJson.zkappCommand.feePayer.body.nonce),
+    memo
+  };
+}
+function deserializeTransaction(serializedTransaction, txNew, signedJson) {
+  const { tx, blindingValues, length, forestJSONs } = JSON.parse(serializedTransaction);
+  const transaction = import_o1js16.Mina.Transaction.fromJSON(JSON.parse(tx));
+  const forests = forestJSONs.map((f) => JSON.parse(f));
+  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 === void 0 || transaction.transaction.accountUpdates[i].lazyAuthorization.blindingValue === void 0) {
+        throw new Error(`Lazy authorization blinding value is undefined for item ${i}`);
+      }
+      transaction.transaction.accountUpdates[i].lazyAuthorization.blindingValue = import_o1js16.Field.fromJSON(blindingValues[i]);
+    }
+    if (forests[i].length > 0) {
+      if (transaction.transaction.accountUpdates[i].lazyAuthorization === void 0 || transaction.transaction.accountUpdates[i].lazyAuthorization.args === void 0) {
+        throw new Error(`Lazy authorization args is undefined for item ${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`);
+      }
+    }
+  }
+  transaction.transaction.feePayer.authorization = signedJson.zkappCommand.feePayer.authorization;
+  transaction.transaction.feePayer.body.fee = import_o1js16.UInt64.from(signedJson.zkappCommand.feePayer.body.fee);
+  for (let i = 0; i < length; i++) {
+    const signature = signedJson.zkappCommand.accountUpdates[i].authorization.signature;
+    if (signature !== void 0 && signature !== null) {
+      transaction.transaction.accountUpdates[i].authorization.signature = signedJson.zkappCommand.accountUpdates[i].authorization.signature;
+    }
+  }
+  return transaction;
+}
+function serializeTransaction(tx) {
+  const length = tx.transaction.accountUpdates.length;
+  let i;
+  const blindingValues = [];
+  const forests = [];
+  for (i = 0; i < length; i++) {
+    const la = tx.transaction.accountUpdates[i].lazyAuthorization;
+    if (la !== void 0 && la.blindingValue !== void 0 && la.kind === "lazy-proof")
+      blindingValues.push(la.blindingValue.toJSON());
+    else
+      blindingValues.push("");
+    const forest = { length: 0, items: [] };
+    serializeLazyAuthorization(tx.transaction.accountUpdates[i].lazyAuthorization?.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, serialized) {
+  if (lazyAuthorization?.hash !== void 0 && lazyAuthorization.hash.toJSON) {
+    serialized.items.push({
+      h: fieldToBase64(lazyAuthorization.hash)
+    });
+  }
+  if (lazyAuthorization?.previousHash !== void 0 && lazyAuthorization.previousHash.toJSON) {
+    serialized.items.push({
+      p: fieldToBase64(lazyAuthorization.previousHash)
+    });
+  }
+  if (lazyAuthorization?.callData !== void 0 && lazyAuthorization.callData.toJSON) {
+    serialized.items.push({
+      c: fieldToBase64(lazyAuthorization.callData)
+    });
+  }
+  if (lazyAuthorization?.id !== void 0) {
+    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, serialized) {
+  if (serialized.restoredItems === void 0)
+    serialized.restoredItems = 0;
+  if (lazyAuthorization?.hash !== void 0 && 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 === void 0)
+      throw new Error(`Hash is undefined for item ${serialized.restoredItems}`);
+    lazyAuthorization.hash = fieldFromBase64(hash);
+    serialized.restoredItems++;
+  }
+  if (lazyAuthorization?.previousHash !== void 0 && 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 === void 0)
+      throw new Error(`Previous hash is undefined for item ${serialized.restoredItems}`);
+    lazyAuthorization.previousHash = fieldFromBase64(previousHash);
+    serialized.restoredItems++;
+  }
+  if (lazyAuthorization?.callData !== void 0 && 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 === void 0)
+      throw new Error(`Call data is undefined for item ${serialized.restoredItems}`);
+    lazyAuthorization.callData = fieldFromBase64(callData);
+    serialized.restoredItems++;
+  }
+  if (lazyAuthorization?.id !== void 0) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const id = serialized.items[serialized.restoredItems].i;
+    if (id === void 0)
+      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);
+    }
+  }
+}
+
+// dist/node/mina/transactions/txstatus.js
+var TIMEOUT = 1e3 * 60 * 21;
+async function txStatusBlockberry(params) {
+  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";
+  }
+}
+
+// dist/node/mina/transactions/tiny-contract.js
+var import_tslib6 = require("tslib");
+var import_o1js17 = require("o1js");
+var TinyContract = class extends import_o1js17.SmartContract {
+  constructor() {
+    super(...arguments);
+    this.value = (0, import_o1js17.State)();
+  }
+  async setValue(value) {
+    this.value.set(value);
+  }
+};
+(0, import_tslib6.__decorate)([
+  (0, import_o1js17.state)(import_o1js17.Field),
+  (0, import_tslib6.__metadata)("design:type", Object)
+], TinyContract.prototype, "value", void 0);
+(0, import_tslib6.__decorate)([
+  import_o1js17.method,
+  (0, import_tslib6.__metadata)("design:type", Function),
+  (0, import_tslib6.__metadata)("design:paramtypes", [import_o1js17.Field]),
+  (0, import_tslib6.__metadata)("design:returntype", Promise)
+], TinyContract.prototype, "setValue", null);
+
+// dist/node/mina/transactions/send.js
+var import_o1js18 = require("o1js");
+async function sendTx(params) {
+  const { tx, description = "", verbose = true, wait = true, chain = getCurrentNetwork().network.chainId } = params;
+  const accountUpdates = JSON.parse(tx.toJSON()).accountUpdates;
+  const auCount = [];
+  let proofAuthorizationCount = 0;
+  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(1e4);
+      } else {
+        console.error(`${description} tx NOT sent: hash: ${txSent?.hash} status: ${txSent?.status}`, txSent.errors);
+        return txSent;
+      }
+    }
+    if (txSent === void 0)
+      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") {
+        const { publicKey, nonce } = tx.transaction.feePayer.body;
+        const started = Date.now();
+        while (Date.now() - started < 1e3 * 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) / 1e3)} sec...`);
+          await sleep(1e4);
+        }
+        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 = getCurrentNetwork().network.chainId } = params;
+  if (chain === "local" || chain === "zeko")
+    return { success: true, result: true };
+  try {
+    const txStatus = await (0, import_o1js18.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" };
+  }
+}
+
+// dist/node/mina/transactions/account.js
+var import_o1js19 = require("o1js");
+async function accountExists(address, tokenId) {
+  try {
+    const publicKey = typeof address === "string" ? import_o1js19.PublicKey.fromBase58(address) : address;
+    await fetchMinaAccount({ publicKey, tokenId, force: false });
+    return import_o1js19.Mina.hasAccount(publicKey, tokenId);
+  } catch (error) {
+    return false;
+  }
+}
+async function tokenBalance(address, tokenId) {
+  try {
+    const publicKey = typeof address === "string" ? import_o1js19.PublicKey.fromBase58(address) : address;
+    await fetchMinaAccount({ publicKey, tokenId, force: false });
+    return import_o1js19.Mina.hasAccount(publicKey, tokenId) ? Number(import_o1js19.Mina.getAccount(publicKey, tokenId).balance.toBigInt()) : void 0;
+  } catch (error) {
+    console.error("Cannot fetch account balance", error);
+    return void 0;
+  }
+}
+async function checkAddress(address) {
+  if (!address || typeof address !== "string") {
+    console.error("checkAddress params are invalid:", address);
+    return false;
+  }
+  try {
+    const publicKey = import_o1js19.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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cloud,
+  Devnet,
+  FungibleToken,
+  FungibleTokenAdmin,
+  FungibleTokenBidContract,
+  FungibleTokenOfferContract,
+  FungibleTokenWhitelistedAdmin,
+  LAUNCH_FEE,
+  Lightnet,
+  Local,
+  LocalCloud,
+  LocalStorage,
+  Mainnet,
+  Memory,
+  Storage,
+  TRANSACTION_FEE,
+  TinyContract,
+  TokenAPI,
+  UInt64Option,
+  Whitelist,
+  WhitelistMap,
+  WhitelistMapOption,
+  WhitelistedAddress,
+  WhitelistedFungibleToken,
+  Zeko,
+  accountBalance,
+  accountBalanceMina,
+  accountExists,
+  bigintFromBase56,
+  bigintFromBase64,
+  bigintToBase56,
+  bigintToBase64,
+  buildTokenDeployTransaction,
+  buildTokenTransaction,
+  checkAddress,
+  checkMinaZkappTransaction,
+  createIpfsURL,
+  currentNetwork,
+  defaultToken,
+  deserializeFields,
+  deserializeIndexedMerkleMap,
+  deserializeTransaction,
+  fee,
+  fetchMinaAccount,
+  fetchMinaActions,
+  fieldFromBase56,
+  fieldFromBase64,
+  fieldToBase56,
+  fieldToBase64,
+  formatTime,
+  fromBase,
+  fungibleTokenVerificationKeys,
+  getAccountFromGraphQL,
+  getAccountNonce,
+  getBalanceFromGraphQL,
+  getCurrentNetwork,
+  getDeployer,
+  getNetworkIdHash,
+  getNonce,
+  getPaymentTxsFromBlockBerry,
+  getTokenSymbolAndAdmin,
+  getTxStatusFast,
+  getZkAppFromBlockBerry,
+  getZkAppTxFromBlockBerry,
+  getZkAppTxsFromBlockBerry,
+  initBlockchain,
+  loadIndexedMerkleMap,
+  makeString,
+  networks,
+  parseIndexedMapSerialized,
+  pinJSON,
+  saveIndexedMerkleMap,
+  sendTx,
+  serializeFields,
+  serializeIndexedMap,
+  serializeTransaction,
+  sleep,
+  toBase,
+  tokenBalance,
+  tokenVerificationKeys,
+  transactionParams,
+  txStatusBlockberry,
+  zkCloudWorker,
+  zkCloudWorkerClient
+});