hardhatjs 2.22.15

package/src/builtin-tasks/node.ts

@@ -0,0 +1,385 @@
+import type EthereumjsUtilT from "@nomicfoundation/ethereumjs-util";
+
+import chalk from "chalk";
+import debug from "debug";
+import fsExtra from "fs-extra";
+
+import { HARDHAT_NETWORK_NAME } from "../internal/constants";
+import { subtask, task, types } from "../internal/core/config/config-env";
+import { HardhatError } from "../internal/core/errors";
+import { ERRORS } from "../internal/core/errors-list";
+import { createProvider } from "../internal/core/providers/construction";
+import { normalizeHardhatNetworkAccountsConfig } from "../internal/core/providers/util";
+import {
+  JsonRpcServer as JsonRpcServerImpl,
+  JsonRpcServerConfig,
+} from "../internal/hardhat-network/jsonrpc/server";
+import { Reporter } from "../internal/sentry/reporter";
+import {
+  EthereumProvider,
+  HardhatNetworkConfig,
+  JsonRpcServer,
+} from "../types";
+
+import { HARDHAT_NETWORK_MNEMONIC } from "../internal/core/config/default-config";
+import {
+  TASK_NODE,
+  TASK_NODE_CREATE_SERVER,
+  TASK_NODE_GET_PROVIDER,
+  TASK_NODE_SERVER_CREATED,
+  TASK_NODE_SERVER_READY,
+} from "./task-names";
+import { watchCompilerOutput, Watcher } from "./utils/watch";
+
+const log = debug("hardhat:core:tasks:node");
+
+function printDefaultConfigWarning() {
+  console.log(
+    chalk.bold(
+      "WARNING: These accounts, and their private keys, are publicly known."
+    )
+  );
+  console.log(
+    chalk.bold(
+      "Any funds sent to them on Mainnet or any other live network WILL BE LOST."
+    )
+  );
+}
+
+function logHardhatNetworkAccounts(networkConfig: HardhatNetworkConfig) {
+  const isDefaultConfig =
+    !Array.isArray(networkConfig.accounts) &&
+    networkConfig.accounts.mnemonic === HARDHAT_NETWORK_MNEMONIC;
+
+  const {
+    bytesToHex: bufferToHex,
+    privateToAddress,
+    toBytes,
+    toChecksumAddress,
+  } = require("@nomicfoundation/ethereumjs-util") as typeof EthereumjsUtilT;
+
+  console.log("Accounts");
+  console.log("========");
+
+  if (isDefaultConfig) {
+    console.log();
+    printDefaultConfigWarning();
+    console.log();
+  }
+
+  const accounts = normalizeHardhatNetworkAccountsConfig(
+    networkConfig.accounts
+  );
+
+  for (const [index, account] of accounts.entries()) {
+    const address = toChecksumAddress(
+      bufferToHex(privateToAddress(toBytes(account.privateKey)))
+    );
+
+    const balance = (BigInt(account.balance) / 10n ** 18n).toString(10);
+
+    let entry = `Account #${index}: ${address} (${balance} ETH)`;
+
+    if (isDefaultConfig) {
+      const privateKey = bufferToHex(toBytes(account.privateKey));
+      entry += `
+Private Key: ${privateKey}`;
+    }
+
+    console.log(entry);
+    console.log();
+  }
+
+  if (isDefaultConfig) {
+    printDefaultConfigWarning();
+    console.log();
+  }
+}
+
+subtask(TASK_NODE_GET_PROVIDER)
+  .addOptionalParam("forkUrl", undefined, undefined, types.string)
+  .addOptionalParam("forkBlockNumber", undefined, undefined, types.int)
+  .setAction(
+    async (
+      {
+        forkBlockNumber: forkBlockNumberParam,
+        forkUrl: forkUrlParam,
+      }: {
+        forkBlockNumber?: number;
+        forkUrl?: string;
+      },
+      { artifacts, config, network, userConfig }
+    ): Promise<EthereumProvider> => {
+      let provider = network.provider;
+
+      if (network.name !== HARDHAT_NETWORK_NAME) {
+        log(`Creating hardhat provider for JSON-RPC server`);
+        provider = await createProvider(
+          config,
+          HARDHAT_NETWORK_NAME,
+          artifacts
+        );
+      }
+
+      const hardhatNetworkConfig = config.networks[HARDHAT_NETWORK_NAME];
+
+      const forkUrlConfig = hardhatNetworkConfig.forking?.url;
+      const forkBlockNumberConfig = hardhatNetworkConfig.forking?.blockNumber;
+
+      const forkUrl = forkUrlParam ?? forkUrlConfig;
+      const forkBlockNumber = forkBlockNumberParam ?? forkBlockNumberConfig;
+
+      // we throw an error if the user specified a forkBlockNumber but not a
+      // forkUrl
+      if (forkBlockNumber !== undefined && forkUrl === undefined) {
+        throw new HardhatError(
+          ERRORS.BUILTIN_TASKS.NODE_FORK_BLOCK_NUMBER_WITHOUT_URL
+        );
+      }
+
+      // if the url or the block is different to the one in the configuration,
+      // we use hardhat_reset to set the fork
+      if (
+        forkUrl !== forkUrlConfig ||
+        forkBlockNumber !== forkBlockNumberConfig
+      ) {
+        await provider.request({
+          method: "hardhat_reset",
+          params: [
+            {
+              forking: {
+                jsonRpcUrl: forkUrl,
+                blockNumber: forkBlockNumber,
+              },
+            },
+          ],
+        });
+      }
+
+      const hardhatNetworkUserConfig =
+        userConfig.networks?.[HARDHAT_NETWORK_NAME] ?? {};
+
+      // enable logging
+      await provider.request({
+        method: "hardhat_setLoggingEnabled",
+        params: [hardhatNetworkUserConfig.loggingEnabled ?? true],
+      });
+
+      return provider;
+    }
+  );
+
+subtask(TASK_NODE_CREATE_SERVER)
+  .addParam("hostname", undefined, undefined, types.string)
+  .addParam("port", undefined, undefined, types.int)
+  .addParam("provider", undefined, undefined, types.any)
+  .setAction(
+    async ({
+      hostname,
+      port,
+      provider,
+    }: {
+      hostname: string;
+      port: number;
+      provider: EthereumProvider;
+    }): Promise<JsonRpcServer> => {
+      const serverConfig: JsonRpcServerConfig = {
+        hostname,
+        port,
+        provider,
+      };
+
+      const server = new JsonRpcServerImpl(serverConfig);
+
+      return server;
+    }
+  );
+
+/**
+ * This task will be called when the server was successfully created, but it's
+ * not ready for receiving requests yet.
+ */
+subtask(TASK_NODE_SERVER_CREATED)
+  .addParam("hostname", undefined, undefined, types.string)
+  .addParam("port", undefined, undefined, types.int)
+  .addParam("provider", undefined, undefined, types.any)
+  .addParam("server", undefined, undefined, types.any)
+  .setAction(
+    async ({}: {
+      hostname: string;
+      port: number;
+      provider: EthereumProvider;
+      server: JsonRpcServer;
+    }) => {
+      // this task is meant to be overriden by plugin writers
+    }
+  );
+
+/**
+ * This subtask will be run when the server is ready to accept requests
+ */
+subtask(TASK_NODE_SERVER_READY)
+  .addParam("address", undefined, undefined, types.string)
+  .addParam("port", undefined, undefined, types.int)
+  .addParam("provider", undefined, undefined, types.any)
+  .addParam("server", undefined, undefined, types.any)
+  .setAction(
+    async (
+      {
+        address,
+        port,
+      }: {
+        address: string;
+        port: number;
+        provider: EthereumProvider;
+        server: JsonRpcServer;
+      },
+      { config }
+    ) => {
+      console.log(
+        chalk.green(
+          `Started HTTP and WebSocket JSON-RPC server at http://${address}:${port}/`
+        )
+      );
+
+      console.log();
+
+      const networkConfig = config.networks[HARDHAT_NETWORK_NAME];
+      logHardhatNetworkAccounts(networkConfig);
+    }
+  );
+
+task(TASK_NODE, "Starts a JSON-RPC server on top of Hardhat Network")
+  .addOptionalParam(
+    "hostname",
+    "The host to which to bind to for new connections (Defaults to 127.0.0.1 running locally, and 0.0.0.0 in Docker)",
+    undefined,
+    types.string
+  )
+  .addOptionalParam(
+    "port",
+    "The port on which to listen for new connections",
+    8545,
+    types.int
+  )
+  .addOptionalParam(
+    "fork",
+    "The URL of the JSON-RPC server to fork from",
+    undefined,
+    types.string
+  )
+  .addOptionalParam(
+    "forkBlockNumber",
+    "The block number to fork from",
+    undefined,
+    types.int
+  )
+  .setAction(
+    async (
+      {
+        forkBlockNumber,
+        fork: forkUrl,
+        hostname: hostnameParam,
+        port,
+      }: {
+        forkBlockNumber?: number;
+        fork?: string;
+        hostname?: string;
+        port: number;
+      },
+      { config, hardhatArguments, network, run }
+    ) => {
+      // we throw if the user specified a network argument and it's not hardhat
+      if (
+        network.name !== HARDHAT_NETWORK_NAME &&
+        hardhatArguments.network !== undefined
+      ) {
+        throw new HardhatError(
+          ERRORS.BUILTIN_TASKS.JSONRPC_UNSUPPORTED_NETWORK
+        );
+      }
+
+      try {
+        const provider: EthereumProvider = await run(TASK_NODE_GET_PROVIDER, {
+          forkBlockNumber,
+          forkUrl,
+        });
+
+        // the default hostname is "127.0.0.1" unless we are inside a docker
+        // container, in that case we use "0.0.0.0"
+        let hostname: string;
+        if (hostnameParam !== undefined) {
+          hostname = hostnameParam;
+        } else {
+          const insideDocker = fsExtra.existsSync("/.dockerenv");
+          if (insideDocker) {
+            hostname = "0.0.0.0";
+          } else {
+            hostname = "127.0.0.1";
+          }
+        }
+
+        const server: JsonRpcServer = await run(TASK_NODE_CREATE_SERVER, {
+          hostname,
+          port,
+          provider,
+        });
+
+        await run(TASK_NODE_SERVER_CREATED, {
+          hostname,
+          port,
+          provider,
+          server,
+        });
+
+        const { port: actualPort, address } = await server.listen();
+
+        let watcher: Watcher | undefined;
+        try {
+          watcher = await watchCompilerOutput(provider, config.paths);
+        } catch (error) {
+          console.warn(
+            chalk.yellow(
+              "There was a problem watching the compiler output, changes in the contracts won't be reflected in the Hardhat Network. Run Hardhat with --verbose to learn more."
+            )
+          );
+
+          log(
+            "Compilation output can't be watched. Please report this to help us improve Hardhat.\n",
+            error
+          );
+
+          if (error instanceof Error) {
+            Reporter.reportError(error);
+          }
+        }
+
+        await run(TASK_NODE_SERVER_READY, {
+          address,
+          port: actualPort,
+          provider,
+          server,
+        });
+
+        await server.waitUntilClosed();
+        await watcher?.close();
+      } catch (error) {
+        if (HardhatError.isHardhatError(error)) {
+          throw error;
+        }
+
+        if (error instanceof Error) {
+          throw new HardhatError(
+            ERRORS.BUILTIN_TASKS.JSONRPC_SERVER_ERROR,
+            {
+              error: error.message,
+            },
+            error
+          );
+        }
+
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw error;
+      }
+    }
+  );

package/src/builtin-tasks/run.ts

@@ -0,0 +1,56 @@
+import debug from "debug";
+import fsExtra from "fs-extra";
+
+import { task } from "../internal/core/config/config-env";
+import { HardhatError } from "../internal/core/errors";
+import { ERRORS } from "../internal/core/errors-list";
+import { runScriptWithHardhat } from "../internal/util/scripts-runner";
+
+import { TASK_COMPILE, TASK_RUN } from "./task-names";
+
+const log = debug("hardhat:core:tasks:run");
+
+task(TASK_RUN, "Runs a user-defined script after compiling the project")
+  .addPositionalParam(
+    "script",
+    "A js file to be run within hardhat's environment"
+  )
+  .addFlag("noCompile", "Don't compile before running this task")
+  .setAction(
+    async (
+      { script, noCompile }: { script: string; noCompile: boolean },
+      { run, hardhatArguments }
+    ) => {
+      if (!(await fsExtra.pathExists(script))) {
+        throw new HardhatError(ERRORS.BUILTIN_TASKS.RUN_FILE_NOT_FOUND, {
+          script,
+        });
+      }
+
+      if (!noCompile) {
+        await run(TASK_COMPILE, { quiet: true });
+      }
+
+      log(
+        `Running script ${script} in a subprocess so we can wait for it to complete`
+      );
+
+      try {
+        process.exitCode = await runScriptWithHardhat(hardhatArguments, script);
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new HardhatError(
+            ERRORS.BUILTIN_TASKS.RUN_SCRIPT_ERROR,
+            {
+              script,
+              error: error.message,
+            },
+            error
+          );
+        }
+
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw error;
+      }
+    }
+  );

package/src/builtin-tasks/task-names.ts

@@ -0,0 +1,92 @@
+export const TASK_CHECK = "check";
+
+export const TASK_CLEAN = "clean";
+export const TASK_CLEAN_GLOBAL = "clean:global";
+
+export const TASK_COMPILE = "compile";
+export const TASK_COMPILE_GET_COMPILATION_TASKS =
+  "compile:get-compilation-tasks";
+export const TASK_COMPILE_SOLIDITY = "compile:solidity";
+export const TASK_COMPILE_SOLIDITY_GET_SOURCE_PATHS =
+  "compile:solidity:get-source-paths";
+export const TASK_COMPILE_SOLIDITY_GET_SOURCE_NAMES =
+  "compile:solidity:get-source-names";
+export const TASK_COMPILE_SOLIDITY_READ_FILE = "compile:solidity:read-file";
+export const TASK_COMPILE_TRANSFORM_IMPORT_NAME =
+  "compile:solidity:transform-import-name";
+export const TASK_COMPILE_GET_REMAPPINGS = "compile:solidity:get-remappings";
+export const TASK_COMPILE_SOLIDITY_GET_DEPENDENCY_GRAPH =
+  "compile:solidity:get-dependency-graph";
+export const TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOBS =
+  "compile:solidity:get-compilation-jobs";
+export const TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOB_FOR_FILE =
+  "compile:solidity:get-compilation-job-for-file";
+export const TASK_COMPILE_SOLIDITY_FILTER_COMPILATION_JOBS =
+  "compile:solidity:filter-compilation-jobs";
+export const TASK_COMPILE_SOLIDITY_MERGE_COMPILATION_JOBS =
+  "compile:solidity:merge-compilation-jobs";
+export const TASK_COMPILE_SOLIDITY_LOG_NOTHING_TO_COMPILE =
+  "compile:solidity:log:nothing-to-compile";
+export const TASK_COMPILE_SOLIDITY_COMPILE_JOB = "compile:solidity:compile-job";
+export const TASK_COMPILE_SOLIDITY_LOG_RUN_COMPILER_START =
+  "compile:solidity:log:run-compiler-start";
+export const TASK_COMPILE_SOLIDITY_LOG_RUN_COMPILER_END =
+  "compile:solidity:log:run-compiler-end";
+export const TASK_COMPILE_SOLIDITY_COMPILE_JOBS =
+  "compile:solidity:compile-jobs";
+export const TASK_COMPILE_SOLIDITY_GET_COMPILER_INPUT =
+  "compile:solidity:get-compiler-input";
+export const TASK_COMPILE_SOLIDITY_COMPILE = "compile:solidity:compile";
+export const TASK_COMPILE_SOLIDITY_COMPILE_SOLC =
+  "compile:solidity:solc:compile";
+export const TASK_COMPILE_SOLIDITY_GET_SOLC_BUILD =
+  "compile:solidity:solc:get-build";
+export const TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_START =
+  "compile:solidity:log:download-compiler-start";
+export const TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_END =
+  "compile:solidity:log:download-compiler-end";
+export const TASK_COMPILE_SOLIDITY_RUN_SOLCJS = "compile:solidity:solcjs:run";
+export const TASK_COMPILE_SOLIDITY_RUN_SOLC = "compile:solidity:solc:run";
+export const TASK_COMPILE_SOLIDITY_CHECK_ERRORS =
+  "compile:solidity:check-errors";
+export const TASK_COMPILE_SOLIDITY_LOG_COMPILATION_ERRORS =
+  "compile:solidity:log:compilation-errors";
+export const TASK_COMPILE_SOLIDITY_EMIT_ARTIFACTS =
+  "compile:solidity:emit-artifacts";
+export const TASK_COMPILE_SOLIDITY_GET_ARTIFACT_FROM_COMPILATION_OUTPUT =
+  "compile:solidity:get-artifact-from-compilation-output";
+export const TASK_COMPILE_SOLIDITY_HANDLE_COMPILATION_JOBS_FAILURES =
+  "compile:solidity:handle-compilation-jobs-failures";
+export const TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOBS_FAILURE_REASONS =
+  "compile:solidity:get-compilation-jobs-failure-reasons";
+export const TASK_COMPILE_SOLIDITY_LOG_COMPILATION_RESULT =
+  "compile:solidity:log:compilation-result";
+export const TASK_COMPILE_REMOVE_OBSOLETE_ARTIFACTS =
+  "compile:remove-obsolete-artifacts";
+
+export const TASK_CONSOLE = "console";
+
+export const TASK_FLATTEN = "flatten";
+export const TASK_FLATTEN_GET_FLATTENED_SOURCE =
+  "flatten:get-flattened-sources";
+export const TASK_FLATTEN_GET_FLATTENED_SOURCE_AND_METADATA =
+  "flatten:get-flattened-sources-and-metadata";
+export const TASK_FLATTEN_GET_DEPENDENCY_GRAPH = "flatten:get-dependency-graph";
+
+export const TASK_HELP = "help";
+
+export const TASK_RUN = "run";
+
+export const TASK_NODE = "node";
+export const TASK_NODE_GET_PROVIDER = "node:get-provider";
+export const TASK_NODE_CREATE_SERVER = "node:create-server";
+export const TASK_NODE_SERVER_CREATED = "node:server-created";
+export const TASK_NODE_SERVER_READY = "node:server-ready";
+
+export const TASK_TEST = "test";
+
+export const TASK_TEST_RUN_SHOW_FORK_RECOMMENDATIONS =
+  "test:show-fork-recommendations";
+export const TASK_TEST_RUN_MOCHA_TESTS = "test:run-mocha-tests";
+export const TASK_TEST_GET_TEST_FILES = "test:get-test-files";
+export const TASK_TEST_SETUP_TEST_ENVIRONMENT = "test:setup-test-environment";