rocketh 0.5.11 → 0.5.13

package/dist/chunk-YZAKY2DK.js

@@ -1,813 +0,0 @@
-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 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 existingPendinTransaction;
-      try {
-        existingPendinTransaction = stringToJSON(fs3.readFileSync(filepath, "utf-8"));
-      } catch {
-        existingPendinTransaction = [];
-      }
-      existingPendinTransaction.push(pendingTransaction);
-      fs3.writeFileSync(filepath, JSONToString(existingPendinTransaction, 2));
-    }
-    return deployments;
-  }
-  async function waitForTransactionReceipt(params) {
-    const { hash, confirmations, pollingInterval, timeout } = { confirmations: 1, pollingInterval: 1, ...params };
-    let receipt = await provider.request({
-      method: "eth_getTransactionReceipt",
-      params: [hash]
-    });
-    if (!receipt) {
-      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 existingPendingDeployments;
-      try {
-        existingPendingDeployments = stringToJSON(fs3.readFileSync(filepath, "utf-8"));
-      } catch {
-        existingPendingDeployments = [];
-      }
-      existingPendingDeployments = existingPendingDeployments.filter((v) => v.transaction.txHash !== hash);
-      if (existingPendingDeployments.length === 0) {
-        fs3.rmSync(filepath);
-      } else {
-        fs3.writeFileSync(filepath, JSONToString(existingPendingDeployments, 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-YZAKY2DK.js.map