hardhat 2.22.4 → 2.22.6

package/src/internal/core/config/default-config.ts

@@ -141,6 +141,32 @@ export const defaultHardhatNetworkParams: Omit<
         ]),
       },
     ],
+    // TODO: the rest of this config is a temporary workaround,
+    // see https://github.com/NomicFoundation/edr/issues/522
+    [
+      10, // optimism mainnet
+      {
+        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
+      },
+    ],
+    [
+      11155420, // optimism sepolia
+      {
+        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
+      },
+    ],
+    [
+      42161, // arbitrum one
+      {
+        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
+      },
+    ],
+    [
+      421614, // arbitrum sepolia
+      {
+        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
+      },
+    ],
   ]),
 };
 

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

@@ -475,6 +475,17 @@ Please double check your transactions' parameters.`,
 Please check that you are sending an \`address\` parameter.`,
       shouldBeReported: false,
     },
+    EMPTY_URL: {
+      number: 117,
+      message:
+        "Empty string `%value%` for network or forking URL - Expected a non-empty string.",
+      title:
+        "Empty string `%value%` for network or forking URL - Expected a non-empty string.",
+      description: `You are trying to connect to a network with an empty network or forking URL.
+
+Please check that you are sending a non-empty string for network or forking \`URL\` parameter.`,
+      shouldBeReported: false,
+    },
   },
   TASK_DEFINITIONS: {
     PARAM_AFTER_VARIADIC: {

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

@@ -51,6 +51,12 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
 
     const { Pool, ProxyAgent } = require("undici") as typeof Undici;
 
+    if (this._url.trim().length === 0) {
+      throw new HardhatError(ERRORS.NETWORK.EMPTY_URL, {
+        value: this._url,
+      });
+    }
+
     const url = new URL(this._url);
     this._path = url.pathname;
     this._authHeader =

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

@@ -12,12 +12,9 @@ import type {
 import type {
   EdrContext,
   Provider as EdrProviderT,
-  ExecutionResult,
   RawTrace,
   Response,
   SubscriptionEvent,
-  TracingMessage,
-  TracingStep,
 } from "@nomicfoundation/edr";
 import { Common } from "@nomicfoundation/ethereumjs-common";
 import chalk from "chalk";
@@ -152,12 +149,6 @@ export function getNodeConfig(
   };
 }
 
-export interface RawTraceCallbacks {
-  onStep?: (messageTrace: TracingStep) => Promise<void>;
-  onBeforeMessage?: (messageTrace: TracingMessage) => Promise<void>;
-  onAfterMessage?: (messageTrace: ExecutionResult) => Promise<void>;
-}
-
 class EdrProviderEventAdapter extends EventEmitter {}
 
 type CallOverrideCallback = (
@@ -176,6 +167,9 @@ export class EdrProviderWrapper
   // temporarily added to make smock work with HH+EDR
   private _callOverrideCallback?: CallOverrideCallback;
 
+  /** Used for internal stack trace tests. */
+  private _vmTracer?: VMTracer;
+
   private constructor(
     private readonly _provider: EdrProviderT,
     // we add this for backwards-compatibility with plugins like solidity-coverage
@@ -184,7 +178,6 @@ export class EdrProviderWrapper
     },
     private readonly _eventAdapter: EdrProviderEventAdapter,
     private readonly _vmTraceDecoder: VmTraceDecoder,
-    private readonly _rawTraceCallbacks: RawTraceCallbacks,
     // The common configuration for EthereumJS VM is not used by EDR, but tests expect it as part of the provider.
     private readonly _common: Common,
     tracingConfig?: TracingConfig
@@ -199,7 +192,6 @@ export class EdrProviderWrapper
   public static async create(
     config: HardhatNetworkProviderConfig,
     loggerConfig: LoggerConfig,
-    rawTraceCallbacks: RawTraceCallbacks,
     tracingConfig?: TracingConfig
   ): Promise<EdrProviderWrapper> {
     const { Provider } = requireNapiRsModule(
@@ -325,7 +317,6 @@ export class EdrProviderWrapper
       minimalEthereumJsNode,
       eventAdapter,
       vmTraceDecoder,
-      rawTraceCallbacks,
       common,
       tracingConfig
     );
@@ -370,15 +361,21 @@ export class EdrProviderWrapper
 
     const needsTraces =
       this._node._vm.evm.events.eventNames().length > 0 ||
-      this._rawTraceCallbacks.onStep !== undefined ||
-      this._rawTraceCallbacks.onAfterMessage !== undefined ||
-      this._rawTraceCallbacks.onBeforeMessage !== undefined;
+      this._node._vm.events.eventNames().length > 0 ||
+      this._vmTracer !== undefined;
 
     if (needsTraces) {
       const rawTraces = responseObject.traces;
       for (const rawTrace of rawTraces) {
         const trace = rawTrace.trace();
+
+        // beforeTx event
+        if (this._node._vm.events.listenerCount("beforeTx") > 0) {
+          this._node._vm.events.emit("beforeTx");
+        }
+
         for (const traceItem of trace) {
+          // step event
           if ("pc" in traceItem) {
             if (this._node._vm.evm.events.listenerCount("step") > 0) {
               this._node._vm.evm.events.emit(
@@ -386,33 +383,37 @@ export class EdrProviderWrapper
                 edrTracingStepToMinimalInterpreterStep(traceItem)
               );
             }
-            if (this._rawTraceCallbacks.onStep !== undefined) {
-              await this._rawTraceCallbacks.onStep(traceItem);
-            }
-          } else if ("executionResult" in traceItem) {
+
+            this._vmTracer?.addStep(traceItem);
+          }
+          // afterMessage event
+          else if ("executionResult" in traceItem) {
             if (this._node._vm.evm.events.listenerCount("afterMessage") > 0) {
               this._node._vm.evm.events.emit(
                 "afterMessage",
                 edrTracingMessageResultToMinimalEVMResult(traceItem)
               );
             }
-            if (this._rawTraceCallbacks.onAfterMessage !== undefined) {
-              await this._rawTraceCallbacks.onAfterMessage(
-                traceItem.executionResult
-              );
-            }
-          } else {
+
+            this._vmTracer?.addAfterMessage(traceItem.executionResult);
+          }
+          // beforeMessage event
+          else {
             if (this._node._vm.evm.events.listenerCount("beforeMessage") > 0) {
               this._node._vm.evm.events.emit(
                 "beforeMessage",
                 edrTracingMessageToMinimalMessage(traceItem)
               );
             }
-            if (this._rawTraceCallbacks.onBeforeMessage !== undefined) {
-              await this._rawTraceCallbacks.onBeforeMessage(traceItem);
-            }
+
+            this._vmTracer?.addBeforeMessage(traceItem);
           }
         }
+
+        // afterTx event
+        if (this._node._vm.events.listenerCount("afterTx") > 0) {
+          this._node._vm.events.emit("afterTx");
+        }
       }
     }
 
@@ -467,6 +468,15 @@ export class EdrProviderWrapper
     }
   }
 
+  /**
+   * Sets a `VMTracer` that observes EVM throughout requests.
+   *
+   * Used for internal stack traces integration tests.
+   */
+  public setVmTracer(vmTracer?: VMTracer) {
+    this._vmTracer = vmTracer;
+  }
+
   // temporarily added to make smock work with HH+EDR
   private _setCallOverrideCallback(callback: CallOverrideCallback) {
     this._callOverrideCallback = callback;
@@ -478,6 +488,10 @@ export class EdrProviderWrapper
     );
   }
 
+  private _setVerboseTracing(enabled: boolean) {
+    this._provider.setVerboseTracing(enabled);
+  }
+
   private _ethEventListener(event: SubscriptionEvent) {
     const subscription = `0x${event.filterId.toString(16)}`;
     const results = Array.isArray(event.result) ? event.result : [event.result];
@@ -562,16 +576,16 @@ export class EdrProviderWrapper
   private async _rawTraceToSolidityStackTrace(
     rawTrace: RawTrace
   ): Promise<SolidityStackTrace | undefined> {
-    const vmTracer = new VMTracer(false);
+    const vmTracer = new VMTracer();
 
     const trace = rawTrace.trace();
     for (const traceItem of trace) {
       if ("pc" in traceItem) {
-        await vmTracer.addStep(traceItem);
+        vmTracer.addStep(traceItem);
       } else if ("executionResult" in traceItem) {
-        await vmTracer.addAfterMessage(traceItem.executionResult);
+        vmTracer.addAfterMessage(traceItem.executionResult);
       } else {
-        await vmTracer.addBeforeMessage(traceItem);
+        vmTracer.addBeforeMessage(traceItem);
       }
     }
 
@@ -613,7 +627,6 @@ export async function createHardhatNetworkProvider(
   return EdrProviderWrapper.create(
     hardhatNetworkProviderConfig,
     loggerConfig,
-    {},
     await makeTracingConfig(artifacts)
   );
 }

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

@@ -91,25 +91,4 @@ export class Exit {
 
     const _exhaustiveCheck: never = this.kind;
   }
-
-  public getEdrExceptionalHalt(): ExceptionalHalt {
-    const { ExceptionalHalt } = requireNapiRsModule(
-      "@nomicfoundation/edr"
-    ) as typeof import("@nomicfoundation/edr");
-
-    switch (this.kind) {
-      case ExitCode.OUT_OF_GAS:
-        return ExceptionalHalt.OutOfGas;
-      case ExitCode.INVALID_OPCODE:
-        return ExceptionalHalt.OpcodeNotFound;
-      case ExitCode.CODESIZE_EXCEEDS_MAXIMUM:
-        return ExceptionalHalt.CreateContractSizeLimit;
-      case ExitCode.CREATE_COLLISION:
-        return ExceptionalHalt.CreateCollision;
-
-      default:
-        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
-        throw new Error(`Unmatched exit code: ${this.kind}`);
-    }
-  }
 }

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/message-trace.ts

@@ -34,8 +34,6 @@ export interface PrecompileMessageTrace extends BaseMessageTrace {
 
 export interface BaseEvmMessageTrace extends BaseMessageTrace {
   code: Uint8Array;
-  value: bigint;
-  returnData: Uint8Array;
   steps: MessageTraceStep[];
   bytecode?: Bytecode;
   // The following is just an optimization: When processing this traces it's useful to know ahead of

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

@@ -26,6 +26,10 @@ import {
 const DUMMY_RETURN_DATA = Buffer.from([]);
 const DUMMY_GAS_USED = 0n;
 
+/**
+ * Consumes the incoming VM trace events, until an error occurs, to keep track
+ * of the last top level message trace/error.
+ */
 export class VMTracer {
   public tracingSteps: TracingStep[] = [];
 
@@ -33,7 +37,7 @@ export class VMTracer {
   private _lastError: Error | undefined;
   private _maxPrecompileNumber;
 
-  constructor(private readonly _throwErrors = true) {
+  constructor() {
     // TODO: temporarily hardcoded to remove the need of using ethereumjs' common and evm here
     this._maxPrecompileNumber = 10;
   }
@@ -46,15 +50,11 @@ export class VMTracer {
     return this._lastError;
   }
 
-  public clearLastError() {
-    this._lastError = undefined;
-  }
-
   private _shouldKeepTracing() {
-    return this._throwErrors || this._lastError === undefined;
+    return this._lastError === undefined;
   }
 
-  public async addBeforeMessage(message: TracingMessage) {
+  public addBeforeMessage(message: TracingMessage) {
     if (!this._shouldKeepTracing()) {
       return;
     }
@@ -143,15 +143,11 @@ export class VMTracer {
 
       this._messageTraces.push(trace);
     } catch (error) {
-      if (this._throwErrors) {
-        throw error;
-      } else {
-        this._lastError = error as Error;
-      }
+      this._lastError = error as Error;
     }
   }
 
-  public async addStep(step: TracingStep) {
+  public addStep(step: TracingStep) {
     if (!this._shouldKeepTracing()) {
       return;
     }
@@ -169,15 +165,11 @@ export class VMTracer {
 
       trace.steps.push({ pc: Number(step.pc) });
     } catch (error) {
-      if (this._throwErrors) {
-        throw error;
-      } else {
-        this._lastError = error as Error;
-      }
+      this._lastError = error as Error;
     }
   }
 
-  public async addAfterMessage(result: ExecutionResult, haltOverride?: Exit) {
+  public addAfterMessage(result: ExecutionResult) {
     if (!this._shouldKeepTracing()) {
       return;
     }
@@ -197,8 +189,7 @@ export class VMTracer {
           ).address;
         }
       } else if (isHaltResult(executionResult)) {
-        trace.exit =
-          haltOverride ?? Exit.fromEdrExceptionalHalt(executionResult.reason);
+        trace.exit = Exit.fromEdrExceptionalHalt(executionResult.reason);
 
         trace.returnData = Buffer.from([]);
       } else {
@@ -211,11 +202,7 @@ export class VMTracer {
         this._messageTraces.pop();
       }
     } catch (error) {
-      if (this._throwErrors) {
-        throw error;
-      } else {
-        this._lastError = error as Error;
-      }
+      this._lastError = error as Error;
     }
   }
 }

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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"}