hardhat 2.22.3 → 2.22.5

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

@@ -208,24 +208,55 @@ export function edrRpcDebugTraceToHardhat(
 export function edrTracingStepToMinimalInterpreterStep(
   step: TracingStep
 ): MinimalInterpreterStep {
-  return {
+  const minimalInterpreterStep: MinimalInterpreterStep = {
     pc: Number(step.pc),
     depth: step.depth,
     opcode: {
       name: step.opcode,
     },
-    stack: step.stackTop !== undefined ? [step.stackTop] : [],
+    stack: step.stack,
   };
+
+  if (step.memory !== undefined) {
+    minimalInterpreterStep.memory = step.memory;
+  }
+
+  return minimalInterpreterStep;
 }
 
 export function edrTracingMessageResultToMinimalEVMResult(
   tracingMessageResult: TracingMessageResult
 ): MinimalEVMResult {
-  return {
+  const { result, contractAddress } = tracingMessageResult.executionResult;
+
+  // only SuccessResult has logs
+  const success = "logs" in result;
+
+  const minimalEVMResult: MinimalEVMResult = {
     execResult: {
-      executionGasUsed: tracingMessageResult.executionResult.result.gasUsed,
+      executionGasUsed: result.gasUsed,
+      success,
     },
   };
+
+  // only success and exceptional halt have reason
+  if ("reason" in result) {
+    minimalEVMResult.execResult.reason = result.reason;
+  }
+  if ("output" in result) {
+    const { output } = result;
+    if (Buffer.isBuffer(output)) {
+      minimalEVMResult.execResult.output = output;
+    } else {
+      minimalEVMResult.execResult.output = output.returnValue;
+    }
+  }
+
+  if (contractAddress !== undefined) {
+    minimalEVMResult.execResult.contractAddress = new Address(contractAddress);
+  }
+
+  return minimalEVMResult;
 }
 
 export function edrTracingMessageToMinimalMessage(
@@ -241,5 +272,6 @@ export function edrTracingMessageToMinimalMessage(
     value: message.value,
     caller: new Address(message.caller),
     gasLimit: message.gasLimit,
+    isStaticCall: message.isStaticCall,
   };
 }

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

@@ -13,8 +13,9 @@ import { AsyncEventEmitter } from "@nomicfoundation/ethereumjs-util";
  * interface only has the things used by those plugins.
  */
 export interface MinimalEthereumJsVm {
+  events: AsyncEventEmitter<MinimalEthereumJsVmEvents>;
   evm: {
-    events: AsyncEventEmitter<MinimalEthereumJsVmEvents>;
+    events: AsyncEventEmitter<MinimalEthereumJsEvmEvents>;
   };
   stateManager: {
     putContractCode: (address: Address, code: Buffer) => Promise<void>;
@@ -27,10 +28,18 @@ export interface MinimalEthereumJsVm {
   };
 }
 
-// we need to use a type instead of an interface to satisfy the type constarint
+// we need to use a type instead of an interface to satisfy the type constraint
 // of the AsyncEventEmitter type param
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 type MinimalEthereumJsVmEvents = {
+  beforeTx: () => void;
+  afterTx: () => void;
+};
+
+// we need to use a type instead of an interface to satisfy the type constraint
+// of the AsyncEventEmitter type param
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type MinimalEthereumJsEvmEvents = {
   beforeMessage: (
     data: MinimalMessage,
     resolve?: (result?: any) => void
@@ -46,13 +55,15 @@ type MinimalEthereumJsVmEvents = {
 };
 
 export class MinimalEthereumJsVmEventEmitter extends AsyncEventEmitter<MinimalEthereumJsVmEvents> {}
+export class MinimalEthereumJsEvmEventEmitter extends AsyncEventEmitter<MinimalEthereumJsEvmEvents> {}
 
 export function getMinimalEthereumJsVm(
   provider: EdrProviderT
 ): MinimalEthereumJsVm {
   const minimalEthereumJsVm: MinimalEthereumJsVm = {
+    events: new MinimalEthereumJsVmEventEmitter(),
     evm: {
-      events: new MinimalEthereumJsVmEventEmitter(),
+      events: new MinimalEthereumJsEvmEventEmitter(),
     },
     stateManager: {
       putContractCode: async (address: Address, code: Buffer) => {

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

@@ -1,3 +1,4 @@
+import type { ExceptionalHalt, SuccessReason } from "@nomicfoundation/edr";
 import type { Address } from "@nomicfoundation/ethereumjs-util";
 
 /**
@@ -12,10 +13,15 @@ export interface MinimalInterpreterStep {
     name: string;
   };
   stack: bigint[];
+  memory?: Uint8Array;
 }
 
 export interface MinimalExecResult {
+  success: boolean;
   executionGasUsed: bigint;
+  contractAddress?: Address;
+  reason?: SuccessReason | ExceptionalHalt;
+  output?: Buffer;
 }
 
 export interface MinimalEVMResult {
@@ -29,4 +35,5 @@ export interface MinimalMessage {
   data: Uint8Array;
   caller: Address;
   gasLimit: bigint;
+  isStaticCall: boolean;
 }

package/src/internal/hardhat-network/stack-traces/source-maps.ts

@@ -75,14 +75,13 @@ function uncompressSourcemaps(compressedSourcemap: string): SourceMap[] {
 
 function addUnmappedInstructions(
   instructions: Instruction[],
-  bytecode: Buffer,
-  bytesIndex: number
+  bytecode: Buffer
 ) {
   const lastInstrPc = instructions[instructions.length - 1].pc;
-  let nextPc = lastInstrPc + 1;
+  let bytesIndex = lastInstrPc + 1;
 
-  while (bytecode[nextPc] !== Opcode.INVALID) {
-    const opcode = bytecode[nextPc];
+  while (bytecode[bytesIndex] !== Opcode.INVALID) {
+    const opcode = bytecode[bytesIndex];
     let pushData: Buffer | undefined;
 
     let pushDataLenth = 0;
@@ -95,10 +94,10 @@ function addUnmappedInstructions(
       ? JumpType.INTERNAL_JUMP
       : JumpType.NOT_JUMP;
 
-    const instruction = new Instruction(nextPc, opcode, jumpType, pushData);
+    const instruction = new Instruction(bytesIndex, opcode, jumpType, pushData);
     instructions.push(instruction);
 
-    nextPc += 1 + pushDataLenth;
+    bytesIndex += getOpcodeLength(opcode);
   }
 }
 
@@ -161,7 +160,7 @@ export function decodeInstructions(
 
   // See: https://github.com/ethereum/solidity/issues/9133
   if (isDeployment) {
-    addUnmappedInstructions(instructions, bytecode, bytesIndex);
+    addUnmappedInstructions(instructions, bytecode);
   }
 
   return instructions;

package/src/internal/solidity/compilation-job.ts

@@ -234,9 +234,9 @@ function getCompilerConfigForFile(
   transitiveDependencies: taskTypes.TransitiveDependency[],
   solidityConfig: SolidityConfig
 ): SolcConfig | CompilationJobCreationError {
-  const transitiveDependenciesVersionPragmas = transitiveDependencies.map(
-    ({ dependency }) => dependency.content.versionPragmas
-  );
+  const transitiveDependenciesVersionPragmas = transitiveDependencies
+    .map(({ dependency }) => dependency.content.versionPragmas)
+    .flat();
   const versionRange = Array.from(
     new Set([
       ...file.content.versionPragmas,

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

@@ -12,61 +12,39 @@ export interface ICompiler {
 }
 
 export class Compiler implements ICompiler {
-  private _loadedSolc?: any;
-
   constructor(private _pathToSolcJs: string) {}
 
   public async compile(input: CompilerInput) {
-    const solc = await this.getSolc();
-
-    const jsonOutput = solc.compile(JSON.stringify(input));
-    return JSON.parse(jsonOutput);
-  }
-
-  public async getSolc() {
-    if (this._loadedSolc !== undefined) {
-      return this._loadedSolc;
-    }
-
-    const solcWrapper = require("solc/wrapper");
-    this._loadedSolc = solcWrapper(
-      this._loadCompilerSources(this._pathToSolcJs)
-    );
-
-    return this._loadedSolc;
-  }
+    const scriptPath = path.join(__dirname, "./solcjs-runner.js");
 
-  /**
-   * This function loads the compiler sources bypassing any require hook.
-   *
-   * The compiler is a huge asm.js file, and using a simple require may trigger
-   * babel/register and hang the process.
-   */
-  private _loadCompilerSources(compilerPath: string) {
-    const Module = module.constructor as any;
-
-    // if Hardhat is bundled (for example, in the vscode extension), then
-    // Module._extenions might be undefined. In that case, we just use a plain
-    // require.
-    if (Module._extensions === undefined) {
-      return require(compilerPath);
-    }
-
-    const previousHook = Module._extensions[".js"];
-
-    Module._extensions[".js"] = function (
-      module: NodeJS.Module,
-      filename: string
-    ) {
-      const content = fs.readFileSync(filename, "utf8");
-      Object.getPrototypeOf(module)._compile.call(module, content, filename);
-    };
-
-    const loadedSolc = require(compilerPath);
+    const output: string = await new Promise((resolve, reject) => {
+      try {
+        const subprocess = execFile(
+          process.execPath,
+          [scriptPath, this._pathToSolcJs],
+          {
+            maxBuffer: 1024 * 1024 * 500,
+          },
+          (err, stdout) => {
+            if (err !== null) {
+              return reject(err);
+            }
+            resolve(stdout);
+          }
+        );
 
-    Module._extensions[".js"] = previousHook;
+        subprocess.stdin!.write(JSON.stringify(input));
+        subprocess.stdin!.end();
+      } catch (e: any) {
+        throw new HardhatError(
+          ERRORS.SOLC.SOLCJS_ERROR,
+          { error: e.message },
+          e
+        );
+      }
+    });
 
-    return loadedSolc;
+    return JSON.parse(output);
   }
 }
 

package/src/internal/solidity/compiler/solcjs-runner.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+async function readStream(stream, encoding = "utf8") {
+  stream.setEncoding(encoding);
+
+  return new Promise((resolve, reject) => {
+    let data = "";
+
+    stream.on("data", (chunk) => (data += chunk));
+    stream.on("end", () => resolve(data));
+    stream.on("error", (error) => reject(error));
+  });
+}
+
+function getSolcJs(solcJsPath) {
+  const solcWrapper = require("solc/wrapper");
+  return solcWrapper(require(solcJsPath));
+}
+
+async function main() {
+  const input = await readStream(process.stdin);
+
+  const solcjsPath = process.argv[2];
+  const solc = getSolcJs(solcjsPath);
+
+  const output = solc.compile(input);
+
+  console.log(output);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/internal/hardhat-network/provider/MiningTimer.d.ts

@@ -1,28 +0,0 @@
-import { IntervalMiningConfig } from "./node-types";
-/**
- * Timer used to periodically call the given mining function.
- *
- * `_blockTime` can be a number or a pair of numbers (of milliseconds).  If it
- * is a number, it will call the given function repeatedly every `_blockTime`
- * milliseconds. If it is a pair of numbers, then after each call it will
- * randomly choose how much to wait until the next call.
- *
- * `_mineFunction` is the function to call. It can be async, and it is assumed
- * that it will never throw.
- */
-export declare class MiningTimer {
-    private _blockTime;
-    private readonly _mineFunction;
-    private _state;
-    private _timeout;
-    constructor(_blockTime: IntervalMiningConfig, _mineFunction: () => Promise<any>);
-    getBlockTime(): IntervalMiningConfig;
-    enabled(): boolean;
-    setBlockTime(blockTime: IntervalMiningConfig): void;
-    start(): void;
-    stop(): void;
-    private _validateBlockTime;
-    private _loop;
-    private _getNextBlockTime;
-}
-//# sourceMappingURL=MiningTimer.d.ts.map

package/internal/hardhat-network/provider/MiningTimer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MiningTimer.d.ts","sourceRoot":"","sources":["../../../src/internal/hardhat-network/provider/MiningTimer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AASpD;;;;;;;;;;GAUG;AACH,qBAAa,WAAW;IAKpB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,QAAQ,CAAC,aAAa;IALhC,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,QAAQ,CAA+B;gBAGrC,UAAU,EAAE,oBAAoB,EACvB,aAAa,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC;IAK7C,YAAY,IAAI,oBAAoB;IAIpC,OAAO,IAAI,OAAO;IAIlB,YAAY,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI;IAiBnD,KAAK,IAAI,IAAI;IAWb,IAAI,IAAI,IAAI;IAYnB,OAAO,CAAC,kBAAkB;YAaZ,KAAK;IAcnB,OAAO,CAAC,iBAAiB;CAW1B"}

package/internal/hardhat-network/provider/MiningTimer.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiningTimer = void 0;
-var MiningTimerState;
-(function (MiningTimerState) {
-    MiningTimerState[MiningTimerState["STOP"] = 0] = "STOP";
-    MiningTimerState[MiningTimerState["RUNNING"] = 1] = "RUNNING";
-})(MiningTimerState || (MiningTimerState = {}));
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-/**
- * Timer used to periodically call the given mining function.
- *
- * `_blockTime` can be a number or a pair of numbers (of milliseconds).  If it
- * is a number, it will call the given function repeatedly every `_blockTime`
- * milliseconds. If it is a pair of numbers, then after each call it will
- * randomly choose how much to wait until the next call.
- *
- * `_mineFunction` is the function to call. It can be async, and it is assumed
- * that it will never throw.
- */
-class MiningTimer {
-    constructor(_blockTime, _mineFunction) {
-        this._blockTime = _blockTime;
-        this._mineFunction = _mineFunction;
-        this._state = MiningTimerState.STOP;
-        this._timeout = null;
-        this._validateBlockTime(_blockTime);
-    }
-    getBlockTime() {
-        return this._blockTime;
-    }
-    enabled() {
-        return this._blockTime !== 0;
-    }
-    setBlockTime(blockTime) {
-        this._validateBlockTime(blockTime);
-        if (blockTime === 0) {
-            this.stop();
-            return;
-        }
-        this._blockTime = blockTime;
-        if (this._state === MiningTimerState.RUNNING) {
-            this.stop();
-        }
-        this.start();
-    }
-    start() {
-        if (this._state === MiningTimerState.RUNNING || !this.enabled()) {
-            return;
-        }
-        const blockTime = this._getNextBlockTime();
-        this._state = MiningTimerState.RUNNING;
-        this._timeout = setTimeout(() => this._loop(), blockTime);
-    }
-    stop() {
-        if (this._state === MiningTimerState.STOP) {
-            return;
-        }
-        this._state = MiningTimerState.STOP;
-        if (this._timeout !== null) {
-            clearTimeout(this._timeout);
-        }
-    }
-    _validateBlockTime(blockTime) {
-        if (Array.isArray(blockTime)) {
-            const [rangeStart, rangeEnd] = blockTime;
-            if (rangeEnd < rangeStart) {
-                throw new Error("Invalid block time range");
-            }
-        }
-        else {
-            if (blockTime < 0) {
-                throw new Error("Block time cannot be negative");
-            }
-        }
-    }
-    async _loop() {
-        if (this._state === MiningTimerState.STOP) {
-            return;
-        }
-        await this._mineFunction();
-        const blockTime = this._getNextBlockTime();
-        this._timeout = setTimeout(() => {
-            this._loop(); // eslint-disable-line @typescript-eslint/no-floating-promises
-        }, blockTime);
-    }
-    _getNextBlockTime() {
-        if (Array.isArray(this._blockTime)) {
-            const [minBlockTime, maxBlockTime] = this._blockTime;
-            return (minBlockTime + Math.floor(Math.random() * (maxBlockTime - minBlockTime)));
-        }
-        return this._blockTime;
-    }
-}
-exports.MiningTimer = MiningTimer;
-//# sourceMappingURL=MiningTimer.js.map

package/internal/hardhat-network/provider/MiningTimer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MiningTimer.js","sourceRoot":"","sources":["../../../src/internal/hardhat-network/provider/MiningTimer.ts"],"names":[],"mappings":"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"}

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

@@ -1,118 +0,0 @@
-import { IntervalMiningConfig } from "./node-types";
-
-enum MiningTimerState {
-  STOP,
-  RUNNING,
-}
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-/**
- * Timer used to periodically call the given mining function.
- *
- * `_blockTime` can be a number or a pair of numbers (of milliseconds).  If it
- * is a number, it will call the given function repeatedly every `_blockTime`
- * milliseconds. If it is a pair of numbers, then after each call it will
- * randomly choose how much to wait until the next call.
- *
- * `_mineFunction` is the function to call. It can be async, and it is assumed
- * that it will never throw.
- */
-export class MiningTimer {
-  private _state = MiningTimerState.STOP;
-  private _timeout: NodeJS.Timeout | null = null;
-
-  constructor(
-    private _blockTime: IntervalMiningConfig,
-    private readonly _mineFunction: () => Promise<any>
-  ) {
-    this._validateBlockTime(_blockTime);
-  }
-
-  public getBlockTime(): IntervalMiningConfig {
-    return this._blockTime;
-  }
-
-  public enabled(): boolean {
-    return this._blockTime !== 0;
-  }
-
-  public setBlockTime(blockTime: IntervalMiningConfig): void {
-    this._validateBlockTime(blockTime);
-
-    if (blockTime === 0) {
-      this.stop();
-      return;
-    }
-
-    this._blockTime = blockTime;
-
-    if (this._state === MiningTimerState.RUNNING) {
-      this.stop();
-    }
-
-    this.start();
-  }
-
-  public start(): void {
-    if (this._state === MiningTimerState.RUNNING || !this.enabled()) {
-      return;
-    }
-
-    const blockTime = this._getNextBlockTime();
-
-    this._state = MiningTimerState.RUNNING;
-    this._timeout = setTimeout(() => this._loop(), blockTime);
-  }
-
-  public stop(): void {
-    if (this._state === MiningTimerState.STOP) {
-      return;
-    }
-
-    this._state = MiningTimerState.STOP;
-
-    if (this._timeout !== null) {
-      clearTimeout(this._timeout);
-    }
-  }
-
-  private _validateBlockTime(blockTime: IntervalMiningConfig) {
-    if (Array.isArray(blockTime)) {
-      const [rangeStart, rangeEnd] = blockTime;
-      if (rangeEnd < rangeStart) {
-        throw new Error("Invalid block time range");
-      }
-    } else {
-      if (blockTime < 0) {
-        throw new Error("Block time cannot be negative");
-      }
-    }
-  }
-
-  private async _loop() {
-    if (this._state === MiningTimerState.STOP) {
-      return;
-    }
-
-    await this._mineFunction();
-
-    const blockTime = this._getNextBlockTime();
-
-    this._timeout = setTimeout(() => {
-      this._loop(); // eslint-disable-line @typescript-eslint/no-floating-promises
-    }, blockTime);
-  }
-
-  private _getNextBlockTime(): number {
-    if (Array.isArray(this._blockTime)) {
-      const [minBlockTime, maxBlockTime] = this._blockTime;
-
-      return (
-        minBlockTime + Math.floor(Math.random() * (maxBlockTime - minBlockTime))
-      );
-    }
-
-    return this._blockTime;
-  }
-}