rocketh 0.5.10 → 0.5.12

package/dist/chunk-TSZHO6IV.js

@@ -0,0 +1,819 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/fs.ts
+import fs from "fs";
+import path from "path";
+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(path.join(dir, filestat.relativePath));
+    }
+  }
+  return filepaths;
+}
+var traverse = function(dir, result = [], topDir, filter) {
+  fs.readdirSync(dir).forEach((name) => {
+    const fPath = path.resolve(dir, name);
+    const stats = fs.statSync(fPath);
+    if (!filter && !name.startsWith(".") || filter && filter(name, stats)) {
+      const fileStats = {
+        name,
+        path: fPath,
+        relativePath: path.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
+import path4 from "path";
+import fs4 from "fs";
+
+// src/environment/index.ts
+import fs3 from "fs";
+import { createPublicClient, custom } from "viem";
+import { JSONRPCHTTPProvider } from "eip-1193-json-provider";
+import path3 from "path";
+
+// 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
+import path2 from "path";
+import fs2 from "fs";
+function loadDeployments(deploymentsPath, subPath, onlyABIAndAddress, expectedChainId) {
+  const deploymentsFound = {};
+  const deployPath = path2.join(deploymentsPath, subPath);
+  let filesStats;
+  try {
+    filesStats = traverse(deployPath, void 0, void 0, (name) => !name.startsWith(".") && name !== "solcInputs");
+  } catch (e) {
+    return { deployments: {} };
+  }
+  let chainId;
+  if (filesStats.length > 0) {
+    const chainIdFilepath = path2.join(deployPath, ".chainId");
+    if (fs2.existsSync(chainIdFilepath)) {
+      chainId = fs2.readFileSync(chainIdFilepath).toString().trim();
+    } else {
+      throw new Error(`A .chainId' file is expected to be present in the deployment folder for network ${subPath}`);
+    }
+    if (expectedChainId) {
+      if (expectedChainId !== chainId) {
+        throw new Error(
+          `Loading deployment in folder '${deployPath}' (with chainId: ${chainId}) for a different chainId (${expectedChainId})`
+        );
+      }
+    }
+  } 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 = path2.join(deployPath, fileName);
+      let deployment = JSON.parse(fs2.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 };
+}
+
+// src/internal/logging.ts
+import { logs } from "named-logs";
+import { hookup, logs as Logging } from "named-logs-console";
+hookup();
+function setLogLevel(level) {
+  Logging.level = level;
+  if (Logging.level > 0) {
+    Logging.enable();
+  } else {
+    Logging.disable();
+  }
+}
+var logger = logs("rocketh");
+var voidSpinner = {
+  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 lastSpin = voidSpinner;
+function spin(message) {
+  if (Logging.level > 0) {
+    lastSpin = lastSpin.start(message);
+    return lastSpin;
+  } else {
+    return voidSpinner;
+  }
+}
+
+// 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 provider = "provider" in config ? config.provider : new JSONRPCHTTPProvider(config.nodeUrl);
+  const transport = custom(provider);
+  const viemClient = createPublicClient({ transport });
+  const chainId = (await viemClient.getChainId()).toString();
+  let networkName;
+  let saveDeployments;
+  let tags = {};
+  if ("nodeUrl" in config) {
+    networkName = config.networkName;
+    saveDeployments = true;
+  } else {
+    if (config.networkName) {
+      networkName = config.networkName;
+    } else {
+      networkName = "memory";
+    }
+    if (networkName === "memory" || networkName === "hardhat") {
+      tags["memory"] = true;
+      saveDeployments = false;
+    } else {
+      saveDeployments = true;
+    }
+  }
+  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,
+      saveDeployments,
+      tags
+    }
+  };
+  const { deployments } = loadDeployments(config.deployments, context.network.name, false, chainId);
+  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: {
+      chainId,
+      name: context.network.name,
+      tags: context.network.tags,
+      provider
+    }
+  };
+  function ensureDeploymentFolder() {
+    const folderPath = path3.join(config.deployments, context.network.name);
+    fs3.mkdirSync(folderPath, { recursive: true });
+    const chainIdFilepath = path3.join(folderPath, ".chainId");
+    if (!fs3.existsSync(chainIdFilepath)) {
+      fs3.writeFileSync(chainIdFilepath, chainId);
+    }
+    return folderPath;
+  }
+  function get(name) {
+    return deployments[name];
+  }
+  async function save(name, deployment) {
+    deployments[name] = deployment;
+    if (context.network.saveDeployments) {
+      const folderPath = ensureDeploymentFolder();
+      fs3.writeFileSync(`${folderPath}/${name}.json`, JSONToString(deployment, 2));
+    }
+    return deployment;
+  }
+  async function recoverTransactionsIfAny() {
+    const folderPath = ensureDeploymentFolder();
+    const filepath = path3.join(folderPath, ".pending_transactions.json");
+    let existingPendingTansactions;
+    try {
+      existingPendingTansactions = stringToJSON(fs3.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.txHash}`);
+            try {
+              await waitForDeploymentTransactionAndSave(pendingTransaction);
+              fs3.writeFileSync(filepath, JSONToString(existingPendingTansactions, 2));
+              spinner.succeed();
+            } catch (e) {
+              spinner.fail();
+              throw e;
+            }
+          } else {
+            const spinner = spin(`recovering execution's transaction ${pendingTransaction.txHash}`);
+            try {
+              await waitForTransaction(pendingTransaction.txHash);
+              fs3.writeFileSync(filepath, JSONToString(existingPendingTansactions, 2));
+              spinner.succeed();
+            } catch (e) {
+              spinner.fail();
+              throw e;
+            }
+          }
+        }
+      }
+      fs3.rmSync(filepath);
+    }
+  }
+  async function savePendingTransaction(pendingTransaction) {
+    if (context.network.saveDeployments) {
+      const folderPath = ensureDeploymentFolder();
+      const filepath = path3.join(folderPath, ".pending_transactions.json");
+      let existingPendinTransactions;
+      try {
+        existingPendinTransactions = stringToJSON(fs3.readFileSync(filepath, "utf-8"));
+      } catch {
+        existingPendinTransactions = [];
+      }
+      existingPendinTransactions.push(pendingTransaction);
+      fs3.writeFileSync(filepath, JSONToString(existingPendinTransactions, 2));
+    }
+    return deployments;
+  }
+  async function waitForTransactionReceipt(params) {
+    const { hash, pollingInterval } = { pollingInterval: 1, ...params };
+    let receipt = await provider.request({
+      method: "eth_getTransactionReceipt",
+      params: [hash]
+    });
+    if (!receipt || !receipt.blockHash) {
+      await wait(pollingInterval);
+      return waitForTransactionReceipt(params);
+    }
+    return receipt;
+  }
+  async function deleteTransaction(hash) {
+    if (context.network.saveDeployments) {
+      const folderPath = ensureDeploymentFolder();
+      const filepath = path3.join(folderPath, ".pending_transactions.json");
+      let existingPendinTransactions;
+      try {
+        existingPendinTransactions = stringToJSON(fs3.readFileSync(filepath, "utf-8"));
+      } catch {
+        existingPendinTransactions = [];
+      }
+      existingPendinTransactions = existingPendinTransactions.filter((v) => v.txHash !== hash);
+      if (existingPendinTransactions.length === 0) {
+        fs3.rmSync(filepath);
+      } else {
+        fs3.writeFileSync(filepath, JSONToString(existingPendinTransactions, 2));
+      }
+    }
+  }
+  async function exportDeploymentsAsTypes() {
+    const folderPath = "./generated";
+    fs3.mkdirSync(folderPath, { recursive: true });
+    fs3.writeFileSync(`${folderPath}/deployments.ts`, `export default ${JSONToString(deployments, 2)} as const;`);
+  }
+  async function waitForTransaction(hash, message) {
+    const spinner = spin(message || "");
+    let receipt;
+    try {
+      receipt = await waitForTransactionReceipt({
+        hash
+      });
+    } catch (e) {
+      spinner.fail();
+      throw e;
+    }
+    if (!receipt) {
+      throw new Error(`receipt for ${hash} not found`);
+    } else {
+      spinner.succeed();
+    }
+    return receipt;
+  }
+  async function waitForDeploymentTransactionAndSave(pendingDeployment, transaction) {
+    const message = `  - Deploying ${pendingDeployment.name} with tx:
+      ${pendingDeployment.txHash}${transaction ? `
+      ${displayTransaction(transaction)}` : ""}`;
+    const receipt = await waitForTransaction(pendingDeployment.txHash, message);
+    if (!receipt.contractAddress) {
+      throw new Error(`failed to deploy contract ${pendingDeployment.name}`);
+    }
+    const { abi, ...artifactObjectWithoutABI } = pendingDeployment.partialDeployment;
+    if (!artifactObjectWithoutABI.nonce) {
+      const spinner = spin();
+      let transaction2 = null;
+      try {
+        transaction2 = await provider.request({
+          method: "eth_getTransactionByHash",
+          params: [pendingDeployment.txHash]
+        });
+      } catch (e) {
+        spinner.fail();
+        throw e;
+      }
+      if (!transaction2) {
+        spinner.fail(`tx ${pendingDeployment.txHash} not found`);
+      } else {
+        spinner.stop();
+      }
+      if (transaction2) {
+        artifactObjectWithoutABI.nonce = transaction2.nonce;
+        artifactObjectWithoutABI.txOrigin = transaction2.from;
+      }
+    }
+    for (const key of Object.keys(artifactObjectWithoutABI)) {
+      if (key.startsWith("_")) {
+        delete artifactObjectWithoutABI[key];
+      }
+      if (key === "evm") {
+        const { gasEstimates } = artifactObjectWithoutABI.evm;
+        artifactObjectWithoutABI.evm = {
+          gasEstimates
+        };
+      }
+    }
+    const deployment = {
+      address: receipt.contractAddress,
+      txHash: pendingDeployment.txHash,
+      abi,
+      ...artifactObjectWithoutABI
+    };
+    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.txHash]
+      });
+    } catch (e) {
+      spinner.fail();
+      throw e;
+    }
+    if (!transaction) {
+      spinner.fail(`tx ${pendingExecution.txHash} not found`);
+    } else {
+      spinner.stop();
+    }
+    if (transaction) {
+      pendingExecution.nonce = transaction.nonce;
+      pendingExecution.txOrigin = transaction.from;
+    }
+    const receipt = await waitForTransaction(pendingExecution.txHash);
+    await deleteTransaction(pendingExecution.txHash);
+    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.txHash]
+      });
+    } catch (e) {
+      spinner.fail();
+      throw e;
+    }
+    if (!transaction) {
+      spinner.fail(`tx ${pendingDeployment.txHash} not found`);
+    } else {
+      spinner.stop();
+    }
+    if (transaction) {
+      pendingDeployment.nonce = transaction.nonce;
+      pendingDeployment.txOrigin = transaction.from;
+    }
+    const deployment = await waitForDeploymentTransactionAndSave(pendingDeployment);
+    await deleteTransaction(pendingDeployment.txHash);
+    return deployment;
+  }
+  let env = {
+    ...perliminaryEnvironment,
+    save,
+    savePendingDeployment,
+    savePendingExecution,
+    get
+  };
+  for (const extension of globalThis.extensions) {
+    env = extension(env);
+  }
+  return {
+    external: env,
+    internal: {
+      exportDeploymentsAsTypes,
+      recoverTransactionsIfAny
+    }
+  };
+}
+
+// src/executor/index.ts
+__require("esbuild-register/dist/node").register();
+function execute(context, callback, options) {
+  const scriptModule = (env) => callback(env);
+  scriptModule.providedContext = context;
+  scriptModule.tags = options.tags;
+  scriptModule.dependencies = options.dependencies;
+  return scriptModule;
+}
+function readConfig(options, extra) {
+  let configFile;
+  try {
+    const configString = fs4.readFileSync("./rocketh.json", "utf-8");
+    configFile = JSON.parse(configString);
+  } catch {
+  }
+  let nodeUrl;
+  const fromEnv = process.env["ETH_NODE_URI_" + options.network];
+  if (typeof fromEnv === "string") {
+    nodeUrl = fromEnv;
+  } else {
+    if (configFile) {
+      const network = configFile.networks && configFile.networks[options.network];
+      if (network) {
+        nodeUrl = network.rpcUrl;
+      } else {
+        if (extra?.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 (extra?.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 {
+    nodeUrl,
+    networkName: options.network,
+    deployments: options.deployments,
+    scripts: options.scripts,
+    tags: typeof options.tags === "undefined" ? void 0 : options.tags.split(",")
+  };
+}
+function readAndResolveConfig(options, extra) {
+  return resolveConfig(readConfig(options, extra));
+}
+function resolveConfig(config) {
+  const resolvedConfig = {
+    ...config,
+    networkName: config.networkName || "memory",
+    deployments: config.deployments || "deployments",
+    scripts: config.scripts || "deploy",
+    tags: config.tags || []
+  };
+  return resolvedConfig;
+}
+async function loadAndExecuteDeployments(config) {
+  const resolvedConfig = resolveConfig(config);
+  return executeDeployScripts(resolvedConfig);
+}
+async function executeDeployScripts(config) {
+  setLogLevel(typeof config.logLevel === "undefined" ? 0 : config.logLevel);
+  let filepaths;
+  filepaths = traverseMultipleDirectory([config.scripts]);
+  filepaths = filepaths.filter((v) => !path4.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 = path4.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);
+  }
+  for (const deployScript of scriptsToRun.concat(scriptsToRunAtTheEnd)) {
+    const filename = path4.basename(deployScript.filePath);
+    const relativeFilepath = path4.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);
+        spinner2.succeed(skip ? `skipping ${filename}` : void 0);
+      } catch (e) {
+        spinner2.fail();
+        throw e;
+      }
+    }
+    if (!skip) {
+      let result;
+      try {
+        result = await deployScript.func(external);
+        spinner.succeed(`
+`);
+      } catch (e) {
+        spinner.fail();
+        throw e;
+      }
+      if (result && typeof result === "boolean") {
+        const deploymentFolderPath = config.deployments;
+      }
+    }
+  }
+  return external.deployments;
+}
+
+export {
+  loadDeployments,
+  extendEnvironment,
+  handleSignerProtocol,
+  execute,
+  readConfig,
+  readAndResolveConfig,
+  resolveConfig,
+  loadAndExecuteDeployments,
+  executeDeployScripts
+};
+//# sourceMappingURL=chunk-TSZHO6IV.js.map