@silvana-one/mina-prover 0.2.0

package/dist/node/index.cjs

@@ -0,0 +1,1161 @@
+"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 index_exports = {};
+__export(index_exports, {
+  LocalCloud: () => LocalCloud,
+  LocalStorage: () => LocalStorage,
+  NftAPI: () => NftAPI,
+  TokenAPI: () => TokenAPI,
+  zkCloudWorkerClient: () => zkCloudWorkerClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/node/api/api.js
+var import_chalk = __toESM(require("chalk"), 1);
+var import_mina_utils2 = require("@silvana-one/mina-utils");
+
+// dist/node/local/local.js
+var import_prover = require("@silvana-one/prover");
+var import_mina_utils = require("@silvana-one/mina-utils");
+var LocalCloud = class _LocalCloud extends import_prover.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() + "." + (0, import_mina_utils.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 = {};
+var LocalStorage = _LocalStorage;
+
+// dist/node/api/api.js
+var import_prover2 = require("@silvana-one/prover");
+var { ZKCLOUDWORKER_AUTH, ZKCLOUDWORKER_API } = import_prover2.config;
+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" || chain === "mainnet" ? 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 (0, import_mina_utils2.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 (0, import_mina_utils2.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 mainnet, 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 fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(apiData)
+        });
+        if (!response.ok) {
+          return {
+            success: false,
+            error: `fetch error: ${response.statusText} status: ${response.status}`
+          };
+        }
+        const data2 = await response.json();
+        return { success: true, data: data2 };
+      } 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/tokens/token.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 proveTransaction(params) {
+    return this.proveTransactions([params]);
+  }
+  async proveTransactions(params) {
+    const transactions = [];
+    for (const tx of params) {
+      const transaction = JSON.stringify(tx, null, 2);
+      transactions.push(transaction);
+    }
+    const { request, symbol } = params[0];
+    const { txType } = request;
+    const answer = await this.client.execute({
+      developer: "DFST",
+      repo: "token-launchpad",
+      transactions,
+      task: "prove",
+      args: JSON.stringify({ tokenAddress: params[0].request.tokenAddress }),
+      metadata: `${params.length > 1 ? "airdrop" : txType.replace(/^token:/, "")} token${symbol ? ` ${symbol}` : ""}${params.length > 1 ? ` (${params.length} txs)` : ""}`
+    });
+    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 getResults instead
+  async waitForJobResults(params) {
+    const deployResult = await this.client.waitForJobResult(params);
+    console.log("waitForJobResult result:", deployResult?.result?.result?.slice(0, 50));
+    return deployResult?.result?.result ?? "error";
+  }
+  async getResults(jobId) {
+    try {
+      const callResult = await this.client.jobResult({ jobId });
+      const jobStatus = typeof callResult?.result === "string" ? void 0 : callResult?.result?.jobStatus;
+      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 { proofs } = JSON.parse(jobResult);
+        const results = [];
+        for (const proof of proofs) {
+          const { success, tx, hash, error } = JSON.parse(proof);
+          results.push({ success, tx, hash, error });
+        }
+        return { success: true, results, jobStatus };
+      } catch (e) {
+        return {
+          success: false,
+          error: `Error parsing job result: ${jobResult} ${e?.message ?? ""}`,
+          jobStatus
+        };
+      }
+    } catch (e) {
+      return {
+        success: false,
+        error: `Error getting job result: ${e?.message ?? ""}`,
+        jobStatus: void 0
+      };
+    }
+  }
+};
+
+// dist/node/tokens/nft.js
+var NftAPI = 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 proveTransaction(params) {
+    return this.proveTransactions([params]);
+  }
+  async proveTransactions(params, name) {
+    const transactions = [];
+    for (const tx of params) {
+      const transaction = JSON.stringify(tx, null, 2);
+      transactions.push(transaction);
+    }
+    const { request, symbol } = params[0];
+    const { txType } = request;
+    const answer = await this.client.execute({
+      developer: "DFST",
+      repo: "nft-agent",
+      transactions,
+      task: "prove",
+      args: JSON.stringify({
+        collectionAddress: params[0].request.collectionAddress
+      }),
+      metadata: `${params.length > 1 ? "mint" : txType.replace(/^nft:/, "")} ${symbol ? ` ${symbol}` : ""} ${params.length > 1 ? `(${params.length} txs)` : txType === "nft:launch" ? "Collection " + request.collectionName : txType === "nft:mint" ? request.nftMintParams.name : name ?? ""}`
+    });
+    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 getResults instead
+  async waitForJobResults(params) {
+    const deployResult = await this.client.waitForJobResult(params);
+    console.log("waitForJobResult result:", deployResult?.result?.result?.slice(0, 50));
+    return deployResult?.result?.result ?? "error";
+  }
+  async getResults(jobId) {
+    try {
+      const callResult = await this.client.jobResult({ jobId });
+      const jobStatus = typeof callResult?.result === "string" ? void 0 : callResult?.result?.jobStatus;
+      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 { proofs } = JSON.parse(jobResult);
+        const results = [];
+        for (const proof of proofs) {
+          const { success, tx, hash, error } = JSON.parse(proof);
+          results.push({ success, tx, hash, error });
+        }
+        return { success: true, results, jobStatus };
+      } catch (e) {
+        return {
+          success: false,
+          error: `Error parsing job result: ${jobResult} ${e?.message ?? ""}`,
+          jobStatus
+        };
+      }
+    } catch (e) {
+      return {
+        success: false,
+        error: `Error getting job result: ${e?.message ?? ""}`,
+        jobStatus: void 0
+      };
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalCloud,
+  LocalStorage,
+  NftAPI,
+  TokenAPI,
+  zkCloudWorkerClient
+});