hardhatjs 2.22.15

package/src/internal/core/params/hardhat-params.ts

@@ -0,0 +1,105 @@
+import { HardhatParamDefinitions } from "../../../types";
+
+import * as types from "./argumentTypes";
+
+export const HARDHAT_PARAM_DEFINITIONS: HardhatParamDefinitions = {
+  network: {
+    name: "network",
+    defaultValue: undefined,
+    description: "The network to connect to.",
+    type: types.string,
+    isOptional: true,
+    isFlag: false,
+    isVariadic: false,
+  },
+  showStackTraces: {
+    name: "showStackTraces",
+    defaultValue: false,
+    description: "Show stack traces (always enabled on CI servers).",
+    type: types.boolean,
+    isFlag: true,
+    isOptional: true,
+    isVariadic: false,
+  },
+  version: {
+    name: "version",
+    defaultValue: false,
+    description: "Shows hardhat's version.",
+    type: types.boolean,
+    isFlag: true,
+    isOptional: true,
+    isVariadic: false,
+  },
+  help: {
+    name: "help",
+    defaultValue: false,
+    description: "Shows this message, or a task's help if its name is provided",
+    type: types.boolean,
+    isFlag: true,
+    isOptional: true,
+    isVariadic: false,
+  },
+  emoji: {
+    name: "emoji",
+    defaultValue: process.platform === "darwin",
+    description: "Use emoji in messages.",
+    type: types.boolean,
+    isFlag: true,
+    isOptional: true,
+    isVariadic: false,
+  },
+  config: {
+    name: "config",
+    defaultValue: undefined,
+    description: "A Hardhat config file.",
+    type: types.inputFile,
+    isFlag: false,
+    isOptional: true,
+    isVariadic: false,
+  },
+  verbose: {
+    name: "verbose",
+    defaultValue: false,
+    description: "Enables Hardhat verbose logging",
+    type: types.boolean,
+    isFlag: true,
+    isOptional: true,
+    isVariadic: false,
+  },
+  maxMemory: {
+    name: "maxMemory",
+    defaultValue: undefined,
+    description: "The maximum amount of memory that Hardhat can use.",
+    type: types.int,
+    isOptional: true,
+    isFlag: false,
+    isVariadic: false,
+  },
+  tsconfig: {
+    name: "tsconfig",
+    defaultValue: undefined,
+    description: "A TypeScript config file.",
+    type: types.inputFile,
+    isOptional: true,
+    isFlag: false,
+    isVariadic: false,
+  },
+  flamegraph: {
+    name: "flamegraph",
+    defaultValue: undefined,
+    description: "Generate a flamegraph of your Hardhat tasks",
+    type: types.boolean,
+    isOptional: true,
+    isFlag: true,
+    isVariadic: false,
+  },
+  typecheck: {
+    name: "typecheck",
+    defaultValue: false,
+    description: "Enable TypeScript type-checking of your scripts/tests",
+    type: types.boolean,
+    isFlag: true,
+    isOptional: true,
+    isVariadic: false,
+  },
+};

package/src/internal/core/project-structure.ts

@@ -0,0 +1,53 @@
+import findUp from "find-up";
+import fsExtra from "fs-extra";
+import path from "path";
+
+import { getPackageRoot } from "../util/packageInfo";
+
+import { HardhatError } from "./errors";
+import { ERRORS } from "./errors-list";
+
+const JS_CONFIG_FILENAME = "hardhat.config.js";
+const CJS_CONFIG_FILENAME = "hardhat.config.cjs";
+const TS_CONFIG_FILENAME = "hardhat.config.ts";
+const CTS_CONFIG_FILENAME = "hardhat.config.cts";
+
+export function isCwdInsideProject() {
+  return (
+    findUp.sync(TS_CONFIG_FILENAME) !== null ||
+    findUp.sync(CTS_CONFIG_FILENAME) !== null ||
+    findUp.sync(CJS_CONFIG_FILENAME) !== null ||
+    findUp.sync(JS_CONFIG_FILENAME) !== null
+  );
+}
+
+export function getUserConfigPath() {
+  const tsConfigPath = findUp.sync(TS_CONFIG_FILENAME);
+  if (tsConfigPath !== null) {
+    return tsConfigPath;
+  }
+
+  const ctsConfigPath = findUp.sync(CTS_CONFIG_FILENAME);
+  if (ctsConfigPath !== null) {
+    return ctsConfigPath;
+  }
+
+  const cjsConfigPath = findUp.sync(CJS_CONFIG_FILENAME);
+  if (cjsConfigPath !== null) {
+    return cjsConfigPath;
+  }
+
+  const pathToConfigFile = findUp.sync(JS_CONFIG_FILENAME);
+  if (pathToConfigFile === null) {
+    throw new HardhatError(ERRORS.GENERAL.NOT_INSIDE_PROJECT);
+  }
+
+  return pathToConfigFile;
+}
+
+export async function getRecommendedGitIgnore() {
+  const packageRoot = getPackageRoot();
+  const gitIgnorePath = path.join(packageRoot, "recommended-gitignore.txt");
+
+  return fsExtra.readFile(gitIgnorePath, "utf-8");
+}

package/src/internal/core/providers/accounts.ts

@@ -0,0 +1,385 @@
+import * as t from "io-ts";
+
+import { signTypedData, SignTypedDataVersion } from "@metamask/eth-sig-util";
+import { FeeMarketEIP1559Transaction } from "@nomicfoundation/ethereumjs-tx";
+import { EIP1193Provider, RequestArguments } from "../../../types";
+import { HardhatError } from "../errors";
+import { ERRORS } from "../errors-list";
+import {
+  rpcAddress,
+  rpcData,
+  rpcQuantityToBigInt,
+} from "../jsonrpc/types/base-types";
+import {
+  RpcTransactionRequest,
+  rpcTransactionRequest,
+} from "../jsonrpc/types/input/transactionRequest";
+import { validateParams } from "../jsonrpc/types/input/validation";
+
+import { ProviderWrapperWithChainId } from "./chainId";
+import { derivePrivateKeys } from "./util";
+import { ProviderWrapper } from "./wrapper";
+
+export interface JsonRpcTransactionData {
+  from?: string;
+  to?: string;
+  gas?: string | number;
+  gasPrice?: string | number;
+  value?: string | number;
+  data?: string;
+  nonce?: string | number;
+}
+
+export class LocalAccountsProvider extends ProviderWrapperWithChainId {
+  private _addressToPrivateKey: Map<string, Buffer> = new Map();
+
+  constructor(
+    provider: EIP1193Provider,
+    localAccountsHexPrivateKeys: string[]
+  ) {
+    super(provider);
+
+    this._initializePrivateKeys(localAccountsHexPrivateKeys);
+  }
+
+  public async request(args: RequestArguments): Promise<unknown> {
+    const {
+      ecsign,
+      hashPersonalMessage,
+      toRpcSig,
+      toBytes,
+      bytesToHex: bufferToHex,
+    } = await import("@nomicfoundation/ethereumjs-util");
+
+    if (
+      args.method === "eth_accounts" ||
+      args.method === "eth_requestAccounts"
+    ) {
+      return [...this._addressToPrivateKey.keys()];
+    }
+
+    const params = this._getParams(args);
+
+    if (args.method === "eth_sign") {
+      if (params.length > 0) {
+        const [address, data] = validateParams(params, rpcAddress, rpcData);
+
+        if (address !== undefined) {
+          if (data === undefined) {
+            throw new HardhatError(ERRORS.NETWORK.ETHSIGN_MISSING_DATA_PARAM);
+          }
+
+          const privateKey = this._getPrivateKeyForAddress(address);
+          const messageHash = hashPersonalMessage(toBytes(data));
+          const signature = ecsign(messageHash, privateKey);
+          return toRpcSig(signature.v, signature.r, signature.s);
+        }
+      }
+    }
+
+    if (args.method === "personal_sign") {
+      if (params.length > 0) {
+        const [data, address] = validateParams(params, rpcData, rpcAddress);
+
+        if (data !== undefined) {
+          if (address === undefined) {
+            throw new HardhatError(
+              ERRORS.NETWORK.PERSONALSIGN_MISSING_ADDRESS_PARAM
+            );
+          }
+
+          const privateKey = this._getPrivateKeyForAddress(address);
+          const messageHash = hashPersonalMessage(toBytes(data));
+          const signature = ecsign(messageHash, privateKey);
+          return toRpcSig(signature.v, signature.r, signature.s);
+        }
+      }
+    }
+
+    if (args.method === "eth_signTypedData_v4") {
+      const [address, data] = validateParams(params, rpcAddress, t.any);
+
+      if (data === undefined) {
+        throw new HardhatError(ERRORS.NETWORK.ETHSIGN_MISSING_DATA_PARAM);
+      }
+
+      let typedMessage = data;
+      if (typeof data === "string") {
+        try {
+          typedMessage = JSON.parse(data);
+        } catch {
+          throw new HardhatError(
+            ERRORS.NETWORK.ETHSIGN_TYPED_DATA_V4_INVALID_DATA_PARAM
+          );
+        }
+      }
+
+      // if we don't manage the address, the method is forwarded
+      const privateKey = this._getPrivateKeyForAddressOrNull(address);
+      if (privateKey !== null) {
+        return signTypedData({
+          privateKey,
+          version: SignTypedDataVersion.V4,
+          data: typedMessage,
+        });
+      }
+    }
+
+    if (args.method === "eth_sendTransaction" && params.length > 0) {
+      const [txRequest] = validateParams(params, rpcTransactionRequest);
+
+      if (txRequest.gas === undefined) {
+        throw new HardhatError(
+          ERRORS.NETWORK.MISSING_TX_PARAM_TO_SIGN_LOCALLY,
+          { param: "gas" }
+        );
+      }
+
+      if (txRequest.from === undefined) {
+        throw new HardhatError(
+          ERRORS.NETWORK.MISSING_TX_PARAM_TO_SIGN_LOCALLY,
+          { param: "from" }
+        );
+      }
+
+      const hasGasPrice = txRequest.gasPrice !== undefined;
+      const hasEip1559Fields =
+        txRequest.maxFeePerGas !== undefined ||
+        txRequest.maxPriorityFeePerGas !== undefined;
+
+      if (!hasGasPrice && !hasEip1559Fields) {
+        throw new HardhatError(ERRORS.NETWORK.MISSING_FEE_PRICE_FIELDS);
+      }
+
+      if (hasGasPrice && hasEip1559Fields) {
+        throw new HardhatError(ERRORS.NETWORK.INCOMPATIBLE_FEE_PRICE_FIELDS);
+      }
+
+      if (hasEip1559Fields && txRequest.maxFeePerGas === undefined) {
+        throw new HardhatError(
+          ERRORS.NETWORK.MISSING_TX_PARAM_TO_SIGN_LOCALLY,
+          { param: "maxFeePerGas" }
+        );
+      }
+
+      if (hasEip1559Fields && txRequest.maxPriorityFeePerGas === undefined) {
+        throw new HardhatError(
+          ERRORS.NETWORK.MISSING_TX_PARAM_TO_SIGN_LOCALLY,
+          { param: "maxPriorityFeePerGas" }
+        );
+      }
+
+      if (txRequest.nonce === undefined) {
+        txRequest.nonce = await this._getNonce(txRequest.from);
+      }
+
+      const privateKey = this._getPrivateKeyForAddress(txRequest.from!);
+
+      const chainId = await this._getChainId();
+
+      const rawTransaction = await this._getSignedTransaction(
+        txRequest,
+        chainId,
+        privateKey
+      );
+
+      return this._wrappedProvider.request({
+        method: "eth_sendRawTransaction",
+        params: [bufferToHex(rawTransaction)],
+      });
+    }
+
+    return this._wrappedProvider.request(args);
+  }
+
+  private _initializePrivateKeys(localAccountsHexPrivateKeys: string[]) {
+    const {
+      bytesToHex: bufferToHex,
+      toBytes,
+      privateToAddress,
+    } = require("@nomicfoundation/ethereumjs-util");
+
+    const privateKeys: Buffer[] = localAccountsHexPrivateKeys.map((h) =>
+      toBytes(h)
+    );
+
+    for (const pk of privateKeys) {
+      const address: string = bufferToHex(privateToAddress(pk)).toLowerCase();
+      this._addressToPrivateKey.set(address, pk);
+    }
+  }
+
+  private _getPrivateKeyForAddress(address: Buffer): Buffer {
+    const {
+      bytesToHex: bufferToHex,
+    } = require("@nomicfoundation/ethereumjs-util");
+    const pk = this._addressToPrivateKey.get(bufferToHex(address));
+    if (pk === undefined) {
+      throw new HardhatError(ERRORS.NETWORK.NOT_LOCAL_ACCOUNT, {
+        account: bufferToHex(address),
+      });
+    }
+
+    return pk;
+  }
+
+  private _getPrivateKeyForAddressOrNull(address: Buffer): Buffer | null {
+    try {
+      return this._getPrivateKeyForAddress(address);
+    } catch {
+      return null;
+    }
+  }
+
+  private async _getNonce(address: Buffer): Promise<bigint> {
+    const { bytesToHex: bufferToHex } = await import(
+      "@nomicfoundation/ethereumjs-util"
+    );
+
+    const response = (await this._wrappedProvider.request({
+      method: "eth_getTransactionCount",
+      params: [bufferToHex(address), "pending"],
+    })) as string;
+
+    return rpcQuantityToBigInt(response);
+  }
+
+  private async _getSignedTransaction(
+    transactionRequest: RpcTransactionRequest,
+    chainId: number,
+    privateKey: Buffer
+  ): Promise<Uint8Array> {
+    const { AccessListEIP2930Transaction, LegacyTransaction } = await import(
+      "@nomicfoundation/ethereumjs-tx"
+    );
+
+    const { Common } = await import("@nomicfoundation/ethereumjs-common");
+
+    const txData = {
+      ...transactionRequest,
+      gasLimit: transactionRequest.gas,
+    };
+
+    // We don't specify a hardfork here because the default hardfork should
+    // support all possible types of transactions.
+    // If the network doesn't support a given transaction type, then the
+    // transaction it will be rejected somewhere else.
+    const common = Common.custom({ chainId, networkId: chainId });
+
+    // we convert the access list to the type
+    // that AccessListEIP2930Transaction expects
+    const accessList = txData.accessList?.map(
+      ({ address, storageKeys }) => [address, storageKeys] as [Buffer, Buffer[]]
+    );
+
+    let transaction;
+    if (txData.maxFeePerGas !== undefined) {
+      transaction = FeeMarketEIP1559Transaction.fromTxData(
+        {
+          ...txData,
+          accessList,
+          gasPrice: undefined,
+        },
+        { common }
+      );
+    } else if (accessList !== undefined) {
+      transaction = AccessListEIP2930Transaction.fromTxData(
+        {
+          ...txData,
+          accessList,
+        },
+        { common }
+      );
+    } else {
+      transaction = LegacyTransaction.fromTxData(txData, { common });
+    }
+
+    const signedTransaction = transaction.sign(privateKey);
+
+    return signedTransaction.serialize();
+  }
+}
+
+export class HDWalletProvider extends LocalAccountsProvider {
+  constructor(
+    provider: EIP1193Provider,
+    mnemonic: string,
+    hdpath: string = "m/44'/60'/0'/0/",
+    initialIndex: number = 0,
+    count: number = 10,
+    passphrase: string = ""
+  ) {
+    // NOTE: If mnemonic has space or newline at the beginning or end, it will be trimmed.
+    // This is because mnemonic containing them may generate different private keys.
+    const trimmedMnemonic = mnemonic.trim();
+    const privateKeys = derivePrivateKeys(
+      trimmedMnemonic,
+      hdpath,
+      initialIndex,
+      count,
+      passphrase
+    );
+
+    const {
+      bytesToHex: bufferToHex,
+    } = require("@nomicfoundation/ethereumjs-util");
+    const privateKeysAsHex = privateKeys.map((pk) => bufferToHex(pk));
+    super(provider, privateKeysAsHex);
+  }
+}
+
+abstract class SenderProvider extends ProviderWrapper {
+  public async request(args: RequestArguments): Promise<unknown> {
+    const method = args.method;
+    const params = this._getParams(args);
+
+    if (
+      method === "eth_sendTransaction" ||
+      method === "eth_call" ||
+      method === "eth_estimateGas"
+    ) {
+      // TODO: Should we validate this type?
+      const tx: JsonRpcTransactionData = params[0];
+
+      if (tx !== undefined && tx.from === undefined) {
+        const senderAccount = await this._getSender();
+
+        if (senderAccount !== undefined) {
+          tx.from = senderAccount;
+        } else if (method === "eth_sendTransaction") {
+          throw new HardhatError(ERRORS.NETWORK.NO_REMOTE_ACCOUNT_AVAILABLE);
+        }
+      }
+    }
+
+    return this._wrappedProvider.request(args);
+  }
+
+  protected abstract _getSender(): Promise<string | undefined>;
+}
+
+export class AutomaticSenderProvider extends SenderProvider {
+  private _firstAccount: string | undefined;
+
+  protected async _getSender(): Promise<string | undefined> {
+    if (this._firstAccount === undefined) {
+      const accounts = (await this._wrappedProvider.request({
+        method: "eth_accounts",
+      })) as string[];
+
+      this._firstAccount = accounts[0];
+    }
+
+    return this._firstAccount;
+  }
+}
+
+export class FixedSenderProvider extends SenderProvider {
+  constructor(provider: EIP1193Provider, private readonly _sender: string) {
+    super(provider);
+  }
+
+  protected async _getSender(): Promise<string | undefined> {
+    return this._sender;
+  }
+}

package/src/internal/core/providers/backwards-compatibility.ts

@@ -0,0 +1,80 @@
+import util from "util";
+
+import {
+  EIP1193Provider,
+  EthereumProvider,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  RequestArguments,
+} from "../../../types";
+import { EventEmitterWrapper } from "../../util/event-emitter";
+
+/**
+ * Hardhat predates the EIP1193 (Javascript Ethereum Provider) standard. It was
+ * built following a draft of that spec, but then it changed completely. We
+ * still need to support the draft api, but internally we use EIP1193. So we
+ * use BackwardsCompatibilityProviderAdapter to wrap EIP1193 providers before
+ * exposing them to the user.
+ */
+export class BackwardsCompatibilityProviderAdapter
+  extends EventEmitterWrapper
+  implements EthereumProvider
+{
+  constructor(private readonly _provider: EIP1193Provider) {
+    super(_provider);
+    // We bind everything here because some test suits break otherwise
+    this.sendAsync = this.sendAsync.bind(this) as any;
+    this.send = this.send.bind(this) as any;
+    this._sendJsonRpcRequest = this._sendJsonRpcRequest.bind(this) as any;
+  }
+
+  public request(args: RequestArguments): Promise<unknown> {
+    return this._provider.request(args);
+  }
+
+  public send(method: string, params?: any[]): Promise<any> {
+    return this._provider.request({ method, params });
+  }
+
+  public sendAsync(
+    payload: JsonRpcRequest,
+    callback: (error: any, response: JsonRpcResponse) => void
+  ): void {
+    util.callbackify(() => this._sendJsonRpcRequest(payload))(callback);
+  }
+
+  private async _sendJsonRpcRequest(
+    request: JsonRpcRequest
+  ): Promise<JsonRpcResponse> {
+    const response: JsonRpcResponse = {
+      id: request.id,
+      jsonrpc: "2.0",
+    };
+
+    try {
+      response.result = await this._provider.request({
+        method: request.method,
+        params: request.params,
+      });
+    } catch (error: any) {
+      if (error.code === undefined) {
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw error;
+      }
+
+      response.error = {
+        // This might be a mistake, but I'm leaving it as is just in case,
+        // because it's not obvious what we should do here.
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        code: error.code ? +error.code : -1,
+        message: error.message,
+        data: {
+          stack: error.stack,
+          name: error.name,
+        },
+      };
+    }
+
+    return response;
+  }
+}

package/src/internal/core/providers/chainId.ts

@@ -0,0 +1,68 @@
+import { EIP1193Provider, RequestArguments } from "../../../types";
+import { HardhatError } from "../errors";
+import { ERRORS } from "../errors-list";
+import { rpcQuantityToNumber } from "../jsonrpc/types/base-types";
+
+import { ProviderWrapper } from "./wrapper";
+
+export abstract class ProviderWrapperWithChainId extends ProviderWrapper {
+  private _chainId: number | undefined;
+
+  protected async _getChainId(): Promise<number> {
+    if (this._chainId === undefined) {
+      try {
+        this._chainId = await this._getChainIdFromEthChainId();
+      } catch {
+        // If eth_chainId fails we default to net_version
+        this._chainId = await this._getChainIdFromEthNetVersion();
+      }
+    }
+
+    return this._chainId;
+  }
+
+  private async _getChainIdFromEthChainId(): Promise<number> {
+    const id = (await this._wrappedProvider.request({
+      method: "eth_chainId",
+    })) as string;
+
+    return rpcQuantityToNumber(id);
+  }
+
+  private async _getChainIdFromEthNetVersion(): Promise<number> {
+    const id = (await this._wrappedProvider.request({
+      method: "net_version",
+    })) as string;
+
+    // There's a node returning this as decimal instead of QUANTITY.
+    // TODO: Document here which node does that
+    return id.startsWith("0x") ? rpcQuantityToNumber(id) : parseInt(id, 10);
+  }
+}
+
+export class ChainIdValidatorProvider extends ProviderWrapperWithChainId {
+  private _alreadyValidated = false;
+
+  constructor(
+    provider: EIP1193Provider,
+    private readonly _expectedChainId: number
+  ) {
+    super(provider);
+  }
+
+  public async request(args: RequestArguments): Promise<unknown> {
+    if (!this._alreadyValidated) {
+      const actualChainId = await this._getChainId();
+      if (actualChainId !== this._expectedChainId) {
+        throw new HardhatError(ERRORS.NETWORK.INVALID_GLOBAL_CHAIN_ID, {
+          configChainId: this._expectedChainId,
+          connectionChainId: actualChainId,
+        });
+      }
+
+      this._alreadyValidated = true;
+    }
+
+    return this._wrappedProvider.request(args);
+  }
+}