rocketh 0.10.7 → 0.10.9

package/dist/index.cjs

@@ -1,1349 +1,33 @@
-"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);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  chainById: () => chainById,
-  execute: () => execute,
-  executeDeployScripts: () => executeDeployScripts,
-  extendEnvironment: () => extendEnvironment,
-  getChain: () => getChain,
-  getGasPriceEstimate: () => getGasPriceEstimate,
-  getRoughGasPriceEstimate: () => getRoughGasPriceEstimate,
-  handleSignerProtocol: () => handleSignerProtocol,
-  loadAndExecuteDeployments: () => loadAndExecuteDeployments,
-  loadDeployments: () => loadDeployments,
-  loadEnvironment: () => loadEnvironment,
-  mergeArtifacts: () => mergeArtifacts,
-  readAndResolveConfig: () => readAndResolveConfig,
-  readConfig: () => readConfig,
-  resolveConfig: () => resolveConfig
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/utils/fs.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-function traverseMultipleDirectory(dirs) {
-  const filepaths = [];
-  for (const dir of dirs) {
-    let filesStats = traverse(dir);
-    filesStats = filesStats.filter((v) => !v.directory);
-    for (const filestat of filesStats) {
-      filepaths.push(import_node_path.default.join(dir, filestat.relativePath));
-    }
-  }
-  return filepaths;
-}
-var traverse = function(dir, result = [], topDir, filter) {
-  import_node_fs.default.readdirSync(dir).forEach((name) => {
-    const fPath = import_node_path.default.resolve(dir, name);
-    const stats = import_node_fs.default.statSync(fPath);
-    if (!filter && !name.startsWith(".") || filter && filter(name, stats)) {
-      const fileStats = {
-        name,
-        path: fPath,
-        relativePath: import_node_path.default.relative(topDir || dir, fPath),
-        mtimeMs: stats.mtimeMs,
-        directory: stats.isDirectory()
-      };
-      if (fileStats.directory) {
-        result.push(fileStats);
-        return traverse(fPath, result, topDir || dir, filter);
-      }
-      result.push(fileStats);
-    }
-  });
-  return result;
-};
-
-// src/executor/index.ts
-var import_node_path4 = __toESM(require("path"), 1);
-var import_node_fs4 = __toESM(require("fs"), 1);
-
-// src/environment/index.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_viem = require("viem");
-var import_eip_1193_jsonrpc_provider = require("eip-1193-jsonrpc-provider");
-var import_node_path3 = __toESM(require("path"), 1);
-
-// src/utils/json.ts
-function bnReplacer(k, v) {
-  if (typeof v === "bigint") {
-    return v.toString() + "n";
-  }
-  return v;
-}
-function bnReviver(k, v) {
-  if (typeof v === "string" && (v.startsWith("-") ? !isNaN(parseInt(v.charAt(1))) : !isNaN(parseInt(v.charAt(0)))) && v.charAt(v.length - 1) === "n") {
-    return BigInt(v.slice(0, -1));
-  }
-  return v;
-}
-function JSONToString(json, space) {
-  return JSON.stringify(json, bnReplacer, space);
-}
-function stringToJSON(str) {
-  return JSON.parse(str, bnReviver);
-}
-
-// src/environment/deployments.ts
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_fs2 = __toESM(require("fs"), 1);
-function loadDeployments(deploymentsPath, networkName, onlyABIAndAddress, expectedChain) {
-  const deploymentsFound = {};
-  const deployPath = import_node_path2.default.join(deploymentsPath, networkName);
-  let filesStats;
-  try {
-    filesStats = traverse(deployPath, void 0, void 0, (name) => !name.startsWith(".") && name !== "solcInputs");
-  } catch (e) {
-    return { deployments: {} };
-  }
-  let chainId;
-  let genesisHash;
-  if (filesStats.length > 0) {
-    const chainIdFilepath = import_node_path2.default.join(deployPath, ".chainId");
-    if (import_node_fs2.default.existsSync(chainIdFilepath)) {
-      chainId = import_node_fs2.default.readFileSync(chainIdFilepath, "utf-8").trim();
-    } else {
-      const chainFilepath = import_node_path2.default.join(deployPath, ".chain");
-      if (import_node_fs2.default.existsSync(chainFilepath)) {
-        const chainSTR = import_node_fs2.default.readFileSync(chainFilepath, "utf-8");
-        const chainData = JSON.parse(chainSTR);
-        chainId = chainData.chainId;
-        genesisHash = chainData.genesisHash;
-      } else {
-        throw new Error(
-          `A '.chain' or '.chainId' file is expected to be present in the deployment folder for network ${networkName}`
-        );
-      }
-    }
-    if (expectedChain) {
-      if (expectedChain.chainId !== chainId) {
-        throw new Error(
-          `Loading deployment in folder '${deployPath}' (with chainId: ${chainId}) for a different chainId (${expectedChain.chainId})`
-        );
-      }
-      if (expectedChain.genesisHash && expectedChain.genesisHash !== genesisHash) {
-        if (expectedChain.deleteDeploymentsIfDifferentGenesisHash) {
-          import_node_fs2.default.rmSync(deployPath, { recursive: true, force: true });
-          return { deployments: {} };
-        } else {
-          throw new Error(
-            `Loading deployment in folder '${deployPath}' (with genesisHash: ${genesisHash}) for a different genesisHash (${expectedChain.genesisHash})`
-          );
-        }
-      }
-    }
-  } else {
-    return { deployments: {} };
-  }
-  let fileNames = filesStats.map((a) => a.relativePath);
-  fileNames = fileNames.sort((a, b) => {
-    if (a < b) {
-      return -1;
-    }
-    if (a > b) {
-      return 1;
-    }
-    return 0;
-  });
-  for (const fileName of fileNames) {
-    if (fileName.substring(fileName.length - 5) === ".json") {
-      const deploymentFileName = import_node_path2.default.join(deployPath, fileName);
-      let deployment = JSON.parse(import_node_fs2.default.readFileSync(deploymentFileName).toString());
-      if (onlyABIAndAddress) {
-        deployment = {
-          address: deployment.address,
-          abi: deployment.abi,
-          linkedData: deployment.linkedData
-        };
-      }
-      const name = fileName.slice(0, fileName.length - 5);
-      deploymentsFound[name] = deployment;
-    }
-  }
-  return { deployments: deploymentsFound, chainId, genesisHash };
-}
-
-// src/internal/logging.ts
-var import_named_logs = require("named-logs");
-var import_named_logs_console = require("named-logs-console");
-(0, import_named_logs_console.hookup)();
-function setLogLevel(level) {
-  import_named_logs_console.factory.level = level;
-  if (import_named_logs_console.factory.level > 0) {
-    import_named_logs_console.factory.enable();
-  } else {
-    import_named_logs_console.factory.disable();
-  }
-}
-var logger = (0, import_named_logs.logs)("rocketh");
-var loggerProgressIndicator = {
-  start(msg) {
-    if (msg) {
-      console.log(msg);
-    }
-    return this;
-  },
-  stop() {
-    return this;
-  },
-  succeed(msg) {
-    if (msg) {
-      console.log(msg);
-    }
-    return this;
-  },
-  fail(msg) {
-    if (msg) {
-      console.error(msg);
-    }
-    return this;
-  }
-};
-var voidProgressIndicator = {
-  start() {
-    return this;
-  },
-  stop() {
-    return this;
-  },
-  succeed() {
-    return this;
-  },
-  fail() {
-    return this;
-  }
-};
-var lastSpin = loggerProgressIndicator;
-function spin(message) {
-  if (import_named_logs_console.factory.level > 0) {
-    lastSpin = lastSpin.start(message);
-    return lastSpin;
-  } else {
-    return voidProgressIndicator;
-  }
-}
-function log(message) {
-  if (import_named_logs_console.factory.level > 0) {
-    console.log(message);
-  }
-}
-
-// src/environment/utils/chains.ts
-var import_chains = __toESM(require("viem/chains"), 1);
-var chainById = {};
-var allChains = import_chains.default.default || import_chains.default;
-for (const key of Object.keys(allChains)) {
-  const chain = allChains[key];
-  chainById[chain.id.toString()] = chain;
-}
-function getChain(id) {
-  const chain = chainById[id];
-  if (!chain) {
-    return {
-      id: parseInt(id),
-      name: "unkwown",
-      // TODO
-      nativeCurrency: {
-        name: "Unknown Currency",
-        symbol: "UNKNOWN",
-        decimals: 18
-      },
-      rpcUrls: {
-        default: {
-          http: []
-        }
-      }
-    };
-  }
-  return chain;
-}
-
-// src/environment/utils/artifacts.ts
-var import_ethers = require("ethers");
-function deepEqual(obj1, obj2) {
-  function isObject(obj) {
-    if (typeof obj === "object" && obj != null) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-  if (obj1 === obj2) {
-    return true;
-  } else if (isObject(obj1) && isObject(obj2)) {
-    if (Object.keys(obj1).length !== Object.keys(obj2).length) {
-      return false;
-    }
-    for (var prop in obj1) {
-      if (!deepEqual(obj1[prop], obj2[prop])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-function mergeDoc(values, mergedDevDocs, field) {
-  if (values[field]) {
-    const mergedEventDocs = mergedDevDocs[field] = mergedDevDocs[field] || {};
-    for (const signature of Object.keys(values[field])) {
-      if (mergedEventDocs[signature] && !deepEqual(mergedEventDocs[signature], values[field][signature])) {
-        throw new Error(`Doc ${field} conflict: "${signature}" `);
-      }
-      mergedEventDocs[signature] = values[field][signature];
-    }
-  }
-}
-function mergeArtifacts(list) {
-  const mergedABI = [];
-  const added = /* @__PURE__ */ new Map();
-  const mergedDevDocs = { kind: "dev", version: 1, methods: {} };
-  const mergedUserDocs = { kind: "user", version: 1, methods: {} };
-  const sigJSMap = /* @__PURE__ */ new Map();
-  for (let i = 0; i < list.length; i++) {
-    const listElem = list[i];
-    for (const element of listElem.artifact.abi) {
-      if (element.type === "function") {
-        const selector = import_ethers.FunctionFragment.from(element).selector;
-        if (sigJSMap.has(selector)) {
-          const existing = sigJSMap.get(selector);
-          throw new Error(
-            `ABI conflict: ${existing.routeName} has function "${existing.functionName}" which conflict with ${listElem.name}'s "${element.name}" (selector: "${selector}")  `
-          );
-        }
-        sigJSMap.set(selector, { index: i, routeName: listElem.name, functionName: element.name });
-        const exists = added.has(element.name);
-        if (exists) {
-        } else {
-          added.set(element.name, element);
-          mergedABI.push(element);
-        }
-      } else if (element.type === "constructor") {
-      } else if (element.type === "error") {
-        const exists = added.has(element.name);
-        if (exists) {
-        } else {
-          added.set(element.name, element);
-          mergedABI.push(element);
-        }
-      } else if (element.type === "event") {
-        const exists = added.has(element.name);
-        if (exists) {
-        } else {
-          added.set(element.name, element);
-          mergedABI.push(element);
-        }
-      } else if (element.type === "fallback") {
-      } else if (element.type === "receive") {
-      } else {
-      }
-    }
-    const devdoc = listElem.artifact.devdoc;
-    if (devdoc) {
-      mergeDoc(devdoc, mergedDevDocs, "events");
-      mergeDoc(devdoc, mergedDevDocs, "errors");
-      mergeDoc(devdoc, mergedDevDocs, "methods");
-      if (devdoc.author) {
-        if (mergedDevDocs.author && mergedDevDocs.author != devdoc.author) {
-          throw new Error(`DevDoc author conflict `);
-        }
-        mergedDevDocs.author = devdoc.author;
-        if (mergedDevDocs.title && mergedDevDocs.title != devdoc.title) {
-          throw new Error(`DevDoc title conflict `);
-        }
-        mergedDevDocs.title = devdoc.title;
-      }
-    }
-    const userdoc = listElem.artifact.userdoc;
-    if (userdoc) {
-      mergeDoc(userdoc, mergedUserDocs, "events");
-      mergeDoc(userdoc, mergedUserDocs, "errors");
-      mergeDoc(userdoc, mergedUserDocs, "methods");
-      if (userdoc.notice) {
-        if (mergedUserDocs.notice && mergedUserDocs.notice != userdoc.notice) {
-          throw new Error(`UserDoc notice conflict `);
-        }
-        mergedUserDocs.notice = userdoc.notice;
-      }
-    }
-  }
-  return {
-    mergedABI,
-    added,
-    mergedDevDocs,
-    mergedUserDocs,
-    sigJSMap
-  };
-}
-
-// src/environment/providers/BaseProvider.ts
-var BaseProvider = class {
-  constructor(provider) {
-    this.provider = provider;
-  }
-  request(args) {
-    return this._request(args);
-  }
-};
-
-// src/environment/providers/TransactionHashTracker.ts
-var TransactionHashTracker = class extends BaseProvider {
-  constructor(provider) {
-    super(provider);
-    this.transactionHashes = [];
-  }
-  async _request(args) {
-    let response;
-    try {
-      response = await this.provider.request(args);
-    } catch (err) {
-      console.error(`failed to execute ${args.method}`, args);
-      throw err;
-    }
-    if (args.method === "eth_sendRawTransaction" || args.method === "eth_sendTransaction") {
-      this.transactionHashes.push(response);
-    }
-    return response;
-  }
-};
-
-// src/environment/index.ts
-globalThis.extensions = [];
-function extendEnvironment(extension) {
-  globalThis.extensions.push(extension);
-}
-globalThis.signerProtocols = {};
-function handleSignerProtocol(protocol, getSigner) {
-  globalThis.signerProtocols[protocol] = {
-    getSigner
-  };
-}
-function wait(numSeconds) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, numSeconds * 1e3);
-  });
-}
-function displayTransaction(transaction) {
-  if (transaction.type === "0x2") {
-    return `(maxFeePerGas: ${BigInt(transaction.maxFeePerGas).toString()}, maxPriorityFeePerGas: ${BigInt(
-      transaction.maxPriorityFeePerGas
-    ).toString()})`;
-  } else {
-    return `(gasPrice: ${BigInt(transaction.gasPrice).toString()})`;
-  }
-}
-async function createEnvironment(config, providedContext) {
-  const rawProvider = "provider" in config.network ? config.network.provider : new import_eip_1193_jsonrpc_provider.JSONRPCHTTPProvider(config.network.nodeUrl);
-  const provider = new TransactionHashTracker(rawProvider);
-  const transport = (0, import_viem.custom)(provider);
-  const viemClient = (0, import_viem.createPublicClient)({ transport });
-  const chainId = (await viemClient.getChainId()).toString();
-  let genesisHash;
-  try {
-    genesisHash = (await viemClient.getBlock({ blockTag: "earliest" })).hash;
-  } catch (err) {
-    console.error(`failed to get genesis hash`);
-  }
-  let networkName;
-  let saveDeployments;
-  let networkTags = {};
-  for (const networkTag of config.network.tags) {
-    networkTags[networkTag] = true;
-  }
-  if ("nodeUrl" in config) {
-    networkName = config.network.name;
-    saveDeployments = true;
-  } else {
-    if (config.network.name) {
-      networkName = config.network.name;
-    } else {
-      networkName = "memory";
-    }
-    if (networkName === "memory" || networkName === "hardhat") {
-      networkTags["memory"] = true;
-      saveDeployments = false;
-    } else {
-      saveDeployments = true;
-    }
-  }
-  if (config.saveDeployments !== void 0) {
-    saveDeployments = config.saveDeployments;
-  }
-  const resolvedAccounts = {};
-  const accountCache = {};
-  async function getAccount(name, accounts, accountDef) {
-    if (accountCache[name]) {
-      return accountCache[name];
-    }
-    let account;
-    if (typeof accountDef === "number") {
-      const accounts2 = await provider.request({ method: "eth_accounts" });
-      const accountPerIndex = accounts2[accountDef];
-      if (accountPerIndex) {
-        accountCache[name] = account = {
-          type: "remote",
-          address: accountPerIndex,
-          signer: provider
-        };
-      }
-    } else if (typeof accountDef === "string") {
-      if (accountDef.startsWith("0x")) {
-        if (accountDef.length === 66) {
-          const privateKeyProtocol = globalThis.signerProtocols["privateKey"];
-          if (privateKeyProtocol) {
-            const namedSigner = await privateKeyProtocol.getSigner(`privateKey:${accountDef}`);
-            const [address] = await namedSigner.signer.request({ method: "eth_accounts" });
-            accountCache[name] = account = {
-              ...namedSigner,
-              address
-            };
-          }
-        } else {
-          accountCache[name] = account = {
-            type: "remote",
-            address: accountDef,
-            signer: provider
-          };
-        }
-      } else {
-        if (accountDef.indexOf(":") > 0) {
-          const [protocolID, extra] = accountDef.split(":");
-          const protocol = globalThis.signerProtocols[protocolID];
-          if (!protocol) {
-            throw new Error(`protocol: ${protocol} is not supported`);
-          }
-          const namedSigner = await protocol.getSigner(accountDef);
-          const [address] = await namedSigner.signer.request({ method: "eth_accounts" });
-          accountCache[name] = account = {
-            ...namedSigner,
-            address
-          };
-        } else {
-          const accountFetched = await getAccount(name, accounts, accounts[accountDef]);
-          if (accountFetched) {
-            accountCache[name] = account = accountFetched;
-          }
-        }
-      }
-    } else {
-      const accountForNetwork = accountDef[networkName] || accountDef[chainId] || accountDef["default"];
-      if (typeof accountForNetwork !== void 0) {
-        const accountFetched = await getAccount(name, accounts, accountForNetwork);
-        if (accountFetched) {
-          accountCache[name] = account = accountFetched;
-        }
-      }
-    }
-    return account;
-  }
-  if (providedContext.accounts) {
-    const accountNames = Object.keys(providedContext.accounts);
-    for (const accountName of accountNames) {
-      let account = await getAccount(accountName, providedContext.accounts, providedContext.accounts[accountName]);
-      resolvedAccounts[accountName] = account;
-    }
-  }
-  const context = {
-    accounts: resolvedAccounts,
-    artifacts: providedContext.artifacts,
-    network: {
-      name: networkName,
-      fork: config.network.fork,
-      saveDeployments,
-      tags: networkTags
-    }
-  };
-  const { deployments } = loadDeployments(
-    config.deployments,
-    context.network.name,
-    false,
-    context.network.fork ? void 0 : {
-      chainId,
-      genesisHash,
-      deleteDeploymentsIfDifferentGenesisHash: true
-    }
-  );
-  const namedAccounts = {};
-  const namedSigners = {};
-  const addressSigners = {};
-  for (const entry of Object.entries(resolvedAccounts)) {
-    const name = entry[0];
-    const { address, ...namedSigner } = entry[1];
-    namedAccounts[name] = address;
-    addressSigners[address] = namedSigner;
-    namedSigners[name] = namedSigner;
-  }
-  const perliminaryEnvironment = {
-    config,
-    deployments,
-    accounts: namedAccounts,
-    signers: namedSigners,
-    addressSigners,
-    artifacts: context.artifacts,
-    network: {
-      chain: getChain(chainId),
-      name: context.network.name,
-      tags: context.network.tags,
-      provider
-    }
-  };
-  function ensureDeploymentFolder() {
-    const folderPath = import_node_path3.default.join(config.deployments, context.network.name);
-    import_node_fs3.default.mkdirSync(folderPath, { recursive: true });
-    const chainFilepath = import_node_path3.default.join(folderPath, ".chain");
-    if (!import_node_fs3.default.existsSync(chainFilepath)) {
-      import_node_fs3.default.writeFileSync(chainFilepath, JSON.stringify({ chainId, genesisHash }));
-    }
-    return folderPath;
-  }
-  function get(name) {
-    const deployment = deployments[name];
-    if (!deployment) {
-      throw new Error(`no deployment named "${name}" found.`);
-    }
-    return deployment;
-  }
-  function getOrNull(name) {
-    return deployments[name] || null;
-  }
-  function fromAddressToNamedABIOrNull(address) {
-    let list = [];
-    for (const name of Object.keys(deployments)) {
-      const deployment = deployments[name];
-      if (deployment.address.toLowerCase() == address.toLowerCase()) {
-        list.push({ name, artifact: deployment });
-      }
-    }
-    if (list.length === 0) {
-      return null;
-    }
-    const { mergedABI } = mergeArtifacts(list);
-    return {
-      mergedABI,
-      names: list.map((v) => v.name)
-    };
-  }
-  function fromAddressToNamedABI(address) {
-    const n = fromAddressToNamedABIOrNull(address);
-    if (!n) {
-      throw new Error(`could not find artifact for address ${address}`);
-    }
-    return n;
-  }
-  async function save(name, deployment) {
-    deployments[name] = deployment;
-    if (context.network.saveDeployments) {
-      const folderPath = ensureDeploymentFolder();
-      import_node_fs3.default.writeFileSync(`${folderPath}/${name}.json`, JSONToString(deployment, 2));
-    }
-    return deployment;
-  }
-  async function recoverTransactionsIfAny() {
-    if (!context.network.saveDeployments) {
-      return;
-    }
-    const folderPath = ensureDeploymentFolder();
-    const filepath = import_node_path3.default.join(folderPath, ".pending_transactions.json");
-    let existingPendingTansactions;
-    try {
-      existingPendingTansactions = stringToJSON(import_node_fs3.default.readFileSync(filepath, "utf-8"));
-    } catch {
-      existingPendingTansactions = [];
-    }
-    if (existingPendingTansactions.length > 0) {
-      while (existingPendingTansactions.length > 0) {
-        const pendingTransaction = existingPendingTansactions.shift();
-        if (pendingTransaction) {
-          if (pendingTransaction.type === "deployment") {
-            const spinner = spin(
-              `recovering ${pendingTransaction.name} with transaction ${pendingTransaction.transaction.hash}`
-            );
-            try {
-              await waitForDeploymentTransactionAndSave(pendingTransaction);
-              import_node_fs3.default.writeFileSync(filepath, JSONToString(existingPendingTansactions, 2));
-              spinner.succeed();
-            } catch (e) {
-              spinner.fail();
-              throw e;
-            }
-          } else {
-            const spinner = spin(`recovering execution's transaction ${pendingTransaction.transaction.hash}`);
-            try {
-              await waitForTransaction(pendingTransaction.transaction.hash);
-              import_node_fs3.default.writeFileSync(filepath, JSONToString(existingPendingTansactions, 2));
-              spinner.succeed();
-            } catch (e) {
-              spinner.fail();
-              throw e;
-            }
-          }
-        }
-      }
-      import_node_fs3.default.rmSync(filepath);
-    }
-  }
-  async function savePendingTransaction(pendingTransaction) {
-    if (context.network.saveDeployments) {
-      const folderPath = ensureDeploymentFolder();
-      const filepath = import_node_path3.default.join(folderPath, ".pending_transactions.json");
-      let existingPendinTransactions;
-      try {
-        existingPendinTransactions = stringToJSON(import_node_fs3.default.readFileSync(filepath, "utf-8"));
-      } catch {
-        existingPendinTransactions = [];
-      }
-      existingPendinTransactions.push(pendingTransaction);
-      import_node_fs3.default.writeFileSync(filepath, JSONToString(existingPendinTransactions, 2));
-    }
-    return deployments;
-  }
-  async function waitForTransactionReceipt(params) {
-    const { hash, pollingInterval } = { pollingInterval: 1, ...params };
-    let latestBlockNumber = await provider.request({
-      method: "eth_blockNumber"
-    });
-    let receipt = await provider.request({
-      method: "eth_getTransactionReceipt",
-      params: [hash]
-    });
-    if (!receipt || !receipt.blockHash) {
-      await wait(pollingInterval);
-      return waitForTransactionReceipt(params);
-    }
-    return { receipt, latestBlockNumber };
-  }
-  async function deleteTransaction(hash) {
-    if (context.network.saveDeployments) {
-      const folderPath = ensureDeploymentFolder();
-      const filepath = import_node_path3.default.join(folderPath, ".pending_transactions.json");
-      let existingPendinTransactions;
-      try {
-        existingPendinTransactions = stringToJSON(import_node_fs3.default.readFileSync(filepath, "utf-8"));
-      } catch {
-        existingPendinTransactions = [];
-      }
-      existingPendinTransactions = existingPendinTransactions.filter((v) => v.transaction.hash !== hash);
-      if (existingPendinTransactions.length === 0) {
-        import_node_fs3.default.rmSync(filepath);
-      } else {
-        import_node_fs3.default.writeFileSync(filepath, JSONToString(existingPendinTransactions, 2));
-      }
-    }
-  }
-  async function exportDeploymentsAsTypes() {
-    const folderPath = "./generated";
-    import_node_fs3.default.mkdirSync(folderPath, { recursive: true });
-    import_node_fs3.default.writeFileSync(`${folderPath}/deployments.ts`, `export default ${JSONToString(deployments, 2)} as const;`);
-  }
-  async function waitForTransaction(hash, info) {
-    const spinner = spin(
-      info?.message ? info.message : `  - Broadcasting tx:
-      ${hash}${info?.transaction ? `
-      ${displayTransaction(info?.transaction)}` : ""}`
-    );
-    let receiptResult;
-    try {
-      receiptResult = await waitForTransactionReceipt({
-        hash
-      });
-    } catch (e) {
-      spinner.fail();
-      throw e;
-    }
-    if (!receiptResult) {
-      throw new Error(`receipt for ${hash} not found`);
-    } else {
-      spinner.succeed();
-    }
-    return receiptResult;
-  }
-  async function waitForDeploymentTransactionAndSave(pendingDeployment, transaction) {
-    const message = `  - Deploying ${pendingDeployment.name} with tx:
-      ${pendingDeployment.transaction.hash}${transaction ? `
-      ${displayTransaction(transaction)}` : ""}`;
-    const { receipt, latestBlockNumber } = await waitForTransaction(pendingDeployment.transaction.hash, {
-      message,
-      transaction
-    });
-    const contractAddress = pendingDeployment.expectedAddress || receipt.contractAddress;
-    if (!contractAddress) {
-      console.error(receipt);
-      throw new Error(`no contract address found for ${pendingDeployment.name}`);
-    }
-    showMessage(`    => ${contractAddress}`);
-    const { abi, ...artifactObjectWithoutABI } = pendingDeployment.partialDeployment;
-    if (!pendingDeployment.transaction.hash) {
-      const spinner = spin();
-      let transaction2 = null;
-      try {
-        transaction2 = await provider.request({
-          method: "eth_getTransactionByHash",
-          params: [pendingDeployment.transaction.hash]
-        });
-      } catch (e) {
-        spinner.fail();
-        throw e;
-      }
-      if (!transaction2) {
-        spinner.fail(`tx ${pendingDeployment.transaction.hash} not found`);
-      } else {
-        spinner.stop();
-      }
-      if (transaction2) {
-        pendingDeployment.transaction = {
-          nonce: transaction2.nonce,
-          hash: transaction2.hash,
-          origin: transaction2.from
-        };
-      }
-    }
-    for (const key of Object.keys(artifactObjectWithoutABI)) {
-      if (key.startsWith("_")) {
-        delete artifactObjectWithoutABI[key];
-      }
-      if (key === "evm") {
-        if (artifactObjectWithoutABI.evm) {
-          if ("gasEstimates" in artifactObjectWithoutABI["evm"]) {
-            const { gasEstimates } = artifactObjectWithoutABI.evm;
-            artifactObjectWithoutABI.evm = {
-              gasEstimates
-            };
-          }
-        }
-      }
-    }
-    const latestBlockNumberAsNumber = parseInt(latestBlockNumber.slice(2), 16);
-    const receiptBlockNumber = parseInt(receipt.blockNumber.slice(2), 16);
-    const confirmations = Math.max(0, latestBlockNumberAsNumber - receiptBlockNumber);
-    const deployment = {
-      address: contractAddress,
-      abi,
-      ...artifactObjectWithoutABI,
-      transaction: pendingDeployment.transaction,
-      receipt: {
-        confirmations,
-        blockHash: receipt.blockHash,
-        blockNumber: receipt.blockNumber,
-        transactionIndex: receipt.transactionIndex
-      }
-    };
-    return save(pendingDeployment.name, deployment);
-  }
-  async function savePendingExecution(pendingExecution) {
-    await savePendingTransaction(pendingExecution);
-    let transaction = null;
-    const spinner = spin();
-    try {
-      transaction = await provider.request({
-        method: "eth_getTransactionByHash",
-        params: [pendingExecution.transaction.hash]
-      });
-    } catch (e) {
-      spinner.fail();
-      throw e;
-    }
-    if (!transaction) {
-      spinner.fail(`tx ${pendingExecution.transaction.hash} not found`);
-    } else {
-      spinner.stop();
-    }
-    if (transaction) {
-      pendingExecution.transaction.nonce = transaction.nonce;
-      pendingExecution.transaction.origin = transaction.from;
-    }
-    const { receipt } = await waitForTransaction(pendingExecution.transaction.hash, { transaction });
-    await deleteTransaction(pendingExecution.transaction.hash);
-    return receipt;
-  }
-  async function savePendingDeployment(pendingDeployment) {
-    await savePendingTransaction(pendingDeployment);
-    let transaction = null;
-    const spinner = spin();
-    try {
-      transaction = await provider.request({
-        method: "eth_getTransactionByHash",
-        params: [pendingDeployment.transaction.hash]
-      });
-    } catch (e) {
-      console.error(`failed to fetch tx ${pendingDeployment.transaction.hash}. Can't know its status`);
-      spinner.fail();
-      throw e;
-    }
-    if (!transaction) {
-      spinner.fail(`tx ${pendingDeployment.transaction.hash} not found`);
-    } else {
-      spinner.stop();
-    }
-    if (transaction) {
-      pendingDeployment = {
-        ...pendingDeployment,
-        transaction: { hash: transaction.hash, nonce: transaction.nonce, origin: transaction.from }
-      };
-    }
-    const deployment = await waitForDeploymentTransactionAndSave(pendingDeployment, transaction);
-    await deleteTransaction(pendingDeployment.transaction.hash);
-    return deployment;
-  }
-  function showMessage(message) {
-    log(message);
-  }
-  function showProgress(message) {
-    return spin(message);
-  }
-  let env = {
-    ...perliminaryEnvironment,
-    save,
-    savePendingDeployment,
-    savePendingExecution,
-    get,
-    getOrNull,
-    fromAddressToNamedABI,
-    fromAddressToNamedABIOrNull,
-    showMessage,
-    showProgress
-  };
-  for (const extension of globalThis.extensions) {
-    env = extension(env);
-  }
-  return {
-    external: env,
-    internal: {
-      exportDeploymentsAsTypes,
-      recoverTransactionsIfAny
-    }
-  };
-}
-
-// src/utils/eth.ts
-function avg(arr) {
-  const sum = arr.reduce((a, v) => a + v);
-  return sum / BigInt(arr.length);
-}
-async function getGasPriceEstimate(provider, options) {
-  const defaultOptions = {
-    blockCount: 20,
-    newestBlock: "pending",
-    rewardPercentiles: [10, 50, 80]
-  };
-  const optionsResolved = options ? { ...defaultOptions, ...options } : defaultOptions;
-  const historicalBlocks = optionsResolved.blockCount;
-  const rawFeeHistory = await provider.request({
-    method: "eth_feeHistory",
-    params: [`0x${historicalBlocks.toString(16)}`, optionsResolved.newestBlock, optionsResolved.rewardPercentiles]
-  });
-  let blockNum = Number(rawFeeHistory.oldestBlock);
-  const lastBlock = blockNum + rawFeeHistory.reward.length;
-  let index = 0;
-  const blocksHistory = [];
-  while (blockNum < lastBlock) {
-    blocksHistory.push({
-      number: blockNum,
-      baseFeePerGas: BigInt(rawFeeHistory.baseFeePerGas[index]),
-      gasUsedRatio: Number(rawFeeHistory.gasUsedRatio[index]),
-      priorityFeePerGas: rawFeeHistory.reward[index].map((x) => BigInt(x))
-    });
-    blockNum += 1;
-    index += 1;
-  }
-  const percentilePriorityFeeAverages = [];
-  for (let i = 0; i < optionsResolved.rewardPercentiles.length; i++) {
-    percentilePriorityFeeAverages.push(avg(blocksHistory.map((b) => b.priorityFeePerGas[i])));
-  }
-  const baseFeePerGas = BigInt(rawFeeHistory.baseFeePerGas[rawFeeHistory.baseFeePerGas.length - 1]);
-  const result = [];
-  for (let i = 0; i < optionsResolved.rewardPercentiles.length; i++) {
-    result.push({
-      maxFeePerGas: percentilePriorityFeeAverages[i] + baseFeePerGas,
-      maxPriorityFeePerGas: percentilePriorityFeeAverages[i]
-    });
-  }
-  return result;
-}
-async function getRoughGasPriceEstimate(provider, options) {
-  const defaultOptions = {
-    blockCount: 20,
-    newestBlock: "pending",
-    rewardPercentiles: [10, 50, 80]
-  };
-  const optionsResolved = options ? { ...defaultOptions, ...options } : defaultOptions;
-  if (optionsResolved.rewardPercentiles.length !== 3) {
-    throw new Error(`rough gas estimate require 3 percentile, it defaults to [10,50,80]`);
-  }
-  const result = await getGasPriceEstimate(provider, optionsResolved);
-  return {
-    slow: result[0],
-    average: result[1],
-    fast: result[2]
-  };
-}
-
-// src/executor/index.ts
-var import_prompts = __toESM(require("prompts"), 1);
-var import_viem2 = require("viem");
-if (!process.env["ROCKETH_SKIP_ESBUILD"]) {
-  require("esbuild-register/dist/node").register();
-}
-function execute(context, callback, options) {
-  const scriptModule = (env, args) => callback(env, args);
-  scriptModule.providedContext = context;
-  scriptModule.tags = options.tags;
-  scriptModule.dependencies = options.dependencies;
-  return scriptModule;
-}
-function readConfig(options) {
-  let configFile;
-  try {
-    const configString = import_node_fs4.default.readFileSync("./rocketh.json", "utf-8");
-    configFile = JSON.parse(configString);
-  } catch {
-  }
-  if (configFile) {
-    if (!options.deployments && configFile.deployments) {
-      options.deployments = configFile.deployments;
-    }
-    if (!options.scripts && configFile.scripts) {
-      options.scripts = configFile.scripts;
-    }
-  }
-  const fromEnv = process.env["ETH_NODE_URI_" + options.network];
-  const fork = typeof options.network !== "string";
-  let networkName = "memory";
-  if (options.network) {
-    if (typeof options.network === "string") {
-      networkName = options.network;
-    } else if ("fork" in options.network) {
-      networkName = options.network.fork;
-    }
-  }
-  let networkTags = configFile?.networks && configFile?.networks[networkName]?.tags || [];
-  if (!options.provider) {
-    let nodeUrl;
-    if (typeof fromEnv === "string") {
-      nodeUrl = fromEnv;
-    } else {
-      if (configFile) {
-        const network = configFile.networks && configFile.networks[networkName];
-        if (network && network.rpcUrl) {
-          nodeUrl = network.rpcUrl;
-        } else {
-          if (options?.ignoreMissingRPC) {
-            nodeUrl = "";
-          } else {
-            if (options.network === "localhost") {
-              nodeUrl = "http://127.0.0.1:8545";
-            } else {
-              logger.error(`network "${options.network}" is not configured. Please add it to the rocketh.json file`);
-              process.exit(1);
-            }
-          }
-        }
-      } else {
-        if (options?.ignoreMissingRPC) {
-          nodeUrl = "";
-        } else {
-          if (options.network === "localhost") {
-            nodeUrl = "http://127.0.0.1:8545";
-          } else {
-            logger.error(`network "${options.network}" is not configured. Please add it to the rocketh.json file`);
-            process.exit(1);
-          }
-        }
-      }
-    }
-    return {
-      network: {
-        nodeUrl,
-        name: networkName,
-        tags: networkTags,
-        fork
-      },
-      deployments: options.deployments,
-      saveDeployments: options.saveDeployments,
-      scripts: options.scripts,
-      tags: typeof options.tags === "undefined" ? void 0 : options.tags.split(","),
-      logLevel: options.logLevel,
-      askBeforeProceeding: options.askBeforeProceeding,
-      reportGasUse: options.reportGasUse
-    };
-  } else {
-    return {
-      network: {
-        provider: options.provider,
-        name: networkName,
-        tags: networkTags,
-        fork
-      },
-      deployments: options.deployments,
-      saveDeployments: options.saveDeployments,
-      scripts: options.scripts,
-      tags: typeof options.tags === "undefined" ? void 0 : options.tags.split(","),
-      logLevel: options.logLevel,
-      askBeforeProceeding: options.askBeforeProceeding,
-      reportGasUse: options.reportGasUse
-    };
-  }
-}
-function readAndResolveConfig(options) {
-  return resolveConfig(readConfig(options));
-}
-function resolveConfig(config) {
-  const resolvedConfig = {
-    ...config,
-    network: config.network,
-    // TODO default to || {name: 'memory'....}
-    deployments: config.deployments || "deployments",
-    scripts: config.scripts || "deploy",
-    tags: config.tags || [],
-    networkTags: config.networkTags || [],
-    saveDeployments: config.saveDeployments
-  };
-  return resolvedConfig;
-}
-async function loadEnvironment(options, context) {
-  const resolvedConfig = readAndResolveConfig(options);
-  const { external, internal } = await createEnvironment(resolvedConfig, context);
-  return external;
-}
-async function loadAndExecuteDeployments(options, args) {
-  const resolvedConfig = readAndResolveConfig(options);
-  return executeDeployScripts(resolvedConfig, args);
-}
-async function executeDeployScripts(config, args) {
-  setLogLevel(typeof config.logLevel === "undefined" ? 0 : config.logLevel);
-  let filepaths;
-  filepaths = traverseMultipleDirectory([config.scripts]);
-  filepaths = filepaths.filter((v) => !import_node_path4.default.basename(v).startsWith("_")).sort((a, b) => {
-    if (a < b) {
-      return -1;
-    }
-    if (a > b) {
-      return 1;
-    }
-    return 0;
-  });
-  let providedContext;
-  const scriptModuleByFilePath = {};
-  const scriptPathBags = {};
-  const scriptFilePaths = [];
-  for (const filepath of filepaths) {
-    const scriptFilePath = import_node_path4.default.resolve(filepath);
-    let scriptModule;
-    try {
-      if (require.cache) {
-        delete require.cache[scriptFilePath];
-      }
-      scriptModule = require(scriptFilePath);
-      if (scriptModule.default) {
-        scriptModule = scriptModule.default;
-        if (scriptModule.default) {
-          logger.warn(`double default...`);
-          scriptModule = scriptModule.default;
-        }
-      }
-      scriptModuleByFilePath[scriptFilePath] = scriptModule;
-      if (providedContext && providedContext !== scriptModule.providedContext) {
-        throw new Error(`context between 2 scripts is different, please share the same across them`);
-      }
-      providedContext = scriptModule.providedContext;
-    } catch (e) {
-      logger.error(`could not import ${filepath}`);
-      throw e;
-    }
-    let scriptTags = scriptModule.tags;
-    if (scriptTags !== void 0) {
-      if (typeof scriptTags === "string") {
-        scriptTags = [scriptTags];
-      }
-      for (const tag of scriptTags) {
-        if (tag.indexOf(",") >= 0) {
-          throw new Error("Tag cannot contains commas");
-        }
-        const bag = scriptPathBags[tag] || [];
-        scriptPathBags[tag] = bag;
-        bag.push(scriptFilePath);
-      }
-    }
-    if (config.tags !== void 0 && config.tags.length > 0) {
-      let found = false;
-      if (scriptTags !== void 0) {
-        for (const tagToFind of config.tags) {
-          for (const tag of scriptTags) {
-            if (tag === tagToFind) {
-              scriptFilePaths.push(scriptFilePath);
-              found = true;
-              break;
-            }
-          }
-          if (found) {
-            break;
-          }
-        }
-      }
-    } else {
-      scriptFilePaths.push(scriptFilePath);
-    }
-  }
-  if (!providedContext) {
-    throw new Error(`no context loaded`);
-  }
-  const { internal, external } = await createEnvironment(config, providedContext);
-  await internal.recoverTransactionsIfAny();
-  const scriptsRegisteredToRun = {};
-  const scriptsToRun = [];
-  const scriptsToRunAtTheEnd = [];
-  function recurseDependencies(scriptFilePath) {
-    if (scriptsRegisteredToRun[scriptFilePath]) {
-      return;
-    }
-    const scriptModule = scriptModuleByFilePath[scriptFilePath];
-    if (scriptModule.dependencies) {
-      for (const dependency of scriptModule.dependencies) {
-        const scriptFilePathsToAdd = scriptPathBags[dependency];
-        if (scriptFilePathsToAdd) {
-          for (const scriptFilenameToAdd of scriptFilePathsToAdd) {
-            recurseDependencies(scriptFilenameToAdd);
-          }
-        }
-      }
-    }
-    if (!scriptsRegisteredToRun[scriptFilePath]) {
-      if (scriptModule.runAtTheEnd) {
-        scriptsToRunAtTheEnd.push({
-          filePath: scriptFilePath,
-          func: scriptModule
-        });
-      } else {
-        scriptsToRun.push({
-          filePath: scriptFilePath,
-          func: scriptModule
-        });
-      }
-      scriptsRegisteredToRun[scriptFilePath] = true;
-    }
-  }
-  for (const scriptFilePath of scriptFilePaths) {
-    recurseDependencies(scriptFilePath);
-  }
-  if (config.askBeforeProceeding) {
-    console.log(
-      `Network: ${external.network.name} 
- 	 Chain: ${external.network.chain.name} 
- 	 Tags: ${Object.keys(
-        external.network.tags
-      ).join("',")}`
-    );
-    const gasPriceEstimate = await getRoughGasPriceEstimate(external.network.provider);
-    const prompt = await (0, import_prompts.default)({
-      type: "confirm",
-      name: "proceed",
-      message: `gas price is currently in this range:
-slow: ${(0, import_viem2.formatEther)(gasPriceEstimate.slow.maxFeePerGas)} (priority: ${(0, import_viem2.formatEther)(
-        gasPriceEstimate.slow.maxPriorityFeePerGas
-      )})
-average: ${(0, import_viem2.formatEther)(gasPriceEstimate.average.maxFeePerGas)} (priority: ${(0, import_viem2.formatEther)(
-        gasPriceEstimate.average.maxPriorityFeePerGas
-      )})
-fast: ${(0, import_viem2.formatEther)(gasPriceEstimate.fast.maxFeePerGas)} (priority: ${(0, import_viem2.formatEther)(
-        gasPriceEstimate.fast.maxPriorityFeePerGas
-      )})
- 
-Do you want to proceed (note that gas price can change for each tx)`
-    });
-    if (!prompt.proceed) {
-      process.exit();
-    }
-  }
-  for (const deployScript of scriptsToRun.concat(scriptsToRunAtTheEnd)) {
-    const filename = import_node_path4.default.basename(deployScript.filePath);
-    const relativeFilepath = import_node_path4.default.relative(".", deployScript.filePath);
-    let skip = false;
-    const spinner = spin(`- Executing ${filename}`);
-    if (deployScript.func.skip) {
-      const spinner2 = spin(`  - skip?()`);
-      try {
-        skip = await deployScript.func.skip(external, args);
-        spinner2.succeed(skip ? `skipping ${filename}` : void 0);
-      } catch (e) {
-        spinner2.fail();
-        throw e;
-      }
-    }
-    if (!skip) {
-      let result;
-      try {
-        result = await deployScript.func(external, args);
-        spinner.succeed(`
-`);
-      } catch (e) {
-        spinner.fail();
-        throw e;
-      }
-      if (result && typeof result === "boolean") {
-        const deploymentFolderPath = config.deployments;
-      }
-    }
-  }
-  if (config.reportGasUse) {
-    const provider = external.network.provider;
-    const transactionHashes = provider.transactionHashes;
-    let totalGasUsed = 0;
-    for (const hash of transactionHashes) {
-      const transactionReceipt = await provider.request({ method: "eth_getTransactionReceipt", params: [hash] });
-      if (transactionReceipt) {
-        const gasUsed = Number(transactionReceipt.gasUsed);
-        totalGasUsed += gasUsed;
-      }
-    }
-    console.log({ totalGasUsed });
-  }
-  return external;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  chainById,
-  execute,
-  executeDeployScripts,
-  extendEnvironment,
-  getChain,
-  getGasPriceEstimate,
-  getRoughGasPriceEstimate,
-  handleSignerProtocol,
-  loadAndExecuteDeployments,
-  loadDeployments,
-  loadEnvironment,
-  mergeArtifacts,
-  readAndResolveConfig,
-  readConfig,
-  resolveConfig
-});
-//# sourceMappingURL=index.cjs.map
+'use strict';
+
+var index = require('./index-BJlVmvtt.cjs');
+require('module');
+require('node:fs');
+require('node:path');
+require('viem');
+require('eip-1193-jsonrpc-provider');
+require('named-logs');
+require('named-logs-console');
+require('viem/chains');
+require('ethers');
+require('prompts');
+
+
+
+exports.chainById = index.chainById;
+exports.chainTypes = index.chainTypes;
+exports.execute = index.execute;
+exports.executeDeployScripts = index.executeDeployScripts;
+exports.extendEnvironment = index.extendEnvironment;
+exports.getChain = index.getChain;
+exports.getGasPriceEstimate = index.getGasPriceEstimate;
+exports.getRoughGasPriceEstimate = index.getRoughGasPriceEstimate;
+exports.handleSignerProtocol = index.handleSignerProtocol;
+exports.loadAndExecuteDeployments = index.loadAndExecuteDeployments;
+exports.loadDeployments = index.loadDeployments;
+exports.loadEnvironment = index.loadEnvironment;
+exports.mergeArtifacts = index.mergeArtifacts;
+exports.readAndResolveConfig = index.readAndResolveConfig;
+exports.readConfig = index.readConfig;
+exports.resolveConfig = index.resolveConfig;
+//# sourceMappingURL=index.cjs.map