hardhat 2.6.4 → 2.6.8

package/src/internal/core/providers/gas-providers.ts

@@ -142,7 +142,7 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
   public static readonly EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE: number = 3;
 
   // See eth_feeHistory for an explanation of what this means
-  public static readonly EIP1559_REWARD_PERCENTILE: number = 0.5;
+  public static readonly EIP1559_REWARD_PERCENTILE: number = 50;
 
   private _nodeHasFeeHistory?: boolean;
   private _nodeSupportsEIP1559?: boolean;

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

@@ -66,6 +66,9 @@ export class HardhatModule {
       case "hardhat_intervalMine":
         return this._intervalMineAction(...this._intervalMineParams(params));
 
+      case "hardhat_getAutomine":
+        return this._getAutomine();
+
       case "hardhat_stopImpersonatingAccount":
         return this._stopImpersonatingAction(
           ...this._stopImpersonatingParams(params)
@@ -184,6 +187,12 @@ export class HardhatModule {
     return true;
   }
 
+  // hardhat_getAutomine
+
+  private async _getAutomine(): Promise<boolean> {
+    return this._node.getAutomine();
+  }
+
   // hardhat_stopImpersonatingAccount
 
   private _stopImpersonatingParams(params: any[]): [Buffer] {

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

@@ -0,0 +1,39 @@
+import { Address, toRpcSig } from "ethereumjs-util";
+import { rpcAddress, rpcData } from "../../../core/jsonrpc/types/base-types";
+import { validateParams } from "../../../core/jsonrpc/types/input/validation";
+import { MethodNotFoundError } from "../../../core/providers/errors";
+import { HardhatNode } from "../node";
+
+/* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
+
+export class PersonalModule {
+  constructor(private readonly _node: HardhatNode) {}
+
+  public async processRequest(
+    method: string,
+    params: any[] = []
+  ): Promise<any> {
+    switch (method) {
+      case "personal_sign": {
+        return this._signAction(...this._signParams(params));
+      }
+    }
+
+    throw new MethodNotFoundError(`Method ${method} not found`);
+  }
+
+  // personal_sign
+
+  private _signParams(params: any[]): [Buffer, Buffer] {
+    return validateParams(params, rpcData, rpcAddress);
+  }
+
+  private async _signAction(data: Buffer, address: Buffer): Promise<string> {
+    const signature = await this._node.signPersonalMessage(
+      new Address(address),
+      data
+    );
+
+    return toRpcSig(signature.v, signature.r, signature.s);
+  }
+}

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

@@ -1103,6 +1103,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     this._automine = automine;
   }
 
+  public getAutomine() {
+    return this._automine;
+  }
+
   public async setBlockGasLimit(gasLimit: BN | number) {
     this._txPool.setBlockGasLimit(gasLimit);
     await this._txPool.updatePendingAndQueued();
@@ -1372,12 +1376,28 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         .map((hash) => this.getTransactionReceipt(hash))
     );
 
-    const effectiveGasPriceAndGas = receipts
-      .map((r) => ({
-        effectiveGasPrice: rpcQuantityToBN(r?.effectiveGasPrice!),
-        gasUsed: rpcQuantityToBN(r?.gasUsed!),
-      }))
-      .sort((a, b) => a.effectiveGasPrice.cmp(b.effectiveGasPrice));
+    const effectiveGasRewardAndGas = receipts
+      .map((r, i) => {
+        const tx = block.transactions[i];
+        const baseFeePerGas = block.header.baseFeePerGas ?? new BN(0);
+
+        // reward = min(maxPriorityFeePerGas, maxFeePerGas - baseFeePerGas)
+        let effectiveGasReward: BN;
+        if ("maxPriorityFeePerGas" in tx) {
+          effectiveGasReward = tx.maxFeePerGas.sub(baseFeePerGas);
+          if (tx.maxPriorityFeePerGas.lt(effectiveGasReward)) {
+            effectiveGasReward = tx.maxPriorityFeePerGas;
+          }
+        } else {
+          effectiveGasReward = tx.gasPrice.sub(baseFeePerGas);
+        }
+
+        return {
+          effectiveGasReward,
+          gasUsed: rpcQuantityToBN(r?.gasUsed!),
+        };
+      })
+      .sort((a, b) => a.effectiveGasReward.cmp(b.effectiveGasReward));
 
     return rewardPercentiles.map((p) => {
       let gasUsed = new BN(0);
@@ -1385,16 +1405,16 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         .muln(Math.ceil(p * FLOATS_PRECISION))
         .divn(100 * FLOATS_PRECISION);
 
-      for (const values of effectiveGasPriceAndGas) {
+      for (const values of effectiveGasRewardAndGas) {
         gasUsed = gasUsed.add(values.gasUsed);
 
         if (targetGas.lte(gasUsed)) {
-          return values.effectiveGasPrice;
+          return values.effectiveGasReward;
         }
       }
 
-      return effectiveGasPriceAndGas[effectiveGasPriceAndGas.length - 1]
-        .effectiveGasPrice;
+      return effectiveGasRewardAndGas[effectiveGasRewardAndGas.length - 1]
+        .effectiveGasReward;
     });
   }
 

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

@@ -32,6 +32,7 @@ import { EthModule } from "./modules/eth";
 import { EvmModule } from "./modules/evm";
 import { HardhatModule } from "./modules/hardhat";
 import { ModulesLogger } from "./modules/logger";
+import { PersonalModule } from "./modules/personal";
 import { NetModule } from "./modules/net";
 import { Web3Module } from "./modules/web3";
 import { HardhatNode } from "./node";
@@ -65,6 +66,7 @@ export class HardhatNetworkProvider
   private _evmModule?: EvmModule;
   private _hardhatModule?: HardhatModule;
   private _debugModule?: DebugModule;
+  private _personalModule?: PersonalModule;
   private readonly _mutex = new Mutex();
 
   constructor(
@@ -205,6 +207,10 @@ export class HardhatNetworkProvider
       return this._debugModule!.processRequest(method, params);
     }
 
+    if (method.startsWith("personal_")) {
+      return this._personalModule!.processRequest(method, params);
+    }
+
     throw new MethodNotFoundError(`Method ${method} not found`);
   }
 
@@ -265,6 +271,7 @@ export class HardhatNetworkProvider
       this._experimentalHardhatNetworkMessageTraceHooks
     );
     this._debugModule = new DebugModule(node);
+    this._personalModule = new PersonalModule(node);
 
     this._forwardNodeEvents(node);
   }

package/src/internal/hardhat-network/stack-traces/error-inferrer.ts

@@ -191,6 +191,25 @@ export class ErrorInferrer {
         return true;
       }
 
+      // look TWO frames ahead to determine if this is a specific occurrence of
+      // a redundant CALLSTACK_ENTRY frame observed when using Solidity 0.8.5:
+      if (
+        frame.type === StackTraceEntryType.CALLSTACK_ENTRY &&
+        i + 2 < stacktrace.length &&
+        stacktrace[i + 2].sourceReference !== undefined &&
+        stacktrace[i + 2].type === StackTraceEntryType.RETURNDATA_SIZE_ERROR
+      ) {
+        // ! below for tsc. we confirmed existence in the enclosing conditional.
+        const thatSrcRef = stacktrace[i + 2].sourceReference!;
+        if (
+          frame.sourceReference.range[0] === thatSrcRef.range[0] &&
+          frame.sourceReference.range[1] === thatSrcRef.range[1] &&
+          frame.sourceReference.line === thatSrcRef.line
+        ) {
+          return false;
+        }
+      }
+
       // constructors contain the whole contract, so we ignore them
       if (
         frame.sourceReference.function === "constructor" &&

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

@@ -31,7 +31,7 @@ import {
   StackTraceEntryType,
 } from "./solidity-stack-trace";
 
-export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.4";
+export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.9";
 export const FIRST_SOLC_VERSION_SUPPORTED = "0.5.1";
 
 export class SolidityTracer {

package/src/internal/lib/hardhat-lib.ts

@@ -8,10 +8,13 @@ import { ERRORS } from "../core/errors-list";
 import { getEnvHardhatArguments } from "../core/params/env-variables";
 import { HARDHAT_PARAM_DEFINITIONS } from "../core/params/hardhat-params";
 import { Environment } from "../core/runtime-environment";
+import { applyWorkaround } from "../util/antlr-prototype-pollution-workaround";
 
 let ctx: HardhatContext;
 let env: HardhatRuntimeEnvironment;
 
+applyWorkaround();
+
 if (HardhatContext.isCreated()) {
   ctx = HardhatContext.getHardhatContext();
 

package/src/internal/util/antlr-prototype-pollution-workaround.ts

@@ -0,0 +1,17 @@
+/**
+ * This function applies a workaround to an ANTLR issue that arises when used
+ * with Immutable.js.
+ *
+ * ANTLR defines String.prototype.hashCode, and Immutable.js uses hashCode
+ * functions internally (for equality), including on strings.
+ *
+ * If the parser is required lazily (which it normally is) in the middle of an
+ * execution, the custom state managers can break, because we'd be redefining
+ * the String's equality function as seen by Immutable.js.
+ *
+ * By always including the parser we make the equality function's definition
+ * stable during the entire execution.
+ */
+export function applyWorkaround() {
+  require("@solidity-parser/parser");
+}

package/src/register.ts

@@ -13,6 +13,9 @@ import {
   disableReplWriterShowProxy,
   isNodeCalledWithoutAScript,
 } from "./internal/util/console";
+import { applyWorkaround } from "./internal/util/antlr-prototype-pollution-workaround";
+
+applyWorkaround();
 
 if (!HardhatContext.isCreated()) {
   require("source-map-support/register");