hardhat 2.10.1 → 2.11.0-dev.0

package/src/internal/hardhat-network/provider/types/HardhatBlockchainInterface.ts

@@ -1,6 +1,5 @@
-import { Block } from "@ethereumjs/block";
-import { BlockchainInterface } from "@ethereumjs/blockchain";
-import { BN } from "ethereumjs-util";
+import { Block } from "@ignored/block";
+import { BlockchainInterface } from "@ignored/blockchain";
 
 import { FilterParams } from "../node-types";
 import { RpcLogOutput, RpcReceiptOutput } from "../output";
@@ -8,18 +7,18 @@ import { RpcLogOutput, RpcReceiptOutput } from "../output";
 export interface HardhatBlockchainInterface extends BlockchainInterface {
   addTransactionReceipts(receipts: RpcReceiptOutput[]): void;
   reserveBlocks(
-    count: BN,
-    interval: BN,
+    count: bigint,
+    interval: bigint,
     previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: BN,
-    previousBlockBaseFeePerGas: BN | undefined
+    previousBlockTotalDifficulty: bigint,
+    previousBlockBaseFeePerGas: bigint | undefined
   ): void;
   deleteLaterBlocks(block: Block): void;
   getBlockByTransactionHash(transactionHash: Buffer): Promise<Block | null>;
   getLatestBlock(): Promise<Block>;
-  getLatestBlockNumber(): BN;
+  getLatestBlockNumber(): bigint;
   getLogs(filterParams: FilterParams): Promise<RpcLogOutput[]>;
-  getTotalDifficulty(blockHash: Buffer): Promise<BN>;
+  getTotalDifficulty(blockHash: Buffer): Promise<bigint>;
   getTransactionReceipt(
     transactionHash: Buffer
   ): Promise<RpcReceiptOutput | null>;

package/src/internal/hardhat-network/provider/utils/getCurrentTimestamp.ts

@@ -1,3 +1,7 @@
 export function getCurrentTimestamp(): number {
   return Math.ceil(new Date().getTime() / 1000);
 }
+
+export function getCurrentTimestampBigInt(): bigint {
+  return BigInt(getCurrentTimestamp());
+}

package/src/internal/hardhat-network/provider/utils/makeAccount.ts

@@ -1,22 +1,16 @@
-import {
-  Account,
-  Address,
-  BN,
-  privateToAddress,
-  toBuffer,
-} from "ethereumjs-util";
+import { Account, Address, privateToAddress, toBuffer } from "@ignored/util";
 
 import { GenesisAccount } from "../node-types";
 
 import { isHexPrefixed } from "./isHexPrefixed";
 
 export function makeAccount(ga: GenesisAccount) {
-  let balance: BN;
+  let balance: bigint;
 
   if (typeof ga.balance === "string" && isHexPrefixed(ga.balance)) {
-    balance = new BN(toBuffer(ga.balance));
+    balance = BigInt(ga.balance);
   } else {
-    balance = new BN(ga.balance);
+    balance = BigInt(ga.balance);
   }
 
   const account = Account.fromAccountData({ balance });

package/src/internal/hardhat-network/provider/utils/makeCommon.ts

@@ -1,43 +1,17 @@
-import Common from "@ethereumjs/common";
-import { bufferToHex } from "ethereumjs-util";
+import { Common } from "@ignored/common";
 
-import { dateToTimestampSeconds } from "../../../util/date";
 import { LocalNodeConfig } from "../node-types";
 
-import { getCurrentTimestamp } from "./getCurrentTimestamp";
-
-export function makeCommon(
-  {
-    initialDate,
-    chainId,
-    networkId,
-    networkName,
-    blockGasLimit,
-    hardfork,
-  }: LocalNodeConfig,
-  stateTrie: any
-) {
-  const initialBlockTimestamp =
-    initialDate !== undefined
-      ? dateToTimestampSeconds(initialDate)
-      : getCurrentTimestamp();
-
-  return Common.forCustomChain(
-    "mainnet",
+export function makeCommon({ chainId, networkId, hardfork }: LocalNodeConfig) {
+  const common = Common.custom(
     {
       chainId,
       networkId,
-      name: networkName,
-      genesis: {
-        timestamp: `0x${initialBlockTimestamp.toString(16)}`,
-        hash: "0x",
-        gasLimit: blockGasLimit,
-        difficulty: 1,
-        nonce: "0x0000000000000042",
-        extraData: "0x1234",
-        stateRoot: bufferToHex(stateTrie.root),
-      },
     },
-    hardfork
+    {
+      hardfork,
+    }
   );
+
+  return common;
 }

package/src/internal/hardhat-network/provider/utils/makeForkClient.ts

@@ -1,5 +1,4 @@
 import chalk from "chalk";
-import { BN, toBuffer } from "ethereumjs-util";
 
 import { HARDHAT_NETWORK_NAME } from "../../../constants";
 import {
@@ -28,7 +27,7 @@ export async function makeForkClient(
   forkCachePath?: string
 ): Promise<{
   forkClient: JsonRpcClient;
-  forkBlockNumber: BN;
+  forkBlockNumber: bigint;
   forkBlockTimestamp: number;
 }> {
   const provider = new HttpProvider(
@@ -55,8 +54,8 @@ export async function makeForkClient(
     }
 
     if (forkConfig.blockNumber > lastSafeBlock) {
-      const confirmations = latestBlock - forkConfig.blockNumber + 1;
-      const requiredConfirmations = maxReorg + 1;
+      const confirmations = latestBlock - BigInt(forkConfig.blockNumber) + 1n;
+      const requiredConfirmations = maxReorg + 1n;
       console.warn(
         chalk.yellow(
           `You are forking from block ${
@@ -69,9 +68,9 @@ Please use block number ${lastSafeBlock} or wait for the block to get ${
       );
     }
 
-    forkBlockNumber = new BN(forkConfig.blockNumber);
+    forkBlockNumber = BigInt(forkConfig.blockNumber);
   } else {
-    forkBlockNumber = new BN(lastSafeBlock);
+    forkBlockNumber = BigInt(lastSafeBlock);
   }
 
   const block = await getBlockByNumber(provider, forkBlockNumber);
@@ -96,7 +95,7 @@ Please use block number ${lastSafeBlock} or wait for the block to get ${
 
 async function getBlockByNumber(
   provider: HttpProvider,
-  blockNumber: BN
+  blockNumber: bigint
 ): Promise<RpcBlockOutput> {
   const rpcBlockOutput = (await provider.request({
     method: "eth_getBlockByNumber",
@@ -118,6 +117,6 @@ async function getLatestBlockNumber(provider: HttpProvider) {
     method: "eth_blockNumber",
   })) as string;
 
-  const latestBlock = new BN(toBuffer(latestBlockString));
-  return latestBlock.toNumber();
+  const latestBlock = BigInt(latestBlockString);
+  return latestBlock;
 }

package/src/internal/hardhat-network/provider/utils/makeStateTrie.ts

@@ -1,5 +1,5 @@
-import { Account, BN } from "ethereumjs-util";
-import { SecureTrie as Trie } from "merkle-patricia-tree";
+import { SecureTrie as Trie } from "@ignored/trie";
+import { Account, intToBuffer, setLengthLeft } from "@ignored/util";
 
 import { GenesisAccount } from "../node-types";
 
@@ -16,7 +16,7 @@ export async function makeStateTrie(genesisAccounts: GenesisAccount[]) {
   // Mimic precompiles activation
   for (let i = 1; i <= 8; i++) {
     await stateTrie.put(
-      new BN(i).toArrayLike(Buffer, "be", 20),
+      setLengthLeft(intToBuffer(i), 20),
       new Account().serialize()
     );
   }

package/src/internal/hardhat-network/provider/utils/putGenesisBlock.ts

@@ -1,25 +1,53 @@
-import { Block, HeaderData } from "@ethereumjs/block";
-import Common from "@ethereumjs/common";
-import { BN } from "ethereumjs-util";
+import { Block, HeaderData } from "@ignored/block";
+import { Common } from "@ignored/common";
+import { SecureTrie } from "@ignored/trie";
+import { bufferToHex } from "@ignored/util";
 
+import { dateToTimestampSeconds } from "../../../util/date";
+import { hardforkGte, HardforkName } from "../../../util/hardforks";
 import { HardhatBlockchain } from "../HardhatBlockchain";
+import { LocalNodeConfig } from "../node-types";
+import { getCurrentTimestamp } from "./getCurrentTimestamp";
 
 export async function putGenesisBlock(
   blockchain: HardhatBlockchain,
   common: Common,
-  initialBaseFee?: BN
+  { initialDate, blockGasLimit }: LocalNodeConfig,
+  stateTrie: SecureTrie,
+  hardfork: HardforkName,
+  initialMixHash: Buffer,
+  initialBaseFee?: bigint
 ) {
-  const header: HeaderData = {};
+  const initialBlockTimestamp =
+    initialDate !== undefined
+      ? dateToTimestampSeconds(initialDate)
+      : getCurrentTimestamp();
+
+  const isPostMerge = hardforkGte(hardfork, HardforkName.MERGE);
+
+  const header: HeaderData = {
+    timestamp: `0x${initialBlockTimestamp.toString(16)}`,
+    gasLimit: blockGasLimit,
+    difficulty: isPostMerge ? 0 : 1,
+    nonce: isPostMerge ? "0x0000000000000000" : "0x0000000000000042",
+    extraData: "0x1234",
+    stateRoot: bufferToHex(stateTrie.root),
+  };
+
+  if (isPostMerge) {
+    header.mixHash = initialMixHash;
+  }
 
   if (initialBaseFee !== undefined) {
     header.baseFeePerGas = initialBaseFee;
   }
 
-  const genesisBlock = Block.genesis(
+  const genesisBlock = Block.fromBlockData(
     {
       header,
     },
     { common }
   );
+
   await blockchain.putBlock(genesisBlock);
 }

package/src/internal/hardhat-network/provider/utils/random.ts

@@ -0,0 +1,54 @@
+import type EthereumjsUtilT from "@ignored/util";
+import type EthereumCryptographyKeccakT from "ethereum-cryptography/keccak";
+
+export class RandomBufferGenerator {
+  private constructor(private _nextValue: Uint8Array) {}
+
+  public static create(seed: string): RandomBufferGenerator {
+    const { bufArrToArr } = require("@ignored/util") as typeof EthereumjsUtilT;
+    const { keccak256 } =
+      require("ethereum-cryptography/keccak") as typeof EthereumCryptographyKeccakT;
+
+    const nextValue = keccak256(bufArrToArr(Buffer.from(seed)));
+
+    return new RandomBufferGenerator(nextValue);
+  }
+
+  public next(): Buffer {
+    const { arrToBufArr } = require("@ignored/util") as typeof EthereumjsUtilT;
+    const { keccak256 } =
+      require("ethereum-cryptography/keccak") as typeof EthereumCryptographyKeccakT;
+
+    const valueToReturn = this._nextValue;
+
+    this._nextValue = keccak256(this._nextValue);
+
+    return arrToBufArr(valueToReturn);
+  }
+
+  public clone(): RandomBufferGenerator {
+    return new RandomBufferGenerator(this._nextValue);
+  }
+}
+
+export const randomHash = () => {
+  const { bufferToHex } = require("@ignored/util") as typeof EthereumjsUtilT;
+  return bufferToHex(randomHashBuffer());
+};
+
+const generator = RandomBufferGenerator.create("seed");
+export const randomHashBuffer = (): Buffer => {
+  return generator.next();
+};
+
+export const randomAddress = () => {
+  const { Address } = require("@ignored/util") as typeof EthereumjsUtilT;
+  return new Address(randomAddressBuffer());
+};
+
+export const randomAddressString = () => {
+  const { bufferToHex } = require("@ignored/util") as typeof EthereumjsUtilT;
+  return bufferToHex(randomAddressBuffer());
+};
+
+export const randomAddressBuffer = () => randomHashBuffer().slice(0, 20);

package/src/internal/hardhat-network/provider/utils/reorganizeTransactionsLists.ts

@@ -1,6 +1,5 @@
-import { BN } from "ethereumjs-util";
-
 import { InternalError } from "../../../core/providers/errors";
+import { BigIntUtils } from "../../../util/bigint";
 import { SenderTransactions, SerializedTransaction } from "../PoolState";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
@@ -14,24 +13,24 @@ import { SenderTransactions, SerializedTransaction } from "../PoolState";
 export function reorganizeTransactionsLists(
   pending: SenderTransactions,
   queued: SenderTransactions,
-  retrieveNonce: (serializedTx: SerializedTransaction) => BN
+  retrieveNonce: (serializedTx: SerializedTransaction) => bigint
 ) {
   let newPending = pending;
-  let newQueued = queued.sortBy(retrieveNonce, (l, r) => l.cmp(r));
+  let newQueued = queued.sortBy(retrieveNonce, (l, r) => BigIntUtils.cmp(l, r));
 
   if (pending.last() === undefined) {
     throw new InternalError("Pending list cannot be empty");
   }
 
-  const nextPendingNonce = retrieveNonce(pending.last()).addn(1);
+  let nextPendingNonce = retrieveNonce(pending.last()) + 1n;
 
   let movedCount = 0;
   for (const queuedTx of newQueued) {
     const queuedTxNonce = retrieveNonce(queuedTx);
 
-    if (nextPendingNonce.eq(queuedTxNonce)) {
+    if (nextPendingNonce === queuedTxNonce) {
       newPending = newPending.push(queuedTx);
-      nextPendingNonce.iaddn(1);
+      nextPendingNonce++;
       movedCount++;
     } else {
       break;

package/src/internal/hardhat-network/provider/utils/reorgs-protection.ts

@@ -5,36 +5,36 @@
  * If there's not such a number, or we aren't aware of it, this function
  * returns undefined.
  */
-export function getLargestPossibleReorg(networkId: number): number | undefined {
+export function getLargestPossibleReorg(networkId: number): bigint | undefined {
   // mainnet
   if (networkId === 1) {
-    return 5;
+    return 5n;
   }
 
   // Kovan
   if (networkId === 42) {
-    return 5;
+    return 5n;
   }
 
   // Goerli
   if (networkId === 5) {
-    return 5;
+    return 5n;
   }
 
   // Rinkeby
   if (networkId === 4) {
-    return 5;
+    return 5n;
   }
 
   // Ropsten
   if (networkId === 3) {
-    return 100;
+    return 100n;
   }
 
   // xDai
   if (networkId === 100) {
-    return 38;
+    return 38n;
   }
 }
 
-export const FALLBACK_MAX_REORG = 30;
+export const FALLBACK_MAX_REORG = 30n;

package/src/internal/hardhat-network/stack-traces/consoleLogger.ts

@@ -1,4 +1,9 @@
-import { BN, bufferToHex, bufferToInt, fromSigned } from "ethereumjs-util";
+import {
+  bufferToBigInt,
+  bufferToHex,
+  bufferToInt,
+  fromSigned,
+} from "@ignored/util";
 import util from "util";
 
 import {
@@ -38,9 +43,9 @@ import {
   Bytes9Ty,
   BytesTy,
   ConsoleLogs,
-  IntTy,
+  Int256Ty,
   StringTy,
-  UintTy,
+  Uint256Ty,
 } from "./logger";
 import {
   CallMessageTrace,
@@ -77,6 +82,11 @@ export class ConsoleLogger {
         return "";
       }
 
+      // special case for console.log()
+      if (log.length === 0) {
+        return "";
+      }
+
       return util.format(log[0], ...log.slice(1));
     });
   }
@@ -131,12 +141,12 @@ export class ConsoleLogger {
     return types.map((type, i) => {
       const position = i * 32;
       switch (types[i]) {
-        case UintTy:
-          return new BN(
+        case Uint256Ty:
+          return bufferToBigInt(
             data.slice(position, position + REGISTER_SIZE)
           ).toString(10);
 
-        case IntTy:
+        case Int256Ty:
           return fromSigned(
             data.slice(position, position + REGISTER_SIZE)
           ).toString();

package/src/internal/hardhat-network/stack-traces/contracts-identifier.ts

@@ -1,4 +1,4 @@
-import { bufferToHex } from "ethereumjs-util";
+import { bufferToHex } from "@ignored/util";
 
 import {
   normalizeLibraryRuntimeBytecodeIfNecessary,

package/src/internal/hardhat-network/stack-traces/debug.ts

@@ -1,4 +1,4 @@
-import { bufferToHex } from "ethereumjs-util";
+import { bufferToHex } from "@ignored/util";
 
 import {
   CallMessageTrace,

package/src/internal/hardhat-network/stack-traces/error-inferrer.ts

@@ -1,6 +1,5 @@
-import { ERROR } from "@ethereumjs/vm/dist/exceptions";
+import { ERROR } from "@ignored/evm/dist/exceptions";
 import { defaultAbiCoder as abi } from "@ethersproject/abi";
-import { BN } from "ethereumjs-util";
 import semver from "semver";
 
 import { AbiHelpers } from "../../util/abi-helpers";
@@ -493,7 +492,7 @@ export class ErrorInferrer {
     // if the error comes from a call to a zero-initialized function,
     // we remove the last frame, which represents the call, to avoid
     // having duplicated frames
-    if (errorCode.eqn(0x51)) {
+    if (errorCode === 0x51) {
       stacktrace.splice(-1);
     }
 
@@ -524,6 +523,11 @@ export class ErrorInferrer {
 
     let errorMessage = "reverted with an unrecognized custom error";
 
+    const selector = returnData.getSelector();
+    if (selector !== undefined) {
+      errorMessage += ` with selector ${selector}`;
+    }
+
     for (const customError of trace.bytecode.contract.customErrors) {
       if (returnData.matchesSelector(customError.selector)) {
         // if the return data matches a custom error in the called contract,
@@ -762,7 +766,7 @@ export class ErrorInferrer {
       return false;
     }
 
-    if (trace.value.lten(0)) {
+    if (trace.value <= 0n) {
       return false;
     }
 
@@ -859,7 +863,7 @@ export class ErrorInferrer {
       return false;
     }
 
-    if (trace.value.lten(0)) {
+    if (trace.value <= 0n) {
       return false;
     }
 
@@ -913,7 +917,7 @@ export class ErrorInferrer {
     }
 
     return (
-      trace.value.gtn(0) &&
+      trace.value > 0n &&
       (constructor.isPayable === undefined || !constructor.isPayable)
     );
   }
@@ -1121,7 +1125,7 @@ export class ErrorInferrer {
   private _instructionWithinFunctionToPanicStackTraceEntry(
     trace: DecodedEvmMessageTrace,
     inst: Instruction,
-    errorCode: BN
+    errorCode: number
   ): PanicErrorStackTraceEntry {
     return {
       type: StackTraceEntryType.PANIC_ERROR,