hardhat 2.17.1 → 2.17.2

package/src/internal/cli/project-creation.ts

@@ -315,7 +315,7 @@ async function createPackageJson() {
 function showStarOnGitHubMessage() {
   console.log(
     chalk.cyan("Give Hardhat a star on Github if you're enjoying it!") +
-      emoji(" 💞✨")
+      emoji(" ⭐️✨")
   );
   console.log();
   console.log(chalk.cyan("     https://github.com/NomicFoundation/hardhat"));

package/src/internal/core/errors-list.ts

@@ -278,6 +278,16 @@ Rename the file to use the .cjs to fix this problem.`,
 To initialize the provider, make sure you first call \`.init()\` or any method that hits a node like request, send or sendAsync.`,
       shouldBeReported: true,
     },
+    INVALID_READ_OF_DIRECTORY: {
+      number: 22,
+      message:
+        "Invalid file path %absolutePath%. Attempting to read a directory instead of a file.",
+      title: "Invalid read: a directory cannot be read",
+      description: `An attempt was made to read a file, but a path to a directory was provided.
+
+Please double check the file path.`,
+      shouldBeReported: false,
+    },
   },
   NETWORK: {
     CONFIG_NOT_FOUND: {
@@ -585,6 +595,14 @@ Please double check your task definitions.`,
 What makes these types special is that they can be represented as strings, so you can write them down in the terminal.`,
       shouldBeReported: false,
     },
+    DEPRECATED_TRANSFORM_IMPORT_TASK: {
+      number: 213,
+      title: "Use of deprecated remapping task",
+      message:
+        "Task TASK_COMPILE_TRANSFORM_IMPORT_NAME is deprecated. Please update your @nomicfoundation/hardhat-foundry plugin version.",
+      description: `This task has been deprecated in favor of a new approach.`,
+      shouldBeReported: true,
+    },
   },
   ARGUMENTS: {
     INVALID_ENV_VAR_VALUE: {
@@ -855,6 +873,26 @@ Use a relative import instead of referencing the package's name.`,
 Please double check your imports and installed libraries.`,
       shouldBeReported: false,
     },
+    INVALID_IMPORT_OF_DIRECTORY: {
+      number: 414,
+      message:
+        "Invalid import %imported% from %from%. Attempting to import a directory. Directories cannot be imported.",
+      title: "Invalid import: a directory cannot be imported",
+      description: `A Solidity file is attempting to import a directory, which is not possible.
+
+Please double check your imports.`,
+      shouldBeReported: false,
+    },
+    AMBIGUOUS_SOURCE_NAMES: {
+      number: 415,
+      message:
+        "Two different source names (%sourcenames%) resolve to the same file (%file%).",
+      title: "Ambiguous source names",
+      description: `Two different source names map to the same file.
+
+This is probably caused by multiple remappings pointing to the same source file.`,
+      shouldBeReported: false,
+    },
   },
   SOLC: {
     INVALID_VERSION: {

package/src/internal/core/jsonrpc/types/base-types.ts

@@ -40,6 +40,17 @@ export const rpcStorageSlot = new t.Type<bigint>(
   t.identity
 );
 
+// This type is necessary because objects' keys need to be either strings or numbers to be properly handled by the 'io-ts' module.
+// If they are not defined as strings or numbers, the type definition will result in an empty object without the required properties.
+// For example, instead of displaying { ke1: value1 }, it will display {}
+export const rpcStorageSlotHexString = new t.Type<string>(
+  "Storage slot hex string",
+  (x): x is string => typeof x === "string",
+  (u, c) =>
+    validateRpcStorageSlotHexString(u) ? t.success(u) : t.failure(u, c),
+  t.identity
+);
+
 function validateStorageSlot(u: unknown, c: t.Context): t.Validation<bigint> {
   if (typeof u !== "string") {
     return t.failure(
@@ -185,6 +196,10 @@ export function rpcDataToBuffer(data: string): Buffer {
 
 // Type guards
 
+function validateRpcStorageSlotHexString(u: unknown): u is string {
+  return typeof u === "string" && /^0x([0-9a-fA-F]){64}$/.test(u);
+}
+
 function isRpcQuantityString(u: unknown): u is string {
   return (
     typeof u === "string" &&

package/src/internal/core/jsonrpc/types/input/callRequest.ts

@@ -2,7 +2,14 @@ import * as t from "io-ts";
 
 import { optionalOrNullable } from "../../../../util/io-ts";
 import { rpcAccessList } from "../access-list";
-import { rpcAddress, rpcData, rpcQuantity } from "../base-types";
+import {
+  rpcAddress,
+  rpcData,
+  rpcQuantity,
+  rpcStorageSlot,
+  rpcStorageSlotHexString,
+} from "../base-types";
+import { address } from "../../../config/config-validation";
 
 // Type used by eth_call and eth_estimateGas
 export const rpcCallRequest = t.type(
@@ -21,3 +28,30 @@ export const rpcCallRequest = t.type(
 );
 
 export type RpcCallRequest = t.TypeOf<typeof rpcCallRequest>;
+
+// Types used by eth_call to configure the state override set
+export const stateProperties = t.record(
+  rpcStorageSlotHexString,
+  rpcStorageSlot
+);
+
+export const stateOverrideOptions = t.type(
+  {
+    balance: optionalOrNullable(rpcQuantity),
+    nonce: optionalOrNullable(rpcQuantity),
+    code: optionalOrNullable(rpcData),
+    state: optionalOrNullable(stateProperties),
+    stateDiff: optionalOrNullable(stateProperties),
+  },
+  "stateOverrideOptions"
+);
+
+export const stateOverrideSet = t.record(address, stateOverrideOptions);
+export const optionalStateOverrideSet = optionalOrNullable(stateOverrideSet);
+
+export type StateProperties = t.TypeOf<typeof stateProperties>;
+export type StateOverrideOptions = t.TypeOf<typeof stateOverrideOptions>;
+export type StateOverrideSet = t.TypeOf<typeof stateOverrideSet>;
+export type OptionalStateOverrideSet = t.TypeOf<
+  typeof optionalStateOverrideSet
+>;

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

@@ -116,6 +116,8 @@ export async function createProvider(
         forkConfig,
         forkCachePath:
           paths !== undefined ? getForkCacheDirPath(paths) : undefined,
+        enableTransientStorage:
+          hardhatNetConfig.enableTransientStorage ?? false,
       },
       new ModulesLogger(hardhatNetConfig.loggingEnabled),
       artifacts

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

@@ -348,10 +348,30 @@ export class ForkBlockchain
       return undefined;
     }
 
-    const transaction = new ReadOnlyValidTransaction(
-      new Address(rpcTransaction.from),
-      rpcToTxData(rpcTransaction)
-    );
+    let transaction: TypedTransaction;
+
+    if (rpcTransaction.type === undefined || rpcTransaction.type === 0n) {
+      transaction = new ReadOnlyValidTransaction(
+        new Address(rpcTransaction.from),
+        rpcToTxData(rpcTransaction)
+      );
+    } else if (rpcTransaction.type === 1n) {
+      transaction = new ReadOnlyValidEIP2930Transaction(
+        new Address(rpcTransaction.from),
+        rpcToTxData(rpcTransaction)
+      );
+    } else if (rpcTransaction.type === 2n) {
+      transaction = new ReadOnlyValidEIP1559Transaction(
+        new Address(rpcTransaction.from),
+        rpcToTxData(rpcTransaction) as FeeMarketEIP1559TxData
+      );
+    } else {
+      transaction = new ReadOnlyValidUnknownTypeTransaction(
+        new Address(rpcTransaction.from),
+        Number(rpcTransaction.type),
+        rpcToTxData(rpcTransaction)
+      );
+    }
 
     this._data.addTransaction(transaction);
 

package/src/internal/hardhat-network/provider/modules/eth.ts

@@ -37,6 +37,8 @@ import {
   RpcOldBlockTag,
 } from "../../../core/jsonrpc/types/input/blockTag";
 import {
+  optionalStateOverrideSet,
+  OptionalStateOverrideSet,
   rpcCallRequest,
   RpcCallRequest,
 } from "../../../core/jsonrpc/types/input/callRequest";
@@ -334,13 +336,21 @@ export class EthModule {
 
   // eth_call
 
-  private _callParams(params: any[]): [RpcCallRequest, OptionalRpcNewBlockTag] {
-    return validateParams(params, rpcCallRequest, optionalRpcNewBlockTag);
+  private _callParams(
+    params: any[]
+  ): [RpcCallRequest, OptionalRpcNewBlockTag, OptionalStateOverrideSet] {
+    return validateParams(
+      params,
+      rpcCallRequest,
+      optionalRpcNewBlockTag,
+      optionalStateOverrideSet
+    );
   }
 
   private async _callAction(
     rpcCall: RpcCallRequest,
-    blockTag: OptionalRpcNewBlockTag
+    blockTag: OptionalRpcNewBlockTag,
+    stateOverrideSet: OptionalStateOverrideSet
   ): Promise<string> {
     this._validateTransactionAndCallRequest(rpcCall);
 
@@ -353,7 +363,11 @@ export class EthModule {
       trace,
       error,
       consoleLogMessages,
-    } = await this._node.runCall(callParams, blockNumberOrPending);
+    } = await this._node.runCall(
+      callParams,
+      blockNumberOrPending,
+      stateOverrideSet
+    );
 
     const code = await this._node.getCodeFromTrace(trace, blockNumberOrPending);
 

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

@@ -32,6 +32,7 @@ interface CommonConfig {
   coinbase: string;
   chains: HardhatNetworkChainsConfig;
   allowBlocksWithSameTimestamp: boolean;
+  enableTransientStorage: boolean;
 }
 
 export type LocalNodeConfig = CommonConfig;

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

@@ -1,5 +1,5 @@
 import { Block, HeaderData } from "@nomicfoundation/ethereumjs-block";
-import { Common } from "@nomicfoundation/ethereumjs-common";
+import { Common, CustomCommonOpts } from "@nomicfoundation/ethereumjs-common";
 import {
   AccessListEIP2930Transaction,
   FeeMarketEIP1559Transaction,
@@ -83,6 +83,10 @@ import { VMTracer } from "../stack-traces/vm-tracer";
 import "./ethereumjs-workarounds";
 import { rpcQuantityToBigInt } from "../../core/jsonrpc/types/base-types";
 import { JsonRpcClient } from "../jsonrpc/client";
+import {
+  StateOverrideSet,
+  StateProperties,
+} from "../../core/jsonrpc/types/input/callRequest";
 import { bloomFilter, Filter, filterLogs, LATEST_BLOCK, Type } from "./filter";
 import { ForkBlockchain } from "./fork/ForkBlockchain";
 import { ForkStateManager } from "./fork/ForkStateManager";
@@ -146,6 +150,7 @@ export class HardhatNode extends EventEmitter {
       networkId,
       chainId,
       allowBlocksWithSameTimestamp,
+      enableTransientStorage,
     } = config;
 
     const allowUnlimitedContractSize =
@@ -303,7 +308,8 @@ export class HardhatNode extends EventEmitter {
       forkBlockNum,
       forkBlockHash,
       nextBlockBaseFeePerGas,
-      forkClient
+      forkClient,
+      enableTransientStorage
     );
 
     return [common, node];
@@ -390,7 +396,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     private _forkBlockNumber?: bigint,
     private _forkBlockHash?: string,
     nextBlockBaseFee?: bigint,
-    private _forkClient?: JsonRpcClient
+    private _forkClient?: JsonRpcClient,
+    private readonly _enableTransientStorage: boolean = false
   ) {
     super();
 
@@ -624,7 +631,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
 
   public async runCall(
     call: CallParams,
-    blockNumberOrPending: bigint | "pending"
+    blockNumberOrPending: bigint | "pending",
+    stateOverrideSet: StateOverrideSet = {}
   ): Promise<RunCallResult> {
     let txParams: TransactionParams;
 
@@ -659,7 +667,13 @@ Hardhat Network's forking functionality only works with blocks from at least spu
 
     const result = await this._runInBlockContext(
       blockNumberOrPending,
-      async () => this._runTxAndRevertMutations(tx, blockNumberOrPending, true)
+      async () =>
+        this._runTxAndRevertMutations(
+          tx,
+          blockNumberOrPending,
+          true,
+          stateOverrideSet
+        )
     );
 
     const traces = await this._gatherTraces(result.execResult);
@@ -2354,6 +2368,83 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     );
   }
 
+  private async _applyStateOverrideSet(stateOverrideSet: StateOverrideSet) {
+    // Multiple state override set can be configured for different addresses, hence the loop
+    for (const [addrToOverride, stateOverrideOptions] of Object.entries(
+      stateOverrideSet
+    )) {
+      const address = new Address(toBuffer(addrToOverride));
+
+      const { balance, nonce, code, state, stateDiff } = stateOverrideOptions;
+
+      await this._overrideBalanceAndNonce(address, balance, nonce);
+      await this._overrideCode(address, code);
+      await this._overrideStateAndStateDiff(address, state, stateDiff);
+    }
+  }
+
+  private async _overrideBalanceAndNonce(
+    address: Address,
+    balance: bigint | undefined,
+    nonce: bigint | undefined
+  ) {
+    const MAX_NONCE = 2n ** 64n - 1n;
+    const MAX_BALANCE = 2n ** 256n - 1n;
+
+    if (nonce !== undefined && nonce > MAX_NONCE) {
+      throw new InvalidInputError(
+        `The 'nonce' property should occupy a maximum of 8 bytes (nonce=${nonce}).`
+      );
+    }
+
+    if (balance !== undefined && balance > MAX_BALANCE) {
+      throw new InvalidInputError(
+        `The 'balance' property should occupy a maximum of 32 bytes (balance=${balance}).`
+      );
+    }
+
+    await this._stateManager.modifyAccountFields(address, {
+      balance,
+      nonce,
+    });
+  }
+
+  private async _overrideCode(address: Address, code: Buffer | undefined) {
+    if (code === undefined) return;
+
+    await this._stateManager.putContractCode(address, code);
+  }
+
+  private async _overrideStateAndStateDiff(
+    address: Address,
+    state: StateProperties | undefined,
+    stateDiff: StateProperties | undefined
+  ) {
+    let newState;
+
+    if (state !== undefined && stateDiff === undefined) {
+      await this._stateManager.clearContractStorage(address);
+      newState = state;
+    } else if (state === undefined && stateDiff !== undefined) {
+      newState = stateDiff;
+    } else if (state === undefined && stateDiff === undefined) {
+      // nothing to do
+      return;
+    } else {
+      throw new InvalidInputError(
+        "The properties 'state' and 'stateDiff' cannot be used simultaneously when configuring the state override set passed to the eth_call method."
+      );
+    }
+
+    for (const [storageKey, value] of Object.entries(newState)) {
+      await this._stateManager.putContractStorage(
+        address,
+        toBuffer(storageKey),
+        setLengthLeft(bigIntToBuffer(value), 32)
+      );
+    }
+  }
+
   /**
    * This function runs a transaction and reverts all the modifications that it
    * makes.
@@ -2361,10 +2452,13 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   private async _runTxAndRevertMutations(
     tx: TypedTransaction,
     blockNumberOrPending: bigint | "pending",
-    forceBaseFeeZero = false
+    forceBaseFeeZero = false,
+    stateOverrideSet: StateOverrideSet = {}
   ): Promise<RunTxResult> {
     const initialStateRoot = await this._stateManager.getStateRoot();
 
+    await this._applyStateOverrideSet(stateOverrideSet);
+
     let blockContext: Block | undefined;
     let originalCommon: Common | undefined;
 
@@ -2400,6 +2494,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         },
         {
           hardfork: this._selectHardfork(blockContext.header.number),
+          ...this._getTransientStorageSettings(),
         }
       );
 
@@ -2740,6 +2835,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         },
         {
           hardfork: this._selectHardfork(BigInt(blockNumber)),
+          ...this._getTransientStorageSettings(),
         }
       );
 
@@ -2750,4 +2846,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       );
     }
   }
+
+  private _getTransientStorageSettings(): Partial<CustomCommonOpts> {
+    if (this._enableTransientStorage) {
+      return { eips: [1153] };
+    }
+
+    return {};
+  }
 }

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

@@ -80,6 +80,7 @@ interface HardhatNetworkProviderConfig {
   experimentalHardhatNetworkMessageTraceHooks?: BoundExperimentalHardhatNetworkMessageTraceHook[];
   forkConfig?: ForkConfig;
   forkCachePath?: string;
+  enableTransientStorage: boolean;
 }
 
 export class HardhatNetworkProvider
@@ -253,6 +254,7 @@ export class HardhatNetworkProvider
       coinbase: this._config.coinbase ?? DEFAULT_COINBASE,
       chains: this._config.chains,
       allowBlocksWithSameTimestamp: this._config.allowBlocksWithSameTimestamp,
+      enableTransientStorage: this._config.enableTransientStorage,
     };
 
     const [common, node] = await HardhatNode.create(config);

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

@@ -2,7 +2,14 @@ import { Common } from "@nomicfoundation/ethereumjs-common";
 
 import { LocalNodeConfig } from "../node-types";
 
-export function makeCommon({ chainId, networkId, hardfork }: LocalNodeConfig) {
+export function makeCommon({
+  chainId,
+  networkId,
+  hardfork,
+  enableTransientStorage,
+}: LocalNodeConfig) {
+  const otherSettings = enableTransientStorage ? { eips: [1153] } : {};
+
   const common = Common.custom(
     {
       chainId,
@@ -10,6 +17,7 @@ export function makeCommon({ chainId, networkId, hardfork }: LocalNodeConfig) {
     },
     {
       hardfork,
+      ...otherSettings,
     }
   );
 

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

@@ -280,10 +280,12 @@ export class VMDebugTracer {
           "There shouldn't be two messages one after another"
         );
 
-        // the increase in memory size of a revert is immediately
-        // reflected, so we don't treat it as a memory expansion
-        // of the previous step
-        if (structLog.op !== "REVERT") {
+        // memory opcodes reflect the expanded memory in that step,
+        // so we correct them
+        if (
+          previousStructLog.op === "MSTORE" ||
+          previousStructLog.op === "MLOAD"
+        ) {
           const memoryLengthDifference =
             structLog.memory.length - previousStructLog.memory.length;
           for (let k = 0; k < memoryLengthDifference; k++) {
@@ -315,13 +317,13 @@ export class VMDebugTracer {
   }
 
   private _getMemory(step: InterpreterStep): string[] {
-    const memory = Buffer.from(step.memory)
-      .toString("hex")
-      .match(/.{1,64}/g);
+    const rawMemory =
+      Buffer.from(step.memory)
+        .toString("hex")
+        .match(/.{1,64}/g) ?? [];
 
-    const result = memory === null ? [] : [...memory];
-
-    return result;
+    // Remove the additional non allocated memory
+    return rawMemory.slice(0, Number(step.memoryWordCount));
   }
 
   private _getStack(step: InterpreterStep): string[] {

package/src/internal/solidity/dependencyGraph.ts

@@ -1,4 +1,6 @@
 import * as taskTypes from "../../types/builtin-tasks";
+import { HardhatError } from "../core/errors";
+import { ERRORS } from "../core/errors-list";
 
 import { ResolvedFile, Resolver } from "./resolver";
 
@@ -22,7 +24,8 @@ export class DependencyGraph implements taskTypes.DependencyGraph {
   private _resolvedFiles = new Map<string, ResolvedFile>();
   private _dependenciesPerFile = new Map<string, Set<ResolvedFile>>();
 
-  private readonly _visitedFiles = new Set<string>();
+  // map absolute paths to source names
+  private readonly _visitedFiles = new Map<string, string>();
 
   private constructor() {}
 
@@ -160,11 +163,20 @@ export class DependencyGraph implements taskTypes.DependencyGraph {
     resolver: Resolver,
     file: ResolvedFile
   ): Promise<void> {
-    if (this._visitedFiles.has(file.absolutePath)) {
+    const sourceName = this._visitedFiles.get(file.absolutePath);
+
+    if (sourceName !== undefined) {
+      if (sourceName !== file.sourceName) {
+        throw new HardhatError(ERRORS.RESOLVER.AMBIGUOUS_SOURCE_NAMES, {
+          sourcenames: `'${sourceName}' and '${file.sourceName}'`,
+          file: file.absolutePath,
+        });
+      }
+
       return;
     }
 
-    this._visitedFiles.add(file.absolutePath);
+    this._visitedFiles.set(file.absolutePath, file.sourceName);
 
     const dependencies = new Set<ResolvedFile>();
     this._resolvedFiles.set(file.sourceName, file);