hardhat 2.19.5 → 2.20.0

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

@@ -1,4 +1,5 @@
-import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/exceptions";
+import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/cjs/exceptions";
+import { equalsBytes } from "@nomicfoundation/ethereumjs-util";
 import { ReturnData } from "../provider/return-data";
 
 import {
@@ -80,7 +81,7 @@ export class SolidityTracer {
       // reverts if a call fails, and most contracts are in solidity
       if (
         subtrace.error !== undefined &&
-        trace.returnData.equals(subtrace.returnData)
+        equalsBytes(trace.returnData, subtrace.returnData)
       ) {
         let unrecognizedEntry: SolidityStackTraceEntry;
 

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

@@ -1,13 +1,16 @@
+import { Journal } from "@nomicfoundation/ethereumjs-evm/dist/cjs/journal";
 import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
 import { AfterTxEvent, VM } from "@nomicfoundation/ethereumjs-vm";
-import { EVMResult } from "@nomicfoundation/ethereumjs-evm";
-import { InterpreterStep } from "@nomicfoundation/ethereumjs-evm/dist/interpreter";
-import { Message } from "@nomicfoundation/ethereumjs-evm/dist/message";
+import {
+  EVMResult,
+  InterpreterStep,
+  Message,
+} from "@nomicfoundation/ethereumjs-evm";
 import {
   Address,
-  bufferToBigInt,
+  bytesToBigInt,
   setLengthLeft,
-  toBuffer,
+  toBytes,
 } from "@nomicfoundation/ethereumjs-util";
 
 import { assertHardhatInvariant } from "../../core/errors";
@@ -232,7 +235,7 @@ export class VMDebugTracer {
     this._lastTrace = {
       gas: Number(result.totalGasSpent),
       failed: result.execResult.exceptionError !== undefined,
-      returnValue: result.execResult.returnValue.toString("hex"),
+      returnValue: Buffer.from(result.execResult.returnValue).toString("hex"),
       structLogs: rpcStructLogs,
     };
 
@@ -339,7 +342,7 @@ export class VMDebugTracer {
 
     let gasCost = step.opcode.fee;
 
-    let op = step.opcode.name;
+    let op = step.opcode.name === "KECCAK256" ? "SHA3" : step.opcode.name;
     let error: object | undefined;
 
     const storage: Storage = {};
@@ -347,7 +350,7 @@ export class VMDebugTracer {
     if (step.opcode.name === "SLOAD") {
       const address = step.address;
       const [keyBuffer] = this._getFromStack(stack, 1);
-      const key: Buffer = setLengthLeft(keyBuffer, 32);
+      const key: Uint8Array = setLengthLeft(keyBuffer, 32);
 
       const storageValue = await this._getContractStorage(address, key);
 
@@ -360,8 +363,8 @@ export class VMDebugTracer {
       storage[key] = storageValue;
     } else if (step.opcode.name === "REVERT") {
       const [offsetBuffer, lengthBuffer] = this._getFromStack(stack, 2);
-      const length = bufferToBigInt(lengthBuffer);
-      const offset = bufferToBigInt(offsetBuffer);
+      const length = bytesToBigInt(lengthBuffer);
+      const offset = bytesToBigInt(offsetBuffer);
 
       const [gasIncrease, addedWords] = this._memoryExpansion(
         BigInt(memory.length),
@@ -375,7 +378,7 @@ export class VMDebugTracer {
       }
     } else if (step.opcode.name === "CREATE2") {
       const [, , memoryUsedBuffer] = this._getFromStack(stack, 3);
-      const memoryUsed = bufferToBigInt(memoryUsedBuffer);
+      const memoryUsed = bytesToBigInt(memoryUsedBuffer);
       const sha3ExtraCost =
         BigIntUtils.divUp(memoryUsed, 32n) * this._sha3WordGas();
       gasCost += Number(sha3ExtraCost);
@@ -387,7 +390,7 @@ export class VMDebugTracer {
       // this is a port of what geth does to compute the
       // gasCost of a *CALL step, with some simplifications
       // because we don't support pre-spuriousDragon hardforks
-      let valueBuffer = Buffer.from([]);
+      let valueBuffer = Uint8Array.from([]);
       let [
         callCostBuffer,
         recipientAddressBuffer,
@@ -410,16 +413,16 @@ export class VMDebugTracer {
         ] = this._getFromStack(stack, 7);
       }
 
-      const callCost = bufferToBigInt(callCostBuffer);
+      const callCost = bytesToBigInt(callCostBuffer);
 
-      const value = bufferToBigInt(valueBuffer);
+      const value = bytesToBigInt(valueBuffer);
 
       const memoryLength = BigInt(memory.length);
-      const inBN = bufferToBigInt(inBuffer);
-      const inSizeBN = bufferToBigInt(inSizeBuffer);
+      const inBN = bytesToBigInt(inBuffer);
+      const inSizeBN = bytesToBigInt(inSizeBuffer);
       const inPosition = inSizeBN === 0n ? inSizeBN : inBN + inSizeBN;
-      const outBN = bufferToBigInt(outBuffer);
-      const outSizeBN = bufferToBigInt(outSizeBuffer);
+      const outBN = bytesToBigInt(outBuffer);
+      const outSizeBN = bytesToBigInt(outSizeBuffer);
       const outPosition = outSizeBN === 0n ? outSizeBN : outBN + outSizeBN;
       const memSize = inPosition > outPosition ? inPosition : outPosition;
       const toAddress = new Address(recipientAddressBuffer.slice(-20));
@@ -473,42 +476,46 @@ export class VMDebugTracer {
   }
 
   private _memoryGas(): bigint {
-    return this._vm._common.param("gasPrices", "memory");
+    return this._vm.common.param("gasPrices", "memory");
   }
 
   private _sha3WordGas(): bigint {
-    return this._vm._common.param("gasPrices", "sha3Word");
+    return this._vm.common.param("gasPrices", "sha3Word");
   }
 
   private _callConstantGas(): bigint {
-    if (this._vm._common.gteHardfork("berlin")) {
-      return this._vm._common.param("gasPrices", "warmstorageread");
+    if (this._vm.common.gteHardfork("berlin")) {
+      return this._vm.common.param("gasPrices", "warmstorageread");
     }
 
-    return this._vm._common.param("gasPrices", "call");
+    return this._vm.common.param("gasPrices", "call");
   }
 
   private _callNewAccountGas(): bigint {
-    return this._vm._common.param("gasPrices", "callNewAccount");
+    return this._vm.common.param("gasPrices", "callNewAccount");
   }
 
   private _callValueTransferGas(): bigint {
-    return this._vm._common.param("gasPrices", "callValueTransfer");
+    return this._vm.common.param("gasPrices", "callValueTransfer");
   }
 
   private _quadCoeffDiv(): bigint {
-    return this._vm._common.param("gasPrices", "quadCoeffDiv");
+    return this._vm.common.param("gasPrices", "quadCoeffDiv");
   }
 
-  private _isAddressEmpty(address: Address): Promise<boolean> {
-    return this._vm.stateManager.accountIsEmpty(address);
+  private async _isAddressEmpty(address: Address): Promise<boolean> {
+    const account = await this._vm.stateManager.getAccount(address);
+    return account?.isEmpty() ?? true;
   }
 
-  private _getContractStorage(address: Address, key: Buffer): Promise<Buffer> {
+  private _getContractStorage(
+    address: Address,
+    key: Uint8Array
+  ): Promise<Uint8Array> {
     return this._vm.stateManager.getContractStorage(address, key);
   }
 
-  private _getContractCode(address: Address): Promise<Buffer> {
+  private _getContractCode(address: Address): Promise<Uint8Array> {
     return this._vm.stateManager.getContractCode(address);
   }
 
@@ -520,12 +527,16 @@ export class VMDebugTracer {
     callCost: bigint
   ): Promise<bigint> {
     // The available gas is reduced when the address is cold
-    if (this._vm._common.gteHardfork("berlin")) {
-      const isWarmed = this._vm.eei.isWarmedAddress(address.toBuffer());
+    if (this._vm.common.gteHardfork("berlin")) {
+      const journal = this._vm.evm.journal;
+      if (!(journal instanceof Journal)) {
+        throw new Error("evm.journal is not an instance of Journal");
+      }
+      const isWarmed = journal.isWarmedAddress(address.toBytes());
 
       const coldCost =
-        this._vm._common.param("gasPrices", "coldaccountaccess") -
-        this._vm._common.param("gasPrices", "warmstorageread");
+        this._vm.common.param("gasPrices", "coldaccountaccess") -
+        this._vm.common.param("gasPrices", "warmstorageread");
 
       // This comment is copied verbatim from geth:
       // The WarmStorageReadCostEIP2929 (100) is already deducted in the form of a constant cost, so
@@ -596,12 +607,12 @@ export class VMDebugTracer {
     return [0n, 0n];
   }
 
-  private _getFromStack(stack: string[], count: number): Buffer[] {
+  private _getFromStack(stack: string[], count: number): Uint8Array[] {
     return stack
       .slice(-count)
       .reverse()
       .map((value) => `0x${value}`)
-      .map(toBuffer);
+      .map(toBytes);
   }
 
   private _memoryFee(words: bigint): bigint {
@@ -614,6 +625,6 @@ export class VMDebugTracer {
   }
 }
 
-function toWord(b: Buffer): string {
-  return b.toString("hex").padStart(64, "0");
+function toWord(b: Uint8Array): string {
+  return Buffer.from(b).toString("hex").padStart(64, "0");
 }

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

@@ -1,10 +1,10 @@
 import {
   EVMResult,
   getActivePrecompiles,
+  InterpreterStep,
+  Message,
 } from "@nomicfoundation/ethereumjs-evm";
-import { InterpreterStep } from "@nomicfoundation/ethereumjs-evm/dist/interpreter";
-import { Message } from "@nomicfoundation/ethereumjs-evm/dist/message";
-import { Address, bufferToBigInt } from "@nomicfoundation/ethereumjs-util";
+import { Address, bytesToBigInt } from "@nomicfoundation/ethereumjs-util";
 import { VM } from "@nomicfoundation/ethereumjs-vm";
 import { assertHardhatInvariant } from "../../core/errors";
 
@@ -19,18 +19,20 @@ import {
 
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
 
-const DUMMY_RETURN_DATA = Buffer.from([]);
+const DUMMY_RETURN_DATA = Uint8Array.from([]);
 const DUMMY_GAS_USED = 0n;
 
 export class VMTracer {
   private _messageTraces: MessageTrace[] = [];
   private _enabled = false;
   private _lastError: Error | undefined;
-  private _maxPrecompileNumber = getActivePrecompiles(this._vm._common).size;
+  private _maxPrecompileNumber = getActivePrecompiles(this._vm.common).size;
 
   constructor(
     private readonly _vm: VM,
-    private readonly _getContractCode: (address: Address) => Promise<Buffer>,
+    private readonly _getContractCode: (
+      address: Address
+    ) => Promise<Uint8Array>,
     private readonly _throwErrors = true
   ) {
     this._beforeMessageHandler = this._beforeMessageHandler.bind(this);
@@ -114,7 +116,7 @@ export class VMTracer {
 
       if (message.to === undefined) {
         const createTrace: CreateMessageTrace = {
-          code: message.data,
+          code: new Uint8Array(message.data),
           steps: [],
           value: message.value,
           returnData: DUMMY_RETURN_DATA,
@@ -126,12 +128,12 @@ export class VMTracer {
 
         trace = createTrace;
       } else {
-        const toAsBigInt = bufferToBigInt(message.to.toBuffer());
+        const toAsBigInt = bytesToBigInt(message.to.toBytes());
 
         if (toAsBigInt > 0 && toAsBigInt <= this._maxPrecompileNumber) {
           const precompileTrace: PrecompileMessageTrace = {
             precompile: Number(toAsBigInt),
-            calldata: message.data,
+            calldata: new Uint8Array(message.data),
             value: message.value,
             returnData: DUMMY_RETURN_DATA,
             depth: message.depth,
@@ -146,15 +148,15 @@ export class VMTracer {
 
           const callTrace: CallMessageTrace = {
             code,
-            calldata: message.data,
+            calldata: new Uint8Array(message.data),
             steps: [],
             value: message.value,
             returnData: DUMMY_RETURN_DATA,
-            address: message.to.toBuffer(),
+            address: message.to.toBytes(),
             numberOfSubtraces: 0,
             depth: message.depth,
             gasUsed: DUMMY_GAS_USED,
-            codeAddress: codeAddress.toBuffer(),
+            codeAddress: codeAddress.toBytes(),
           };
 
           trace = callTrace;
@@ -227,7 +229,7 @@ export class VMTracer {
       trace.gasUsed = result.execResult.executionGasUsed;
 
       if (isCreateTrace(trace)) {
-        trace.deployedContract = result?.createdAddress?.toBuffer();
+        trace.deployedContract = result?.createdAddress?.toBytes();
       }
 
       if (this._messageTraces.length > 1) {

package/src/internal/solidity/compiler/downloader.ts

@@ -316,13 +316,14 @@ export class CompilerDownloader implements ICompilerDownloader {
     build: CompilerBuild,
     downloadPath: string
   ): Promise<boolean> {
-    const ethereumjsUtil = require("@nomicfoundation/ethereumjs-util");
+    const { bytesToHex } =
+      require("@nomicfoundation/ethereumjs-util") as typeof import("@nomicfoundation/ethereumjs-util");
     const { keccak256 } = await import("../../util/keccak");
 
     const expectedKeccak256 = build.keccak256;
     const compiler = await fsExtra.readFile(downloadPath);
 
-    const compilerKeccak256 = ethereumjsUtil.bufferToHex(keccak256(compiler));
+    const compilerKeccak256 = bytesToHex(keccak256(compiler));
 
     if (expectedKeccak256 !== compilerKeccak256) {
       await fsExtra.unlink(downloadPath);

package/src/internal/solidity/compiler/solc-info.ts

@@ -60,6 +60,7 @@ const defaultEvmTargets: { [key: string]: string } = {
   "0.8.21": "shanghai",
   "0.8.22": "shanghai",
   "0.8.23": "shanghai",
+  "0.8.24": "shanghai",
 };
 
 export function getEvmVersionFromSolcVersion(

package/src/internal/util/abi-helpers.ts

@@ -10,7 +10,7 @@ export class AbiHelpers {
   public static computeSelector(
     name: string,
     inputs: any[]
-  ): Buffer | undefined {
+  ): Uint8Array | undefined {
     try {
       const fragment = abi.FunctionFragment.from({
         type: "function",
@@ -26,7 +26,7 @@ export class AbiHelpers {
     }
   }
 
-  public static isValidCalldata(inputs: any[], calldata: Buffer): boolean {
+  public static isValidCalldata(inputs: any[], calldata: Uint8Array): boolean {
     try {
       abi.defaultAbiCoder.decode(inputs, calldata);
       return true;

package/src/internal/util/bigint.ts

@@ -34,13 +34,13 @@ export function toEvmWord(x: bigint | number): string {
   return x.toString(16).padStart(64, "0");
 }
 
-function bufferToBigInt(x: Buffer): bigint {
-  const hex = `0x${x.toString("hex")}`;
+function bufferToBigInt(x: Uint8Array): bigint {
+  const hex = `0x${Buffer.from(x).toString("hex")}`;
   return hex === "0x" ? 0n : BigInt(hex);
 }
 
 export function fromBigIntLike(
-  x: string | number | bigint | Buffer | undefined
+  x: string | number | bigint | Uint8Array | undefined
 ): bigint | undefined {
   if (x === undefined || typeof x === "bigint") {
     return x;
@@ -48,7 +48,7 @@ export function fromBigIntLike(
   if (typeof x === "number" || typeof x === "string") {
     return BigInt(x);
   }
-  if (Buffer.isBuffer(x)) {
+  if (x instanceof Uint8Array) {
     return bufferToBigInt(x);
   }
 

package/src/internal/util/hardforks.ts

@@ -17,6 +17,7 @@ export enum HardforkName {
   GRAY_GLACIER = "grayGlacier",
   MERGE = "merge",
   SHANGHAI = "shanghai",
+  CANCUN = "cancun",
 }
 
 const HARDFORKS_ORDER: HardforkName[] = [
@@ -36,6 +37,7 @@ const HARDFORKS_ORDER: HardforkName[] = [
   HardforkName.GRAY_GLACIER,
   HardforkName.MERGE,
   HardforkName.SHANGHAI,
+  HardforkName.CANCUN,
 ];
 
 export function getHardforkName(name: string): HardforkName {

package/src/internal/util/keccak.ts

@@ -1,5 +1,5 @@
 import createKeccakHash from "keccak";
 
-export function keccak256(data: Buffer): Buffer {
-  return createKeccakHash("keccak256").update(data).digest();
+export function keccak256(data: Uint8Array): Uint8Array {
+  return createKeccakHash("keccak256").update(Buffer.from(data)).digest();
 }