hardhat 2.11.0-dev.0 → 2.11.0

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

@@ -1,7 +1,7 @@
 import * as t from "io-ts";
 
 import { SignTypedDataVersion, signTypedData } from "@metamask/eth-sig-util";
-import { FeeMarketEIP1559Transaction } from "@ignored/tx";
+import { FeeMarketEIP1559Transaction } from "@nomicfoundation/ethereumjs-tx";
 import { EIP1193Provider, RequestArguments } from "../../../types";
 import { HardhatError } from "../errors";
 import { ERRORS } from "../errors-list";
@@ -44,7 +44,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
 
   public async request(args: RequestArguments): Promise<unknown> {
     const { ecsign, hashPersonalMessage, toRpcSig, toBuffer, bufferToHex } =
-      await import("@ignored/util");
+      await import("@nomicfoundation/ethereumjs-util");
 
     if (
       args.method === "eth_accounts" ||
@@ -192,7 +192,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
       bufferToHex,
       toBuffer,
       privateToAddress,
-    } = require("@ignored/util");
+    } = require("@nomicfoundation/ethereumjs-util");
 
     const privateKeys: Buffer[] = localAccountsHexPrivateKeys.map((h) =>
       toBuffer(h)
@@ -205,7 +205,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   }
 
   private _getPrivateKeyForAddress(address: Buffer): Buffer {
-    const { bufferToHex } = require("@ignored/util");
+    const { bufferToHex } = require("@nomicfoundation/ethereumjs-util");
     const pk = this._addressToPrivateKey.get(bufferToHex(address));
     if (pk === undefined) {
       throw new HardhatError(ERRORS.NETWORK.NOT_LOCAL_ACCOUNT, {
@@ -225,7 +225,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   }
 
   private async _getNonce(address: Buffer): Promise<bigint> {
-    const { bufferToHex } = await import("@ignored/util");
+    const { bufferToHex } = await import("@nomicfoundation/ethereumjs-util");
 
     const response = (await this._wrappedProvider.request({
       method: "eth_getTransactionCount",
@@ -241,10 +241,10 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
     privateKey: Buffer
   ): Promise<Buffer> {
     const { AccessListEIP2930Transaction, Transaction } = await import(
-      "@ignored/tx"
+      "@nomicfoundation/ethereumjs-tx"
     );
 
-    const { Common } = await import("@ignored/common");
+    const { Common } = await import("@nomicfoundation/ethereumjs-common");
 
     const txData = {
       ...transactionRequest,
@@ -308,7 +308,7 @@ export class HDWalletProvider extends LocalAccountsProvider {
       passphrase
     );
 
-    const { bufferToHex } = require("@ignored/util");
+    const { bufferToHex } = require("@nomicfoundation/ethereumjs-util");
     const privateKeysAsHex = privateKeys.map((pk) => bufferToHex(pk));
     super(provider, privateKeysAsHex);
   }

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

@@ -11,14 +11,13 @@ import type {
   ProjectPathsConfig,
 } from "../../../types";
 
-import { HARDHAT_NETWORK_NAME } from "../../constants";
-import { ModulesLogger } from "../../hardhat-network/provider/modules/logger";
-import {
+import type {
   ForkConfig,
   MempoolOrder,
 } from "../../hardhat-network/provider/node-types";
-import { getForkCacheDirPath } from "../../hardhat-network/provider/utils/disk-cache";
-import { BigIntUtils } from "../../util/bigint";
+import type * as ModulesLoggerT from "../../hardhat-network/provider/modules/logger";
+import type * as DiskCacheT from "../../hardhat-network/provider/utils/disk-cache";
+import { HARDHAT_NETWORK_NAME } from "../../constants";
 import { parseDateString } from "../../util/date";
 
 import { normalizeHardhatNetworkAccountsConfig } from "./util";
@@ -72,9 +71,7 @@ export function createProvider(
     ) {
       forkConfig = {
         jsonRpcUrl: hardhatNetConfig.forking?.url,
-        blockNumber: BigIntUtils.mapBigIntToNumber(
-          hardhatNetConfig.forking?.blockNumber
-        ),
+        blockNumber: hardhatNetConfig.forking?.blockNumber,
         httpHeaders: hardhatNetConfig.forking.httpHeaders,
       };
     }
@@ -83,6 +80,11 @@ export function createProvider(
       hardhatNetConfig.accounts
     );
 
+    const { ModulesLogger } =
+      require("../../hardhat-network/provider/modules/logger") as typeof ModulesLoggerT;
+    const { getForkCacheDirPath } =
+      require("../../hardhat-network/provider/utils/disk-cache") as typeof DiskCacheT;
+
     eip1193Provider = new HardhatNetworkProvider(
       hardhatNetConfig.hardfork,
       HARDHAT_NETWORK_NAME,

package/src/internal/core/providers/gas-providers.ts

@@ -10,7 +10,7 @@ import { ProviderWrapper } from "./wrapper";
 const DEFAULT_GAS_MULTIPLIER = 1;
 
 export class FixedGasProvider extends ProviderWrapper {
-  constructor(provider: EIP1193Provider, private readonly _gasLimit: bigint) {
+  constructor(provider: EIP1193Provider, private readonly _gasLimit: number) {
     super(provider);
   }
 
@@ -30,7 +30,7 @@ export class FixedGasProvider extends ProviderWrapper {
 }
 
 export class FixedGasPriceProvider extends ProviderWrapper {
-  constructor(provider: EIP1193Provider, private readonly _gasPrice: bigint) {
+  constructor(provider: EIP1193Provider, private readonly _gasPrice: number) {
     super(provider);
   }
 

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

@@ -53,7 +53,7 @@ export function normalizeHardhatNetworkAccountsConfig(
     return accountsConfig;
   }
 
-  const { bufferToHex } = require("@ignored/util");
+  const { bufferToHex } = require("@nomicfoundation/ethereumjs-util");
 
   return derivePrivateKeys(
     accountsConfig.mnemonic,

package/src/internal/core/runtime-environment.ts

@@ -25,13 +25,21 @@ import { HardhatError } from "./errors";
 import { ERRORS } from "./errors-list";
 import { createProvider } from "./providers/construction";
 import { OverriddenTaskDefinition } from "./tasks/task-definitions";
+import {
+  completeTaskProfile,
+  createParentTaskProfile,
+  createTaskProfile,
+  TaskProfile,
+} from "./task-profiling";
 
 const log = debug("hardhat:core:hre");
 
 export class Environment implements HardhatRuntimeEnvironment {
   private static readonly _BLACKLISTED_PROPERTIES: string[] = [
     "injectToGlobal",
+    "entryTaskProfile",
     "_runTaskDefinition",
+    "_extenders",
   ];
 
   public network: Network;
@@ -40,6 +48,8 @@ export class Environment implements HardhatRuntimeEnvironment {
 
   private readonly _extenders: EnvironmentExtender[];
 
+  public entryTaskProfile?: TaskProfile;
+
   /**
    * Initializes the Hardhat Runtime Environment and the given
    * extender functions.
@@ -111,7 +121,11 @@ export class Environment implements HardhatRuntimeEnvironment {
    * @throws a HH303 if there aren't any defined tasks with the given name.
    * @returns a promise with the task's execution result.
    */
-  public readonly run: RunTaskFunction = async (name, taskArguments = {}) => {
+  public readonly run: RunTaskFunction = async (
+    name,
+    taskArguments = {},
+    callerTaskProfile?: TaskProfile
+  ) => {
     const taskDefinition = this.tasks[name];
 
     log("Running task %s", name);
@@ -127,16 +141,32 @@ export class Environment implements HardhatRuntimeEnvironment {
       taskArguments
     );
 
+    let taskProfile: TaskProfile | undefined;
+    if (this.hardhatArguments.flamegraph === true) {
+      taskProfile = createTaskProfile(name);
+
+      if (callerTaskProfile !== undefined) {
+        callerTaskProfile.children.push(taskProfile);
+      } else {
+        this.entryTaskProfile = taskProfile;
+      }
+    }
+
     try {
       return await this._runTaskDefinition(
         taskDefinition,
-        resolvedTaskArguments
+        resolvedTaskArguments,
+        taskProfile
       );
     } catch (e) {
       analyzeModuleNotFoundError(e, this.config.paths.configFile);
 
       // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
       throw e;
+    } finally {
+      if (taskProfile !== undefined) {
+        completeTaskProfile(taskProfile);
+      }
     }
   };
 
@@ -178,10 +208,15 @@ export class Environment implements HardhatRuntimeEnvironment {
     };
   }
 
+  /**
+   * @param taskProfile Undefined if we aren't computing task profiles
+   * @private
+   */
   private async _runTaskDefinition(
     taskDefinition: TaskDefinition,
-    taskArguments: TaskArguments
-  ) {
+    taskArguments: TaskArguments,
+    taskProfile?: TaskProfile
+  ): Promise<any> {
     let runSuperFunction: any;
 
     if (taskDefinition instanceof OverriddenTaskDefinition) {
@@ -190,10 +225,25 @@ export class Environment implements HardhatRuntimeEnvironment {
       ) => {
         log("Running %s's super", taskDefinition.name);
 
-        return this._runTaskDefinition(
-          taskDefinition.parentTaskDefinition,
-          _taskArguments
-        );
+        if (taskProfile === undefined) {
+          return this._runTaskDefinition(
+            taskDefinition.parentTaskDefinition,
+            _taskArguments
+          );
+        }
+
+        const parentTaskProfile = createParentTaskProfile(taskProfile);
+        taskProfile.children.push(parentTaskProfile);
+
+        try {
+          return await this._runTaskDefinition(
+            taskDefinition.parentTaskDefinition,
+            _taskArguments,
+            parentTaskProfile
+          );
+        } finally {
+          completeTaskProfile(parentTaskProfile);
+        }
       };
 
       runSuperFunction.isDefined = true;
@@ -213,10 +263,53 @@ export class Environment implements HardhatRuntimeEnvironment {
     const previousRunSuper: any = globalAsAny.runSuper;
     globalAsAny.runSuper = runSuper;
 
-    const uninjectFromGlobal = this.injectToGlobal();
+    let modifiedHreWithParentTaskProfile: any | undefined;
+    if (this.hardhatArguments.flamegraph === true) {
+      // We create a modified version of `this`, as we want to keep track of the
+      // `taskProfile` and use it as `callerTaskProfile` if the action calls
+      // `run`, and add a few utility methods.
+      //
+      // Note that for this to work we need to set the prototype later
+      modifiedHreWithParentTaskProfile = {
+        ...this,
+        run: (_name: string, _taskArguments: TaskArguments) =>
+          (this as any).run(_name, _taskArguments, taskProfile),
+        adhocProfile: async (_name: string, f: () => Promise<any>) => {
+          const adhocProfile = createTaskProfile(_name);
+          taskProfile!.children.push(adhocProfile);
+          try {
+            return await f();
+          } finally {
+            completeTaskProfile(adhocProfile);
+          }
+        },
+        adhocProfileSync: (_name: string, f: () => any) => {
+          const adhocProfile = createTaskProfile(_name);
+          taskProfile!.children.push(adhocProfile);
+          try {
+            return f();
+          } finally {
+            completeTaskProfile(adhocProfile);
+          }
+        },
+      };
+
+      Object.setPrototypeOf(
+        modifiedHreWithParentTaskProfile,
+        Object.getPrototypeOf(this)
+      );
+    }
+
+    const uninjectFromGlobal =
+      modifiedHreWithParentTaskProfile?.injectToGlobal() ??
+      this.injectToGlobal();
 
     try {
-      return await taskDefinition.action(taskArguments, this, runSuper);
+      return await taskDefinition.action(
+        taskArguments,
+        modifiedHreWithParentTaskProfile ?? this,
+        runSuper
+      );
     } finally {
       uninjectFromGlobal();
       globalAsAny.runSuper = previousRunSuper;

package/src/internal/core/task-profiling.ts

@@ -0,0 +1,56 @@
+export interface TaskProfile {
+  name: string;
+  start: bigint;
+  end?: bigint;
+  children: TaskProfile[];
+  parallel?: boolean;
+}
+
+export function createTaskProfile(name: string): TaskProfile {
+  return {
+    name,
+    start: process.hrtime.bigint(),
+    children: [],
+  };
+}
+
+export function completeTaskProfile(taskProfile: TaskProfile) {
+  taskProfile.end = process.hrtime.bigint();
+}
+
+export function createParentTaskProfile(taskProfile: TaskProfile): TaskProfile {
+  return createTaskProfile(`super::${taskProfile.name}`);
+}
+
+/**
+ * Sets `parallel` to `true` to any children that was running at the same time
+ * of another.
+ *
+ * We assume `children[]` is in chronological `start` order.
+ */
+export function flagParallelChildren(
+  profile: TaskProfile,
+  isParentParallel = false
+) {
+  if (isParentParallel) {
+    profile.parallel = true;
+    for (const child of profile.children) {
+      child.parallel = true;
+    }
+  } else {
+    for (const [i, child] of profile.children.entries()) {
+      if (i === 0) {
+        continue;
+      }
+      const prevChild = profile.children[i - 1];
+      if (child.start < prevChild.end!) {
+        prevChild.parallel = true;
+        child.parallel = true;
+      }
+    }
+  }
+
+  for (const child of profile.children) {
+    flagParallelChildren(child, child.parallel);
+  }
+}

package/src/internal/core/typescript-support.ts

@@ -38,7 +38,10 @@ export function isTypescriptSupported() {
   return cachedIsTypescriptSupported;
 }
 
-export function loadTsNode(tsConfigPath?: string) {
+export function loadTsNode(
+  tsConfigPath?: string,
+  shouldTypecheck: boolean = false
+) {
   try {
     require.resolve("typescript");
   } catch {
@@ -67,8 +70,14 @@ export function loadTsNode(tsConfigPath?: string) {
     process.env.TS_NODE_FILES = "true";
   }
 
+  let tsNodeRequirement = "ts-node/register";
+
+  if (!shouldTypecheck) {
+    tsNodeRequirement += "/transpile-only";
+  }
+
   // eslint-disable-next-line import/no-extraneous-dependencies
-  require("ts-node/register");
+  require(tsNodeRequirement);
 }
 
 function isTypescriptFile(path: string): boolean {

package/src/internal/hardhat-network/jsonrpc/client.ts

@@ -1,4 +1,4 @@
-import { Address, bufferToHex } from "@ignored/util";
+import { Address, bufferToHex } from "@nomicfoundation/ethereumjs-util";
 import fsExtra from "fs-extra";
 import * as t from "io-ts";
 import path from "path";

package/src/internal/hardhat-network/provider/BlockchainBase.ts

@@ -1,16 +1,16 @@
-import { Block, BlockHeader } from "@ignored/block";
+import { Block, BlockHeader } from "@nomicfoundation/ethereumjs-block";
 import {
   BlockchainInterface,
   CasperConsensus,
   CliqueConsensus,
   Consensus,
   EthashConsensus,
-} from "@ignored/blockchain";
-import { Common, ConsensusAlgorithm } from "@ignored/common";
-import { TypedTransaction } from "@ignored/tx";
+} from "@nomicfoundation/ethereumjs-blockchain";
+import { Common, ConsensusAlgorithm } from "@nomicfoundation/ethereumjs-common";
+import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
 
 import { assertHardhatInvariant } from "../../core/errors";
-import { BigIntUtils } from "../../util/bigint";
+import * as BigIntUtils from "../../util/bigint";
 import { BlockchainData } from "./BlockchainData";
 import { RpcReceiptOutput } from "./output";
 
@@ -23,7 +23,7 @@ export abstract class BlockchainBase {
   constructor(protected _common: Common) {
     this._data = new BlockchainData(_common);
 
-    // copied from blockchain.ts in @ignored/blockchain
+    // copied from blockchain.ts in @nomicfoundation/ethereumjs-blockchain
     switch (this._common.consensusAlgorithm()) {
       case ConsensusAlgorithm.Casper:
         this.consensus = new CasperConsensus();

package/src/internal/hardhat-network/provider/BlockchainData.ts

@@ -1,8 +1,8 @@
-import { Block } from "@ignored/block";
-import { Common } from "@ignored/common";
-import { TypedTransaction } from "@ignored/tx";
-import { bufferToHex } from "@ignored/util";
-import { Bloom } from "@ignored/vm";
+import { Block } from "@nomicfoundation/ethereumjs-block";
+import { Common } from "@nomicfoundation/ethereumjs-common";
+import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
+import { bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import { Bloom } from "@nomicfoundation/ethereumjs-vm";
 
 import { assertHardhatInvariant } from "../../core/errors";
 import { bloomFilter, filterLogs } from "./filter";

package/src/internal/hardhat-network/provider/HardhatBlockchain.ts

@@ -1,7 +1,7 @@
-import { Block } from "@ignored/block";
-import { Common } from "@ignored/common";
-import { TypedTransaction } from "@ignored/tx";
-import { zeros } from "@ignored/util";
+import { Block } from "@nomicfoundation/ethereumjs-block";
+import { Common } from "@nomicfoundation/ethereumjs-common";
+import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
+import { zeros } from "@nomicfoundation/ethereumjs-util";
 
 import { BlockchainBase } from "./BlockchainBase";
 import { FilterParams } from "./node-types";

package/src/internal/hardhat-network/provider/PoolState.ts

@@ -1,11 +1,11 @@
-import { TypedTransaction } from "@ignored/tx";
+import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
 import {
   List as ImmutableList,
   Map as ImmutableMap,
   Record as ImmutableRecord,
 } from "immutable";
 
-import { BigIntUtils } from "../../util/bigint";
+import * as BigIntUtils from "../../util/bigint";
 
 export interface OrderedTransaction {
   orderId: number;

package/src/internal/hardhat-network/provider/TransactionQueue.ts

@@ -1,8 +1,8 @@
-import { TypedTransaction } from "@ignored/tx";
+import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
 import Heap from "mnemonist/heap";
 
 import { InternalError, InvalidInputError } from "../../core/providers/errors";
-import { BigIntUtils } from "../../util/bigint";
+import * as BigIntUtils from "../../util/bigint";
 import { MempoolOrder } from "./node-types";
 import { OrderedTransaction } from "./PoolState";
 

package/src/internal/hardhat-network/provider/TxPool.ts

@@ -1,11 +1,18 @@
-import { Common } from "@ignored/common";
-import { TransactionFactory, TypedTransaction } from "@ignored/tx";
-import { StateManager } from "@ignored/statemanager";
-import { Address, bufferToHex, toBuffer } from "@ignored/util";
+import { Common } from "@nomicfoundation/ethereumjs-common";
+import {
+  TransactionFactory,
+  TypedTransaction,
+} from "@nomicfoundation/ethereumjs-tx";
+import { StateManager } from "@nomicfoundation/ethereumjs-statemanager";
+import {
+  Address,
+  bufferToHex,
+  toBuffer,
+} from "@nomicfoundation/ethereumjs-util";
 import { List as ImmutableList, Record as ImmutableRecord } from "immutable";
 
 import { InvalidInputError } from "../../core/providers/errors";
-import { BigIntUtils } from "../../util/bigint";
+import * as BigIntUtils from "../../util/bigint";
 
 import {
   AddressToTransactions,

package/src/internal/hardhat-network/provider/ethereumjs-workarounds.ts

@@ -1,10 +1,10 @@
-import { TransactionFactory } from "@ignored/tx";
-import { BaseTransaction } from "@ignored/tx/dist/baseTransaction";
+import { TransactionFactory } from "@nomicfoundation/ethereumjs-tx";
+import { BaseTransaction } from "@nomicfoundation/ethereumjs-tx/dist/baseTransaction";
 import {
   AccessListEIP2930TxData,
   TxData,
   TxOptions,
-} from "@ignored/tx/dist/types";
+} from "@nomicfoundation/ethereumjs-tx/dist/types";
 
 // This is a hack to prevent Block.fromBlockData from recreating our
 // transactions and changing their types. Note fromBlockData is used

package/src/internal/hardhat-network/provider/filter.ts

@@ -1,5 +1,5 @@
-import { bufferToHex, toBuffer } from "@ignored/util";
-import { Bloom } from "@ignored/vm";
+import { bufferToHex, toBuffer } from "@nomicfoundation/ethereumjs-util";
+import { Bloom } from "@nomicfoundation/ethereumjs-vm";
 
 import { RpcLogOutput } from "./output";
 

package/src/internal/hardhat-network/provider/fork/ForkBlockchain.ts

@@ -1,9 +1,9 @@
-import { Block } from "@ignored/block";
-import { Common } from "@ignored/common";
-import { TypedTransaction } from "@ignored/tx";
-import { Address } from "@ignored/util";
+import { Block } from "@nomicfoundation/ethereumjs-block";
+import { Common } from "@nomicfoundation/ethereumjs-common";
+import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
+import { Address } from "@nomicfoundation/ethereumjs-util";
 
-import { FeeMarketEIP1559TxData } from "@ignored/tx/dist/types";
+import { FeeMarketEIP1559TxData } from "@nomicfoundation/ethereumjs-tx/dist/types";
 import { RpcBlockWithTransactions } from "../../../core/jsonrpc/types/output/block";
 import { RpcTransactionReceipt } from "../../../core/jsonrpc/types/output/receipt";
 import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
@@ -252,13 +252,13 @@ export class ForkBlockchain
       return undefined;
     }
 
-    const forkNetworkId = this._jsonRpcClient.getNetworkId();
-    const common = new Common({ chain: forkNetworkId });
-
+    const common = this._common.copy();
     // We set the common's hardfork to Berlin if the remote block doesn't have
     // EIP-1559 activated. The reason for this is that ethereumjs throws if we
     // have a base fee for an older hardfork, and set a default one for London.
-    if (rpcBlock.baseFeePerGas === undefined) {
+    if (rpcBlock.baseFeePerGas !== undefined) {
+      common.setHardfork("london"); // TODO: consider changing this to "latest hardfork"
+    } else {
       common.setHardfork("berlin");
     }
 
@@ -276,7 +276,7 @@ export class ForkBlockchain
       freeze: false,
 
       // don't validate things like the size of `extraData` in the header
-      consensusFormatValidation: false,
+      skipConsensusFormatValidation: true,
     });
 
     for (const transaction of rpcBlock.transactions) {

package/src/internal/hardhat-network/provider/fork/ForkStateManager.ts

@@ -1,4 +1,4 @@
-import { StateManager } from "@ignored/statemanager";
+import { StateManager } from "@nomicfoundation/ethereumjs-statemanager";
 import {
   Account,
   bigIntToHex,
@@ -8,12 +8,12 @@ import {
   KECCAK256_NULL,
   toBuffer,
   unpadBuffer,
-} from "@ignored/util";
-import { keccak256 } from "ethereum-cryptography/keccak";
+} from "@nomicfoundation/ethereumjs-util";
 import { Map as ImmutableMap, Record as ImmutableRecord } from "immutable";
 
 import { assertHardhatInvariant } from "../../../core/errors";
 import { InternalError } from "../../../core/providers/errors";
+import { keccak256 } from "../../../util/keccak";
 import { JsonRpcClient } from "../../jsonrpc/client";
 import { GenesisAccount } from "../node-types";
 import { makeAccount } from "../utils/makeAccount";
@@ -52,12 +52,6 @@ export class ForkStateManager implements StateManager {
   private _contextBlockNumber = this._forkBlockNumber;
   private _contextChanged = false;
 
-  // used by the DefaultStateManager calls
-  private _accessedStorage: Array<Map<string, Set<string>>> = [new Map()];
-  private _accessedStorageReverted: Array<Map<string, Set<string>>> = [
-    new Map(),
-  ];
-
   constructor(
     private readonly _jsonRpcClient: JsonRpcClient,
     private readonly _forkBlockNumber: bigint
@@ -258,7 +252,6 @@ export class ForkStateManager implements StateManager {
   public async checkpoint(): Promise<void> {
     const stateRoot = await this.getStateRoot();
     this._stateCheckpoints.push(bufferToHex(stateRoot));
-    this._accessedStorage.push(new Map());
   }
 
   public async commit(): Promise<void> {
@@ -274,11 +267,6 @@ export class ForkStateManager implements StateManager {
       throw notCheckpointedError("revert");
     }
     await this.setStateRoot(toBuffer(checkpointedRoot));
-
-    const lastItem = this._accessedStorage.pop();
-    if (lastItem !== undefined) {
-      this._accessedStorageReverted.push(lastItem);
-    }
   }
 
   public async getStateRoot(): Promise<Buffer> {
@@ -438,9 +426,15 @@ export class ForkStateManager implements StateManager {
   }
 
   public async modifyAccountFields(
-    _address: Address,
-    _accountFields: any
+    address: Address,
+    accountFields: any
   ): Promise<void> {
-    // not implemented
+    // copied from BaseStateManager
+    const account = await this.getAccount(address);
+    account.nonce = accountFields.nonce ?? account.nonce;
+    account.balance = accountFields.balance ?? account.balance;
+    account.storageRoot = accountFields.storageRoot ?? account.storageRoot;
+    account.codeHash = accountFields.codeHash ?? account.codeHash;
+    await this.putAccount(address, account);
   }
 }

package/src/internal/hardhat-network/provider/fork/rpcToBlockData.ts

@@ -1,4 +1,4 @@
-import { BlockData } from "@ignored/block";
+import { BlockData } from "@nomicfoundation/ethereumjs-block";
 
 import { RpcBlockWithTransactions } from "../../../core/jsonrpc/types/output/block";