rocketh 0.4.41 → 0.5.1

package/dist/index.cjs

@@ -0,0 +1,684 @@
+"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, {
+  execute: () => execute,
+  executeDeployScripts: () => executeDeployScripts,
+  extendEnvironment: () => extendEnvironment,
+  handleSignerProtocol: () => handleSignerProtocol,
+  loadAndExecuteDeployments: () => loadAndExecuteDeployments,
+  loadDeployments: () => loadDeployments,
+  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_json_provider = require("eip-1193-json-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, subPath, onlyABIAndAddress, expectedChainId) {
+  const deploymentsFound = {};
+  const deployPath = import_node_path2.default.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 = import_node_path2.default.join(deployPath, ".chainId");
+    if (import_node_fs2.default.existsSync(chainIdFilepath)) {
+      chainId = import_node_fs2.default.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 = 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 };
+}
+
+// src/environment/index.ts
+globalThis.extensions = [];
+function extendEnvironment(extension) {
+  globalThis.extensions.push(extension);
+}
+globalThis.signerProtocols = {};
+function handleSignerProtocol(protocol, getSigner) {
+  globalThis.signerProtocols[protocol] = {
+    getSigner
+  };
+}
+async function createEnvironment(config, providedContext) {
+  const provider = "provider" in config ? config.provider : new import_eip_1193_json_provider.JSONRPCHTTPProvider(config.nodeUrl);
+  const transport = (0, import_viem.custom)(provider);
+  const viemClient = (0, import_viem.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 (accountForNetwork) {
+        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 = import_node_path3.default.join(config.deployments, context.network.name);
+    import_node_fs3.default.mkdirSync(folderPath, { recursive: true });
+    const chainIdFilepath = import_node_path3.default.join(folderPath, ".chainId");
+    if (!import_node_fs3.default.existsSync(chainIdFilepath)) {
+      import_node_fs3.default.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();
+      import_node_fs3.default.writeFileSync(`${folderPath}/${name}.json`, JSONToString(deployment, 2));
+    }
+    return deployment;
+  }
+  async function recoverTransactionsIfAny() {
+    const filepath = import_node_path3.default.join(config.deployments, context.network.name, ".pending_transactions.json");
+    let existingPendingDeployments;
+    try {
+      existingPendingDeployments = stringToJSON(import_node_fs3.default.readFileSync(filepath, "utf-8"));
+    } catch {
+      existingPendingDeployments = [];
+    }
+    if (existingPendingDeployments.length > 0) {
+      while (existingPendingDeployments.length > 0) {
+        const pendingTransaction = existingPendingDeployments.shift();
+        if (pendingTransaction) {
+          console.log(
+            `recovering ${pendingTransaction.name} with transaction ${pendingTransaction.transaction.txHash}`
+          );
+          await waitForTransactionAndSave(pendingTransaction.name, pendingTransaction.transaction);
+          console.log(`transaction ${pendingTransaction.transaction.txHash} complete`);
+          import_node_fs3.default.writeFileSync(filepath, JSONToString(existingPendingDeployments, 2));
+        }
+      }
+      import_node_fs3.default.rmSync(filepath);
+    }
+  }
+  async function saveTransaction(name, transaction) {
+    if (context.network.saveDeployments) {
+      const folderPath = ensureDeploymentFolder();
+      const filepath = import_node_path3.default.join(folderPath, ".pending_transactions.json");
+      let existingPendingDeployments;
+      try {
+        existingPendingDeployments = stringToJSON(import_node_fs3.default.readFileSync(filepath, "utf-8"));
+      } catch {
+        existingPendingDeployments = [];
+      }
+      existingPendingDeployments.push({ name, transaction });
+      import_node_fs3.default.writeFileSync(filepath, JSONToString(existingPendingDeployments, 2));
+    }
+    return deployments;
+  }
+  async function deleteTransaction(hash) {
+    if (context.network.saveDeployments) {
+      const filepath = import_node_path3.default.join(config.deployments, context.network.name, ".pending_transactions.json");
+      let existingPendingDeployments;
+      try {
+        existingPendingDeployments = stringToJSON(import_node_fs3.default.readFileSync(filepath, "utf-8"));
+      } catch {
+        existingPendingDeployments = [];
+      }
+      existingPendingDeployments = existingPendingDeployments.filter((v) => v.transaction.txHash !== hash);
+      if (existingPendingDeployments.length === 0) {
+        import_node_fs3.default.rmSync(filepath);
+      } else {
+        import_node_fs3.default.writeFileSync(filepath, JSONToString(existingPendingDeployments, 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 waitForTransactionAndSave(name, pendingDeployment) {
+    const receipt = await viemClient.waitForTransactionReceipt({
+      hash: pendingDeployment.txHash
+    });
+    if (!receipt.contractAddress) {
+      throw new Error(`failed to deploy contract ${name}`);
+    }
+    const { abi, ...artifactObjectWithoutABI } = pendingDeployment.partialDeployment;
+    if (!artifactObjectWithoutABI.nonce) {
+      const transaction = await provider.request({
+        method: "eth_getTransactionByHash",
+        params: [pendingDeployment.txHash]
+      });
+      if (transaction) {
+        artifactObjectWithoutABI.nonce = transaction.nonce;
+        artifactObjectWithoutABI.txOrigin = transaction.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(name, deployment);
+  }
+  async function saveWhilePending(name, pendingDeployment) {
+    await saveTransaction(name, pendingDeployment);
+    const transaction = await provider.request({
+      method: "eth_getTransactionByHash",
+      params: [pendingDeployment.txHash]
+    });
+    const deployment = waitForTransactionAndSave(
+      name,
+      transaction ? {
+        ...pendingDeployment,
+        nonce: transaction.nonce,
+        txOrigin: transaction.from
+      } : pendingDeployment
+    );
+    await deleteTransaction(pendingDeployment.txHash);
+    return deployment;
+  }
+  let env = {
+    ...perliminaryEnvironment,
+    save,
+    saveWhilePending,
+    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 = import_node_fs4.default.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 {
+          console.error(`network "${options.network}" is not configured. Please add it to the rocketh.json file`);
+          process.exit(1);
+        }
+      }
+    } else {
+      if (extra?.ignoreMissingRPC) {
+        nodeUrl = "";
+      } else {
+        console.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) {
+  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) {
+          console.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) {
+      console.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 = import_node_path4.default.basename(deployScript.filePath);
+    let skip = false;
+    if (deployScript.func.skip) {
+      try {
+        skip = await deployScript.func.skip(external);
+      } catch (e) {
+        console.error(`skip failed for ${deployScript.filePath}`);
+        throw e;
+      }
+    }
+    if (!skip) {
+      let result;
+      try {
+        result = await deployScript.func(external);
+      } catch (e) {
+        console.error(`execution failed for ${deployScript.filePath}`);
+        throw e;
+      }
+      if (result && typeof result === "boolean") {
+        const deploymentFolderPath = config.deployments;
+      }
+    }
+  }
+  return external.deployments;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  execute,
+  executeDeployScripts,
+  extendEnvironment,
+  handleSignerProtocol,
+  loadAndExecuteDeployments,
+  loadDeployments,
+  readAndResolveConfig,
+  readConfig,
+  resolveConfig
+});
+//# sourceMappingURL=index.cjs.map