hardhat 2.17.0 → 2.17.2

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

@@ -4,7 +4,10 @@ import {
   RpcDebugTracingConfig,
 } from "../../../core/jsonrpc/types/input/debugTraceTransaction";
 import { validateParams } from "../../../core/jsonrpc/types/input/validation";
-import { MethodNotFoundError } from "../../../core/providers/errors";
+import {
+  InvalidArgumentsError,
+  MethodNotFoundError,
+} from "../../../core/providers/errors";
 import { HardhatNode } from "../node";
 import { RpcDebugTraceOutput } from "../output";
 
@@ -32,7 +35,23 @@ export class DebugModule {
   private _traceTransactionParams(
     params: any[]
   ): [Buffer, RpcDebugTracingConfig] {
-    return validateParams(params, rpcHash, rpcDebugTracingConfig);
+    const validatedParams = validateParams(
+      params,
+      rpcHash,
+      rpcDebugTracingConfig
+    );
+
+    this._validateTracerParam(validatedParams[1]);
+
+    return validatedParams;
+  }
+
+  private _validateTracerParam(config: RpcDebugTracingConfig) {
+    if (config?.tracer !== undefined) {
+      throw new InvalidArgumentsError(
+        "Hardhat currently only supports the default tracer, so no tracer parameter should be passed."
+      );
+    }
   }
 
   private async _traceTransactionAction(

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/constants.ts

@@ -1,2 +1,2 @@
-export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.20";
+export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.21";
 export const FIRST_SOLC_VERSION_SUPPORTED = "0.5.1";

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);

package/src/internal/solidity/resolver.ts

@@ -21,6 +21,7 @@ import { ERRORS } from "../core/errors-list";
 import { createNonCryptographicHashBasedIdentifier } from "../util/hash";
 
 import { getRealPath } from "../util/fs-utils";
+import { applyRemappings } from "../../utils/remappings";
 import { Parser } from "./parse";
 
 export interface ResolvedFilesMap {
@@ -69,6 +70,7 @@ export class Resolver {
   constructor(
     private readonly _projectRoot: string,
     private readonly _parser: Parser,
+    private readonly _remappings: Record<string, string>,
     private readonly _readFile: (absolutePath: string) => Promise<string>,
     private readonly _transformImportName: (
       importName: string
@@ -86,14 +88,22 @@ export class Resolver {
       return cached;
     }
 
-    validateSourceNameFormat(sourceName);
+    const remappedSourceName = applyRemappings(this._remappings, sourceName);
+
+    validateSourceNameFormat(remappedSourceName);
 
     let resolvedFile: ResolvedFile;
 
-    if (await isLocalSourceName(this._projectRoot, sourceName)) {
-      resolvedFile = await this._resolveLocalSourceName(sourceName);
+    if (await isLocalSourceName(this._projectRoot, remappedSourceName)) {
+      resolvedFile = await this._resolveLocalSourceName(
+        sourceName,
+        remappedSourceName
+      );
     } else {
-      resolvedFile = await this._resolveLibrarySourceName(sourceName);
+      resolvedFile = await this._resolveLibrarySourceName(
+        sourceName,
+        remappedSourceName
+      );
     }
 
     this._cache.set(sourceName, resolvedFile);
@@ -109,7 +119,14 @@ export class Resolver {
     from: ResolvedFile,
     importName: string
   ): Promise<ResolvedFile> {
-    const imported = await this._transformImportName(importName);
+    // sanity check for deprecated task
+    if (importName !== (await this._transformImportName(importName))) {
+      throw new HardhatError(
+        ERRORS.TASK_DEFINITIONS.DEPRECATED_TRANSFORM_IMPORT_TASK
+      );
+    }
+
+    const imported = applyRemappings(this._remappings, importName);
 
     const scheme = this._getUriScheme(imported);
     if (scheme !== undefined) {
@@ -151,7 +168,7 @@ export class Resolver {
       if (isRelativeImport) {
         sourceName = await this._relativeImportToSourceName(from, imported);
       } else {
-        sourceName = normalizeSourceName(imported);
+        sourceName = normalizeSourceName(importName); // The sourceName of the imported file is not transformed
       }
 
       const cached = this._cache.get(sourceName);
@@ -169,7 +186,10 @@ export class Resolver {
         isRelativeImport &&
         !this._isRelativeImportToLibrary(from, imported)
       ) {
-        resolvedFile = await this._resolveLocalSourceName(sourceName);
+        resolvedFile = await this._resolveLocalSourceName(
+          sourceName,
+          applyRemappings(this._remappings, sourceName)
+        );
       } else {
         resolvedFile = await this.resolveSourceName(sourceName);
       }
@@ -241,28 +261,50 @@ export class Resolver {
         );
       }
 
+      if (
+        HardhatError.isHardhatErrorType(
+          error,
+          ERRORS.GENERAL.INVALID_READ_OF_DIRECTORY
+        )
+      ) {
+        throw new HardhatError(
+          ERRORS.RESOLVER.INVALID_IMPORT_OF_DIRECTORY,
+          {
+            imported,
+            from: from.sourceName,
+          },
+          error
+        );
+      }
+
       // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
       throw error;
     }
   }
 
   private async _resolveLocalSourceName(
-    sourceName: string
+    sourceName: string,
+    remappedSourceName: string
   ): Promise<ResolvedFile> {
     await this._validateSourceNameExistenceAndCasing(
       this._projectRoot,
-      sourceName,
+      remappedSourceName,
       false
     );
 
-    const absolutePath = path.join(this._projectRoot, sourceName);
+    const absolutePath = path.join(this._projectRoot, remappedSourceName);
     return this._resolveFile(sourceName, absolutePath);
   }
 
   private async _resolveLibrarySourceName(
-    sourceName: string
+    sourceName: string,
+    remappedSourceName: string
   ): Promise<ResolvedFile> {
-    const libraryName = this._getLibraryName(sourceName);
+    const normalizedSourceName = remappedSourceName.replace(
+      /^node_modules\//,
+      ""
+    );
+    const libraryName = this._getLibraryName(normalizedSourceName);
 
     let packageJsonPath;
     try {
@@ -288,7 +330,7 @@ export class Resolver {
     }
 
     let nodeModulesPath = path.dirname(path.dirname(packageJsonPath));
-    if (this._isScopedPackage(sourceName)) {
+    if (this._isScopedPackage(normalizedSourceName)) {
       nodeModulesPath = path.dirname(nodeModulesPath);
     }
 
@@ -298,7 +340,7 @@ export class Resolver {
       // cases we handle resolution differently
       const packageRoot = path.dirname(packageJsonPath);
       const pattern = new RegExp(`^${libraryName}/?`);
-      const fileName = sourceName.replace(pattern, "");
+      const fileName = normalizedSourceName.replace(pattern, "");
 
       await this._validateSourceNameExistenceAndCasing(
         packageRoot,
@@ -311,10 +353,10 @@ export class Resolver {
     } else {
       await this._validateSourceNameExistenceAndCasing(
         nodeModulesPath,
-        sourceName,
+        normalizedSourceName,
         true
       );
-      absolutePath = path.join(nodeModulesPath, sourceName);
+      absolutePath = path.join(nodeModulesPath, normalizedSourceName);
     }
 
     const packageInfo: {

package/src/internal/util/unsafe.ts

@@ -10,6 +10,6 @@ export const unsafeObjectKeys = Object.keys as <T>(
  * This function is a typed version of `Object.entries`. Note that it's type
  * unsafe. You have to be sure that `o` has exactly the same keys as `T`.
  */
-export function unsafeObjectEntries<T>(o: T) {
+export function unsafeObjectEntries<T extends object>(o: T) {
   return Object.entries(o) as Array<[keyof T, T[keyof T]]>;
 }

package/src/types/config.ts

@@ -57,6 +57,7 @@ export interface HardhatNetworkUserConfig {
   forking?: HardhatNetworkForkingUserConfig;
   coinbase?: string;
   chains?: HardhatNetworkChainsUserConfig;
+  enableTransientStorage?: boolean;
 }
 
 export type HardhatNetworkAccountsUserConfig =
@@ -153,6 +154,7 @@ export interface HardhatNetworkConfig {
   coinbase?: string;
   chains: HardhatNetworkChainsConfig;
   allowBlocksWithSameTimestamp?: boolean;
+  enableTransientStorage?: boolean;
 }
 
 export type HardhatNetworkAccountsConfig =

package/src/utils/contract-names.ts

@@ -22,6 +22,7 @@ export function isFullyQualifiedName(name: string): boolean {
  * Parses a fully qualified name.
  *
  * @param fullyQualifiedName It MUST be a fully qualified name.
+ * @throws {HardhatError} If the name is not fully qualified.
  */
 export function parseFullyQualifiedName(fullyQualifiedName: string): {
   sourceName: string;

package/src/utils/remappings.ts

@@ -0,0 +1,17 @@
+export function applyRemappings(
+  remappings: Record<string, string>,
+  sourceName: string
+): string {
+  const selectedRemapping = { from: "", to: "" };
+
+  for (const [from, to] of Object.entries(remappings)) {
+    if (
+      sourceName.startsWith(from) &&
+      from.length >= selectedRemapping.from.length
+    ) {
+      [selectedRemapping.from, selectedRemapping.to] = [from, to];
+    }
+  }
+
+  return sourceName.replace(selectedRemapping.from, selectedRemapping.to);
+}