hardhat 2.6.6 → 2.7.1

package/src/internal/core/typescript-support.ts

@@ -38,16 +38,16 @@ export function isTypescriptSupported() {
   return cachedIsTypescriptSupported;
 }
 
-export function loadTsNode() {
+export function loadTsNode(tsConfigPath?: string) {
   try {
     require.resolve("typescript");
-  } catch (error) {
+  } catch {
     throw new HardhatError(ERRORS.GENERAL.TYPESCRIPT_NOT_INSTALLED);
   }
 
   try {
     require.resolve("ts-node");
-  } catch (error) {
+  } catch {
     throw new HardhatError(ERRORS.GENERAL.TS_NODE_NOT_INSTALLED);
   }
 
@@ -58,6 +58,10 @@ export function loadTsNode() {
     return;
   }
 
+  if (tsConfigPath !== undefined) {
+    process.env.TS_NODE_PROJECT = tsConfigPath;
+  }
+
   // See: https://github.com/nomiclabs/hardhat/issues/265
   if (process.env.TS_NODE_FILES === undefined) {
     process.env.TS_NODE_FILES = "true";

package/src/internal/hardhat-network/jsonrpc/client.ts

@@ -317,7 +317,7 @@ export class JsonRpcClient {
   ): Promise<any> {
     try {
       return await this._httpProvider.request({ method, params });
-    } catch (err) {
+    } catch (err: any) {
       if (this._shouldRetry(isRetryCall, err)) {
         return this._send(method, params, true);
       }
@@ -429,7 +429,7 @@ export class JsonRpcClient {
           encoding: "utf8",
         }
       );
-    } catch (error) {
+    } catch (error: any) {
       if (error.code === "ENOENT") {
         return undefined;
       }

package/src/internal/hardhat-network/jsonrpc/handler.ts

@@ -207,7 +207,12 @@ const _readJsonHttpRequest = async (req: IncomingMessage): Promise<any> => {
 
     json = JSON.parse(text);
   } catch (error) {
-    throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    if (error instanceof Error) {
+      throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw error;
   }
 
   return json;
@@ -218,7 +223,12 @@ const _readWsRequest = (msg: string): JsonRpcRequest => {
   try {
     json = JSON.parse(msg);
   } catch (error) {
-    throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    if (error instanceof Error) {
+      throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw error;
   }
 
   return json;

package/src/internal/hardhat-network/jsonrpc/server.ts

@@ -72,7 +72,7 @@ export class JsonRpcServer implements IJsonRpcServer {
 
   public close = async () => {
     await Promise.all([
-      new Promise((resolve, reject) => {
+      new Promise<void>((resolve, reject) => {
         log("Closing JSON-RPC server");
         this._httpServer.close((err) => {
           if (err !== null && err !== undefined) {
@@ -85,7 +85,7 @@ export class JsonRpcServer implements IJsonRpcServer {
           resolve();
         });
       }),
-      new Promise((resolve, reject) => {
+      new Promise<void>((resolve, reject) => {
         log("Closing websocket server");
         this._wsServer.close((err) => {
           if (err !== null && err !== undefined) {

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

@@ -2,7 +2,8 @@ import { TypedTransaction } from "@ethereumjs/tx";
 import { BN } from "ethereumjs-util";
 import Heap from "mnemonist/heap";
 
-import { InternalError } from "../../core/providers/errors";
+import { InternalError, InvalidInputError } from "../../core/providers/errors";
+import { MempoolOrder } from "./node-types";
 import { OrderedTransaction } from "./PoolState";
 
 function getEffectiveMinerFee(tx: OrderedTransaction, baseFee?: BN): BN {
@@ -38,6 +39,33 @@ function decreasingOrderEffectiveMinerFeeComparator(
   // in increasing order by orderId.
   return left.orderId - right.orderId;
 }
+
+function decreasingOrderComparator(
+  left: OrderedTransaction,
+  right: OrderedTransaction
+) {
+  return left.orderId - right.orderId;
+}
+
+function getOrderedTransactionHeap(
+  mempoolOrder: MempoolOrder,
+  baseFee?: BN
+): Heap<OrderedTransaction> {
+  switch (mempoolOrder) {
+    case "priority":
+      return new Heap<OrderedTransaction>((a, b) =>
+        decreasingOrderEffectiveMinerFeeComparator(a, b, baseFee)
+      );
+    case "fifo":
+      return new Heap<OrderedTransaction>((a, b) =>
+        decreasingOrderComparator(a, b)
+      );
+    default:
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw new InvalidInputError(`Invalid mempool order: ${mempoolOrder}`);
+  }
+}
+
 /**
  * A queue of transactions in the order that they could be mined in the next
  * block.
@@ -67,11 +95,10 @@ export class TransactionQueue {
    */
   constructor(
     pendingTransactions: Map<string, OrderedTransaction[]>,
+    mempoolOrder: MempoolOrder,
     baseFee?: BN
   ) {
-    this._heap = new Heap<OrderedTransaction>((a, b) =>
-      decreasingOrderEffectiveMinerFeeComparator(a, b, baseFee)
-    );
+    this._heap = getOrderedTransactionHeap(mempoolOrder, baseFee);
 
     for (const [address, txList] of pendingTransactions) {
       if (baseFee === undefined && txList.some((tx) => tx.data.type === 2)) {

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

@@ -332,7 +332,7 @@ export class TxPool {
   private _getSenderAddress(tx: TypedTransaction): Address {
     try {
       return tx.getSenderAddress(); // verifies signature
-    } catch (e) {
+    } catch (e: any) {
       if (!tx.isSigned()) {
         throw new InvalidInputError("Invalid Signature");
       }

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

@@ -215,9 +215,7 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
             : filterParams.addresses,
         topics: filterParams.normalizedTopics,
       });
-      return remoteLogs
-        .map((log, index) => toRpcLogOutput(log, index))
-        .concat(localLogs);
+      return remoteLogs.map(toRpcLogOutput).concat(localLogs);
     }
     return this._data.getLogs(filterParams);
   }
@@ -274,7 +272,7 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     // one for London.
     const common = this._common.copy();
     if (rpcBlock.baseFeePerGas !== undefined) {
-      common.setHardfork("london");
+      common.setHardfork("london"); // TODO: consider changing this to "latest hardfork"
     } else {
       common.setHardfork("berlin");
     }

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

@@ -959,29 +959,31 @@ export class EthModule {
       // AccessListEIP2930Transaction.fromSerializedTx and Transaction.fromSerializedTx
       // Please keep it updated.
 
-      if (error.message === "invalid remainder") {
-        throw new InvalidArgumentsError("Invalid transaction", error);
-      }
+      if (error instanceof Error) {
+        if (error.message === "invalid remainder") {
+          throw new InvalidArgumentsError("Invalid transaction", error);
+        }
 
-      if (error.message.includes("Incompatible EIP155")) {
-        throw new InvalidArgumentsError(
-          "Trying to send an incompatible EIP-155 transaction, signed for another chain.",
-          error
-        );
-      }
+        if (error.message.includes("Incompatible EIP155")) {
+          throw new InvalidArgumentsError(
+            "Trying to send an incompatible EIP-155 transaction, signed for another chain.",
+            error
+          );
+        }
 
-      if (
-        error.message.includes("TypedTransaction with ID") &&
-        error.message.includes(" unknown")
-      ) {
-        throw new InvalidArgumentsError(`Invalid transaction`, error);
-      }
+        if (
+          error.message.includes("TypedTransaction with ID") &&
+          error.message.includes(" unknown")
+        ) {
+          throw new InvalidArgumentsError(`Invalid transaction`, error);
+        }
 
-      if (error.message.includes("The chain ID does not match")) {
-        throw new InvalidArgumentsError(
-          `Trying to send a raw transaction with an invalid chainId. The expected chainId is ${this._common.chainIdBN()}`,
-          error
-        );
+        if (error.message.includes("The chain ID does not match")) {
+          throw new InvalidArgumentsError(
+            `Trying to send a raw transaction with an invalid chainId. The expected chainId is ${this._common.chainIdBN()}`,
+            error
+          );
+        }
       }
 
       throw error;
@@ -1065,7 +1067,7 @@ export class EthModule {
     if (typeof typedData === "string") {
       try {
         typedMessage = JSON.parse(typedData);
-      } catch (error) {
+      } catch {
         throw new InvalidInputError(
           `The message parameter is an invalid JSON. Either pass a valid JSON or a plain object conforming to EIP712 TypedData schema.`
         );

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)
@@ -105,6 +108,9 @@ export class HardhatModule {
         return this._setNextBlockBaseFeePerGasAction(
           ...this._setNextBlockBaseFeePerGasParams(params)
         );
+
+      case "hardhat_setCoinbase":
+        return this._setCoinbaseAction(...this._setCoinbaseParams(params));
     }
 
     throw new MethodNotFoundError(`Method ${method} not found`);
@@ -184,6 +190,12 @@ export class HardhatModule {
     return true;
   }
 
+  // hardhat_getAutomine
+
+  private async _getAutomine(): Promise<boolean> {
+    return this._node.getAutomine();
+  }
+
   // hardhat_stopImpersonatingAccount
 
   private _stopImpersonatingParams(params: any[]): [Buffer] {
@@ -233,7 +245,7 @@ export class HardhatModule {
 
     if (this._node.isEip1559Active()) {
       throw new InvalidInputError(
-        "hardhat_setMinGasPrice is not support when EIP-1559 is active"
+        "hardhat_setMinGasPrice is not supported when EIP-1559 is active"
       );
     }
 
@@ -337,6 +349,17 @@ export class HardhatModule {
     return true;
   }
 
+  // hardhat_setCoinbase
+
+  private _setCoinbaseParams(params: any[]): [Buffer] {
+    return validateParams(params, rpcAddress);
+  }
+
+  private async _setCoinbaseAction(address: Buffer) {
+    await this._node.setCoinbase(new Address(address));
+    return true;
+  }
+
   private async _logBlock(result: MineBlockResult) {
     const { block, traces } = result;
 

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-types.ts

@@ -3,6 +3,7 @@ import { RunBlockResult } from "@ethereumjs/vm/dist/runBlock";
 import { BN } from "ethereumjs-util";
 
 import { BuildInfo } from "../../../types";
+import { HARDHAT_MEMPOOL_SUPPORTED_ORDERS } from "../../constants";
 import { MessageTrace } from "../stack-traces/message-trace";
 
 import type { ReturnData } from "./return-data";
@@ -28,6 +29,8 @@ interface CommonConfig {
   initialDate?: Date;
   tracingConfig?: TracingConfig;
   initialBaseFeePerGas?: number;
+  mempoolOrder: MempoolOrder;
+  coinbase: string;
 }
 
 export type LocalNodeConfig = CommonConfig;
@@ -48,6 +51,8 @@ export interface TracingConfig {
 
 export type IntervalMiningConfig = number | [number, number];
 
+export type MempoolOrder = typeof HARDHAT_MEMPOOL_SUPPORTED_ORDERS[number];
+
 export interface GenesisAccount {
   privateKey: string;
   balance: string | number | BN;
@@ -121,6 +126,7 @@ export interface Snapshot {
   nextBlockTimestamp: BN;
   irregularStatesByBlockNumber: Map<string, Buffer>;
   userProvidedNextBlockBaseFeePerGas: BN | undefined;
+  coinbase: string;
 }
 
 export type SendTransactionResult =

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

@@ -82,6 +82,7 @@ import {
   GatherTracesResult,
   GenesisAccount,
   isForkedNodeConfig,
+  MempoolOrder,
   MineBlockResult,
   NodeConfig,
   RunCallResult,
@@ -115,10 +116,6 @@ const log = debug("hardhat:core:hardhat-network:node");
 
 const ethSigUtil = require("eth-sig-util");
 
-export const COINBASE_ADDRESS = Address.fromString(
-  "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e"
-);
-
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
 export class HardhatNode extends EventEmitter {
@@ -132,6 +129,7 @@ export class HardhatNode extends EventEmitter {
       allowUnlimitedContractSize,
       tracingConfig,
       minGasPrice,
+      mempoolOrder,
     } = config;
 
     let common: Common;
@@ -242,6 +240,8 @@ export class HardhatNode extends EventEmitter {
       automine,
       minGasPrice,
       initialBlockTimeOffset,
+      mempoolOrder,
+      config.coinbase,
       genesisAccounts,
       tracingConfig,
       forkNetworkId,
@@ -268,7 +268,7 @@ The hardfork must be at least spuriousDragon, but ${common.hardfork()} was given
       let upstreamCommon: Common;
       try {
         upstreamCommon = new Common({ chain: remoteChainId });
-      } catch (error) {
+      } catch {
         // If ethereumjs doesn't have a common it will throw and we won't have
         // info about the activation block of each hardfork, so we don't run
         // this validation.
@@ -315,6 +315,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     private _automine: boolean,
     private _minGasPrice: BN,
     private _blockTimeOffsetSeconds: BN = new BN(0),
+    private _mempoolOrder: MempoolOrder,
+    private _coinbase: string,
     genesisAccounts: GenesisAccount[],
     tracingConfig?: TracingConfig,
     private _forkNetworkId?: number,
@@ -367,7 +369,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         error
       );
 
-      Reporter.reportError(error);
+      if (error instanceof Error) {
+        Reporter.reportError(error);
+      }
     }
   }
 
@@ -434,16 +438,21 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     try {
       result = await this._mineBlockWithPendingTxs(blockTimestamp);
     } catch (err) {
-      if (err?.message.includes("sender doesn't have enough funds")) {
-        throw new InvalidInputError(err.message, err);
-      }
+      if (err instanceof Error) {
+        if (err?.message.includes("sender doesn't have enough funds")) {
+          throw new InvalidInputError(err.message, err);
+        }
+
+        // Some network errors are HardhatErrors, and can end up here when forking
+        if (HardhatError.isHardhatError(err)) {
+          throw err;
+        }
 
-      // Some network errors are HardhatErrors, and can end up here when forking
-      if (HardhatError.isHardhatError(err)) {
-        throw err;
+        throw new TransactionExecutionError(err);
       }
 
-      throw new TransactionExecutionError(err);
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw err;
     }
 
     await this._saveBlockAsSuccessfullyRun(result.block, result.blockResult);
@@ -697,7 +706,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   }
 
   public getCoinbaseAddress(): Address {
-    return COINBASE_ADDRESS;
+    return Address.fromString(this._coinbase);
   }
 
   public async getStorageAt(
@@ -870,6 +879,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       irregularStatesByBlockNumber: this._irregularStatesByBlockNumber,
       userProvidedNextBlockBaseFeePerGas:
         this.getUserProvidedNextBlockBaseFeePerGas(),
+      coinbase: this.getCoinbaseAddress().toString(),
     };
 
     this._irregularStatesByBlockNumber = new Map(
@@ -924,6 +934,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       this._resetUserProvidedNextBlockBaseFeePerGas();
     }
 
+    this._coinbase = snapshot.coinbase;
+
     // We delete this and the following snapshots, as they can only be used
     // once in Ganache
     this._snapshots.splice(snapshotIndex);
@@ -1103,6 +1115,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();
@@ -1345,6 +1361,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     };
   }
 
+  public async setCoinbase(coinbase: Address) {
+    this._coinbase = coinbase.toString();
+  }
+
   private _getGasUsedRatio(block: Block): number {
     const FLOATS_PRECISION = 100_000;
 
@@ -1372,12 +1392,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 +1421,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;
     });
   }
 
@@ -1479,7 +1515,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     try {
       sender = tx.getSenderAddress(); // verifies signature as a side effect
     } catch (e) {
-      throw new InvalidInputError(e.message);
+      if (e instanceof Error) {
+        throw new InvalidInputError(e.message);
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw e;
     }
 
     // validate nonce
@@ -1559,6 +1600,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       const pendingTxs = this._txPool.getPendingTransactions();
       const transactionQueue = new TransactionQueue(
         pendingTxs,
+        this._mempoolOrder,
         headerData.baseFeePerGas
       );
 
@@ -2306,7 +2348,7 @@ function getCommonForTracing(networkId: number, blockNumber: number): Common {
     common.setHardfork(common.activeHardfork(blockNumber));
 
     return common;
-  } catch (e) {
+  } catch {
     throw new InternalError(
       `Network id ${networkId} does not correspond to a network that Hardhat can trace`
     );

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

@@ -292,18 +292,18 @@ export function getRpcReceiptOutputsFromLocalBlockExecution(
 ): RpcReceiptOutput[] {
   const receipts: RpcReceiptOutput[] = [];
 
-  let cumulativeGasUsed = new BN(0);
+  let blockLogIndex = 0;
 
   for (let i = 0; i < runBlockResult.results.length; i += 1) {
     const tx = block.transactions[i];
     const { createdAddress, gasUsed } = runBlockResult.results[i];
     const receipt = runBlockResult.receipts[i];
 
-    cumulativeGasUsed = cumulativeGasUsed.add(new BN(receipt.gasUsed));
-
-    const logs = receipt.logs.map((log, logIndex) =>
-      getRpcLogOutput(log, tx, block, i, logIndex)
-    );
+    const logs = receipt.logs.map((log) => {
+      const result = getRpcLogOutput(log, tx, block, i, blockLogIndex);
+      blockLogIndex += 1;
+      return result;
+    });
 
     const rpcReceipt: RpcReceiptOutput = {
       transactionHash: bufferToRpcData(tx.hash()),
@@ -312,7 +312,7 @@ export function getRpcReceiptOutputsFromLocalBlockExecution(
       blockNumber: numberToRpcQuantity(new BN(block.header.number)),
       from: bufferToRpcData(tx.getSenderAddress().toBuffer()),
       to: tx.to === undefined ? null : bufferToRpcData(tx.to.toBuffer()),
-      cumulativeGasUsed: numberToRpcQuantity(cumulativeGasUsed),
+      cumulativeGasUsed: numberToRpcQuantity(new BN(receipt.gasUsed)),
       gasUsed: numberToRpcQuantity(gasUsed),
       contractAddress:
         createdAddress !== undefined
@@ -395,7 +395,7 @@ export function remoteReceiptToRpcReceiptOutput(
   };
 }
 
-export function toRpcLogOutput(log: RpcLog, index?: number): RpcLogOutput {
+export function toRpcLogOutput(log: RpcLog): RpcLogOutput {
   return {
     removed: false,
     address: bufferToRpcData(log.address),
@@ -403,7 +403,7 @@ export function toRpcLogOutput(log: RpcLog, index?: number): RpcLogOutput {
     blockNumber:
       log.blockNumber !== null ? numberToRpcQuantity(log.blockNumber) : null,
     data: bufferToRpcData(log.data),
-    logIndex: index !== undefined ? numberToRpcQuantity(index) : null,
+    logIndex: log.logIndex !== null ? numberToRpcQuantity(log.logIndex) : null,
     transactionIndex:
       log.transactionIndex !== null
         ? numberToRpcQuantity(log.transactionIndex)