hardhat 2.10.1 → 2.11.0-dev.0

package/src/internal/hardhat-network/stack-traces/message-trace.ts

@@ -1,5 +1,4 @@
-import type { VmError } from "@ethereumjs/vm/dist/exceptions";
-import type { BN } from "ethereumjs-util";
+import type { EvmError } from "@ignored/evm";
 
 import type { Bytecode } from "./model";
 
@@ -15,10 +14,10 @@ export type DecodedEvmMessageTrace =
   | DecodedCallMessageTrace;
 
 export interface BaseMessageTrace {
-  value: BN;
+  value: bigint;
   returnData: Buffer;
-  error?: VmError;
-  gasUsed: BN;
+  error?: EvmError;
+  gasUsed: bigint;
   depth: number;
 }
 
@@ -29,9 +28,9 @@ export interface PrecompileMessageTrace extends BaseMessageTrace {
 
 export interface BaseEvmMessageTrace extends BaseMessageTrace {
   code: Buffer;
-  value: BN;
+  value: bigint;
   returnData: Buffer;
-  error?: VmError;
+  error?: EvmError;
   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/model.ts

@@ -1,4 +1,4 @@
-import { bufferToHex } from "ethereumjs-util";
+import { bufferToHex } from "@ignored/util";
 
 import { AbiHelpers } from "../../util/abi-helpers";
 

package/src/internal/hardhat-network/stack-traces/panic-errors.ts

@@ -1,6 +1,4 @@
-import { BN } from "ethereumjs-util";
-
-export function panicErrorCodeToMessage(errorCode: BN): string {
+export function panicErrorCodeToMessage(errorCode: number): string {
   const reason = panicErrorCodeToReason(errorCode);
 
   if (reason !== undefined) {
@@ -10,8 +8,8 @@ export function panicErrorCodeToMessage(errorCode: BN): string {
   return `reverted with unknown panic code 0x${errorCode.toString(16)}`;
 }
 
-function panicErrorCodeToReason(errorCode: BN): string | undefined {
-  switch (errorCode.toNumber()) {
+function panicErrorCodeToReason(errorCode: number): string | undefined {
+  switch (errorCode) {
     case 0x1:
       return "Assertion error";
     case 0x11:

package/src/internal/hardhat-network/stack-traces/solidity-errors.ts

@@ -1,4 +1,4 @@
-import { bufferToHex } from "ethereumjs-util";
+import { bufferToHex } from "@ignored/util";
 
 import { panicErrorCodeToMessage } from "./panic-errors";
 import {
@@ -263,6 +263,21 @@ function getMessageFromLastStackTraceEntry(
         return `VM Exception while processing transaction: reverted with reason string '${stackTraceEntry.message.decodeError()}'`;
       }
 
+      if (stackTraceEntry.message.isPanicReturnData()) {
+        const message = panicErrorCodeToMessage(
+          stackTraceEntry.message.decodePanic()
+        );
+        return `VM Exception while processing transaction: ${message}`;
+      }
+
+      if (!stackTraceEntry.message.isEmpty()) {
+        return `VM Exception while processing transaction: reverted with an unrecognized custom error`;
+      }
+
+      if (stackTraceEntry.isInvalidOpcodeError) {
+        return "VM Exception while processing transaction: invalid opcode";
+      }
+
       return "Transaction reverted without a reason string";
 
     case StackTraceEntryType.REVERT_ERROR:

package/src/internal/hardhat-network/stack-traces/solidity-stack-trace.ts

@@ -1,5 +1,3 @@
-import { BN } from "ethereumjs-util";
-
 import { ReturnData } from "../provider/return-data";
 
 import { ContractFunctionType } from "./model";
@@ -82,7 +80,7 @@ export interface RevertErrorStackTraceEntry {
 
 export interface PanicErrorStackTraceEntry {
   type: StackTraceEntryType.PANIC_ERROR;
-  errorCode: BN;
+  errorCode: number;
   sourceReference: SourceReference;
 }
 
@@ -100,7 +98,7 @@ export interface UnmappedSolc063RevertErrorStackTraceEntry {
 
 export interface FunctionNotPayableErrorStackTraceEntry {
   type: StackTraceEntryType.FUNCTION_NOT_PAYABLE_ERROR;
-  value: BN;
+  value: bigint;
   sourceReference: SourceReference;
 }
 
@@ -111,13 +109,13 @@ export interface InvalidParamsErrorStackTraceEntry {
 
 export interface FallbackNotPayableErrorStackTraceEntry {
   type: StackTraceEntryType.FALLBACK_NOT_PAYABLE_ERROR;
-  value: BN;
+  value: bigint;
   sourceReference: SourceReference;
 }
 
 export interface FallbackNotPayableAndNoReceiveErrorStackTraceEntry {
   type: StackTraceEntryType.FALLBACK_NOT_PAYABLE_AND_NO_RECEIVE_ERROR;
-  value: BN;
+  value: bigint;
   sourceReference: SourceReference;
 }
 
@@ -155,6 +153,7 @@ export interface UnrecognizedCreateErrorStackTraceEntry {
   type: StackTraceEntryType.UNRECOGNIZED_CREATE_ERROR;
   message: ReturnData;
   sourceReference?: undefined;
+  isInvalidOpcodeError: boolean;
 }
 
 export interface UnrecognizedContractErrorStackTraceEntry {
@@ -162,6 +161,7 @@ export interface UnrecognizedContractErrorStackTraceEntry {
   address: Buffer;
   message: ReturnData;
   sourceReference?: undefined;
+  isInvalidOpcodeError: boolean;
 }
 
 export interface OtherExecutionErrorStackTraceEntry {

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

@@ -1,3 +1,4 @@
+import { ERROR } from "@ignored/evm/dist/exceptions";
 import { ReturnData } from "../provider/return-data";
 
 import {
@@ -31,7 +32,7 @@ import {
   StackTraceEntryType,
 } from "./solidity-stack-trace";
 
-export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.9";
+export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.16";
 export const FIRST_SOLC_VERSION_SUPPORTED = "0.5.1";
 
 export class SolidityTracer {
@@ -101,11 +102,14 @@ export class SolidityTracer {
       }
     }
 
+    const isInvalidOpcodeError = trace.error?.error === ERROR.INVALID_OPCODE;
+
     if (isCreateTrace(trace)) {
       return [
         {
           type: StackTraceEntryType.UNRECOGNIZED_CREATE_ERROR,
           message: new ReturnData(trace.returnData),
+          isInvalidOpcodeError,
         },
       ];
     }
@@ -115,6 +119,7 @@ export class SolidityTracer {
         type: StackTraceEntryType.UNRECOGNIZED_CONTRACT_ERROR,
         address: trace.address,
         message: new ReturnData(trace.returnData),
+        isInvalidOpcodeError,
       },
     ];
   }

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

@@ -1,18 +1,20 @@
-import { TypedTransaction } from "@ethereumjs/tx";
-import VM from "@ethereumjs/vm";
-import { EVMResult } from "@ethereumjs/vm/dist/evm/evm";
-import { InterpreterStep } from "@ethereumjs/vm/dist/evm/interpreter";
-import Message from "@ethereumjs/vm/dist/evm/message";
+import { TypedTransaction } from "@ignored/tx";
+import { AfterTxEvent, VM } from "@ignored/vm";
+import { EVM, EVMResult } from "@ignored/evm";
+import { InterpreterStep } from "@ignored/evm/dist/interpreter";
+import { Message } from "@ignored/evm/dist/message";
 import {
-  EIP2929StateManager,
-  StateManager,
-} from "@ethereumjs/vm/dist/state/interface";
-import { Address, BN, setLengthLeft, toBuffer } from "ethereumjs-util";
+  Address,
+  bufferToBigInt,
+  setLengthLeft,
+  toBuffer,
+} from "@ignored/util";
 
 import { assertHardhatInvariant } from "../../core/errors";
 import { RpcDebugTracingConfig } from "../../core/jsonrpc/types/input/debugTraceTransaction";
 import { InvalidInputError } from "../../core/providers/errors";
 import { RpcDebugTraceOutput, RpcStructLog } from "../provider/output";
+import { BigIntUtils } from "../../util/bigint";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
@@ -54,6 +56,8 @@ export class VMDebugTracer {
   private _messages: DebugMessage[] = [];
   private _addressToStorage: Record<string, Storage> = {};
 
+  private _error: any;
+
   constructor(private readonly _vm: VM) {
     this._beforeMessageHandler = this._beforeMessageHandler.bind(this);
     this._afterMessageHandler = this._afterMessageHandler.bind(this);
@@ -75,6 +79,10 @@ export class VMDebugTracer {
 
       await action();
 
+      if (this._error !== undefined) {
+        throw this._error;
+      }
+
       return this._getDebugTrace();
     } finally {
       this._disableTracing();
@@ -83,19 +91,25 @@ export class VMDebugTracer {
 
   private _enableTracing(config: RpcDebugTracingConfig) {
     this._vm.on("beforeTx", this._beforeTxHandler);
-    this._vm.on("beforeMessage", this._beforeMessageHandler);
-    this._vm.on("step", this._stepHandler);
-    this._vm.on("afterMessage", this._afterMessageHandler);
+    (this._vm.evm as EVM).on("beforeMessage", this._beforeMessageHandler);
+    (this._vm.evm as EVM).on("step", this._stepHandler);
+    (this._vm.evm as EVM).on("afterMessage", this._afterMessageHandler);
     this._vm.on("afterTx", this._afterTxHandler);
     this._config = config;
   }
 
   private _disableTracing() {
     this._vm.removeListener("beforeTx", this._beforeTxHandler);
-    this._vm.removeListener("beforeMessage", this._beforeMessageHandler);
-    this._vm.removeListener("step", this._stepHandler);
+    (this._vm.evm as EVM).removeListener(
+      "beforeMessage",
+      this._beforeMessageHandler
+    );
+    (this._vm.evm as EVM).removeListener("step", this._stepHandler);
+    (this._vm.evm as EVM).removeListener(
+      "afterMessage",
+      this._afterMessageHandler
+    );
     this._vm.removeListener("afterTx", this._afterTxHandler);
-    this._vm.removeListener("afterMessage", this._afterMessageHandler);
     this._config = undefined;
   }
 
@@ -133,13 +147,20 @@ export class VMDebugTracer {
   }
 
   private async _stepHandler(step: InterpreterStep, next: any) {
-    assertHardhatInvariant(
-      this._messages.length > 0,
-      "Step handler should be called after at least one beforeMessage handler"
-    );
+    try {
+      assertHardhatInvariant(
+        this._messages.length > 0,
+        "Step handler should be called after at least one beforeMessage handler"
+      );
 
-    const structLog = await this._stepToStructLog(step);
-    this._messages[this._messages.length - 1].structLogs.push(structLog);
+      const structLog = await this._stepToStructLog(step);
+      this._messages[this._messages.length - 1].structLogs.push(structLog);
+    } catch (e: any) {
+      // errors thrown in event handlers are lost, so we save this error to
+      // re-throw it in the `trace` function
+      this._error = e;
+      this._disableTracing();
+    }
 
     next();
   }
@@ -156,7 +177,7 @@ export class VMDebugTracer {
     next();
   }
 
-  private async _afterTxHandler(result: EVMResult, next: any) {
+  private async _afterTxHandler(result: AfterTxEvent, next: any) {
     const { default: flattenDeep } = await import("lodash/flattenDeep");
     const topLevelMessage = this._messages[0];
 
@@ -192,7 +213,7 @@ export class VMDebugTracer {
     }
 
     this._lastTrace = {
-      gas: result.gasUsed.toNumber(),
+      gas: Number(result.totalGasSpent),
       failed: result.execResult.exceptionError !== undefined,
       returnValue: result.execResult.returnValue.toString("hex"),
       structLogs: rpcStructLogs,
@@ -289,7 +310,7 @@ export class VMDebugTracer {
   private _getStack(step: InterpreterStep): string[] {
     const stack = step.stack
       .slice()
-      .map((el: BN) => el.toString("hex").padStart(64, "0"));
+      .map((el: bigint) => el.toString(16).padStart(64, "0"));
     return stack;
   }
 
@@ -320,26 +341,25 @@ export class VMDebugTracer {
       storage[key] = storageValue;
     } else if (step.opcode.name === "REVERT") {
       const [offsetBuffer, lengthBuffer] = this._getFromStack(stack, 2);
-      const length = new BN(lengthBuffer);
-      const offset = new BN(offsetBuffer);
+      const length = bufferToBigInt(lengthBuffer);
+      const offset = bufferToBigInt(offsetBuffer);
 
       const [gasIncrease, addedWords] = this._memoryExpansion(
-        memory.length,
-        length.add(offset)
+        BigInt(memory.length),
+        length + offset
       );
 
-      gasCost += gasIncrease;
+      gasCost += Number(gasIncrease);
 
       for (let i = 0; i < addedWords; i++) {
         memory.push(EMPTY_MEMORY_WORD);
       }
     } else if (step.opcode.name === "CREATE2") {
       const [, , memoryUsedBuffer] = this._getFromStack(stack, 3);
-      const memoryUsed = new BN(memoryUsedBuffer);
-      const sha3ExtraCost = divUp(memoryUsed, 32)
-        .muln(this._sha3WordGas())
-        .toNumber();
-      gasCost += sha3ExtraCost;
+      const memoryUsed = bufferToBigInt(memoryUsedBuffer);
+      const sha3ExtraCost =
+        BigIntUtils.divUp(memoryUsed, 32n) * this._sha3WordGas();
+      gasCost += Number(sha3ExtraCost);
     } else if (
       step.opcode.name === "CALL" ||
       step.opcode.name === "STATICCALL" ||
@@ -371,22 +391,22 @@ export class VMDebugTracer {
         ] = this._getFromStack(stack, 7);
       }
 
-      const callCost = new BN(callCostBuffer);
+      const callCost = bufferToBigInt(callCostBuffer);
 
-      const value = new BN(valueBuffer);
+      const value = bufferToBigInt(valueBuffer);
 
-      const memoryLength = memory.length;
-      const inBN = new BN(inBuffer);
-      const inSizeBN = new BN(inSizeBuffer);
-      const inPosition = inSizeBN.isZero() ? inSizeBN : inBN.add(inSizeBN);
-      const outBN = new BN(outBuffer);
-      const outSizeBN = new BN(outSizeBuffer);
-      const outPosition = outSizeBN.isZero() ? outSizeBN : outBN.add(outSizeBN);
-      const memSize = inPosition.gt(outPosition) ? inPosition : outPosition;
+      const memoryLength = BigInt(memory.length);
+      const inBN = bufferToBigInt(inBuffer);
+      const inSizeBN = bufferToBigInt(inSizeBuffer);
+      const inPosition = inSizeBN === 0n ? inSizeBN : inBN + inSizeBN;
+      const outBN = bufferToBigInt(outBuffer);
+      const outSizeBN = bufferToBigInt(outSizeBuffer);
+      const outPosition = outSizeBN === 0n ? outSizeBN : outBN + outSizeBN;
+      const memSize = inPosition > outPosition ? inPosition : outPosition;
       const toAddress = new Address(recipientAddressBuffer.slice(-20));
 
       const constantGas = this._callConstantGas();
-      const availableGas = step.gasLeft.toNumber() - constantGas;
+      const availableGas = step.gasLeft - constantGas;
 
       const [memoryGas] = this._memoryExpansion(memoryLength, memSize);
 
@@ -398,7 +418,7 @@ export class VMDebugTracer {
         callCost
       );
 
-      gasCost = constantGas + dynamicGas;
+      gasCost = Number(constantGas + dynamicGas);
     } else if (step.opcode.name === "CALLCODE") {
       // finding an existing tx that uses CALLCODE or compiling a contract
       // so that it uses this opcode is hard,
@@ -417,13 +437,13 @@ export class VMDebugTracer {
     const structLog: StructLog = {
       pc: step.pc,
       op,
-      gas: step.gasLeft.toNumber(),
+      gas: Number(step.gasLeft),
       gasCost,
       depth: step.depth + 1,
       stack,
       memory,
       storage,
-      memSize: step.memoryWordCount.toNumber(),
+      memSize: Number(step.memoryWordCount),
     };
 
     if (error !== undefined) {
@@ -433,15 +453,15 @@ export class VMDebugTracer {
     return structLog;
   }
 
-  private _memoryGas(): number {
+  private _memoryGas(): bigint {
     return this._vm._common.param("gasPrices", "memory");
   }
 
-  private _sha3WordGas(): number {
+  private _sha3WordGas(): bigint {
     return this._vm._common.param("gasPrices", "sha3Word");
   }
 
-  private _callConstantGas(): number {
+  private _callConstantGas(): bigint {
     if (this._vm._common.gteHardfork("berlin")) {
       return this._vm._common.param("gasPrices", "warmstorageread");
     }
@@ -449,15 +469,15 @@ export class VMDebugTracer {
     return this._vm._common.param("gasPrices", "call");
   }
 
-  private _callNewAccountGas(): number {
+  private _callNewAccountGas(): bigint {
     return this._vm._common.param("gasPrices", "callNewAccount");
   }
 
-  private _callValueTransferGas(): number {
+  private _callValueTransferGas(): bigint {
     return this._vm._common.param("gasPrices", "callValueTransfer");
   }
 
-  private _quadCoeffDiv(): number {
+  private _quadCoeffDiv(): bigint {
     return this._vm._common.param("gasPrices", "quadCoeffDiv");
   }
 
@@ -475,23 +495,14 @@ export class VMDebugTracer {
 
   private async _callDynamicGas(
     address: Address,
-    value: BN,
-    availableGas: number,
-    memoryGas: number,
-    callCost: BN
-  ): Promise<number> {
+    value: bigint,
+    availableGas: bigint,
+    memoryGas: bigint,
+    callCost: bigint
+  ): Promise<bigint> {
     // The available gas is reduced when the address is cold
     if (this._vm._common.gteHardfork("berlin")) {
-      const stateManager = this._vm.stateManager as
-        | StateManager
-        | EIP2929StateManager;
-
-      assertHardhatInvariant(
-        "isWarmedAddress" in stateManager,
-        "The VM should have an EIP2929StateManger when berlin is enabled"
-      );
-
-      const isWarmed = stateManager.isWarmedAddress(address.toBuffer());
+      const isWarmed = this._vm.eei.isWarmedAddress(address.toBuffer());
 
       const coldCost =
         this._vm._common.param("gasPrices", "coldaccountaccess") -
@@ -505,9 +516,9 @@ export class VMDebugTracer {
       }
     }
 
-    let gas = 0;
+    let gas = 0n;
 
-    const transfersValue = !value.isZero();
+    const transfersValue = value !== 0n;
     const addressIsEmpty = await this._isAddressEmpty(address);
 
     if (transfersValue && addressIsEmpty) {
@@ -525,41 +536,45 @@ export class VMDebugTracer {
     return gas;
   }
 
-  private _callGas(availableGas: number, base: number, callCost: BN): number {
+  private _callGas(
+    availableGas: bigint,
+    base: bigint,
+    callCost: bigint
+  ): bigint {
     availableGas -= base;
 
-    const gas = availableGas - Math.floor(availableGas / 64);
+    const gas = availableGas - availableGas / 64n;
 
-    if (callCost.gtn(gas)) {
+    if (callCost > gas) {
       return gas;
     }
 
-    return callCost.toNumber();
+    return callCost;
   }
 
   /**
    * Returns the increase in gas and the number of added words
    */
   private _memoryExpansion(
-    currentWords: number,
-    newSize: BN
-  ): [number, number] {
-    const currentSize = new BN(currentWords).muln(32);
-    const currentWordsLength = currentSize.addn(31).divn(32);
-    const newWordsLength = newSize.addn(31).divn(32);
+    currentWords: bigint,
+    newSize: bigint
+  ): [bigint, bigint] {
+    const currentSize = currentWords * 32n;
+    const currentWordsLength = (currentSize + 31n) / 32n;
+    const newWordsLength = (newSize + 31n) / 32n;
 
-    const wordsDiff = newWordsLength.sub(currentWordsLength);
+    const wordsDiff = newWordsLength - currentWordsLength;
 
-    if (newSize.gt(currentSize)) {
+    if (newSize > currentSize) {
       const newTotalFee = this._memoryFee(newWordsLength);
       const currentTotalFee = this._memoryFee(currentWordsLength);
 
-      const fee = newTotalFee.sub(currentTotalFee);
+      const fee = newTotalFee - currentTotalFee;
 
-      return [fee.toNumber(), wordsDiff.toNumber()];
+      return [fee, wordsDiff];
     }
 
-    return [0, 0];
+    return [0n, 0n];
   }
 
   private _getFromStack(stack: string[], count: number): Buffer[] {
@@ -570,28 +585,16 @@ export class VMDebugTracer {
       .map(toBuffer);
   }
 
-  private _memoryFee(words: BN): BN {
-    const square = words.mul(words);
-    const linCoef = words.muln(this._memoryGas());
-    const quadCoef = square.divn(this._quadCoeffDiv());
-    const newTotalFee = linCoef.add(quadCoef);
+  private _memoryFee(words: bigint): bigint {
+    const square = words * words;
+    const linCoef = words * this._memoryGas();
+    const quadCoef = square / this._quadCoeffDiv();
+    const newTotalFee = linCoef + quadCoef;
 
     return newTotalFee;
   }
 }
 
-function divUp(x: BN, y: number | BN): BN {
-  y = new BN(y);
-
-  let result = x.div(y);
-
-  if (!x.mod(y).eqn(0)) {
-    result = result.addn(1);
-  }
-
-  return result;
-}
-
 function toWord(b: Buffer): string {
   return b.toString("hex").padStart(64, "0");
 }

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

@@ -1,9 +1,8 @@
-import VM from "@ethereumjs/vm";
-import { EVMResult } from "@ethereumjs/vm/dist/evm/evm";
-import { InterpreterStep } from "@ethereumjs/vm/dist/evm/interpreter";
-import Message from "@ethereumjs/vm/dist/evm/message";
-import { precompiles } from "@ethereumjs/vm/dist/evm/precompiles";
-import { Address, BN } from "ethereumjs-util";
+import { EVM, EVMResult, getActivePrecompiles } from "@ignored/evm";
+import { InterpreterStep } from "@ignored/evm/dist/interpreter";
+import { Message } from "@ignored/evm/dist/message";
+import { Address, bufferToBigInt } from "@ignored/util";
+import { VM } from "@ignored/vm";
 
 import {
   CallMessageTrace,
@@ -16,14 +15,14 @@ import {
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
-const MAX_PRECOMPILE_NUMBER = Object.keys(precompiles).length + 1;
 const DUMMY_RETURN_DATA = Buffer.from([]);
-const DUMMY_GAS_USED = new BN(0);
+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;
 
   constructor(
     private readonly _vm: VM,
@@ -39,9 +38,9 @@ export class VMTracer {
     if (this._enabled) {
       return;
     }
-    this._vm.on("beforeMessage", this._beforeMessageHandler);
-    this._vm.on("step", this._stepHandler);
-    this._vm.on("afterMessage", this._afterMessageHandler);
+    (this._vm.evm as EVM).on("beforeMessage", this._beforeMessageHandler);
+    (this._vm.evm as EVM).on("step", this._stepHandler);
+    (this._vm.evm as EVM).on("afterMessage", this._afterMessageHandler);
     this._enabled = true;
   }
 
@@ -49,9 +48,15 @@ export class VMTracer {
     if (!this._enabled) {
       return;
     }
-    this._vm.removeListener("beforeMessage", this._beforeMessageHandler);
-    this._vm.removeListener("step", this._stepHandler);
-    this._vm.removeListener("afterMessage", this._afterMessageHandler);
+    (this._vm.evm as EVM).removeListener(
+      "beforeMessage",
+      this._beforeMessageHandler
+    );
+    (this._vm.evm as EVM).removeListener("step", this._stepHandler);
+    (this._vm.evm as EVM).removeListener(
+      "afterMessage",
+      this._afterMessageHandler
+    );
     this._enabled = false;
   }
 
@@ -106,11 +111,11 @@ export class VMTracer {
 
         trace = createTrace;
       } else {
-        const toAsBn = new BN(message.to.toBuffer());
+        const toAsNumber = bufferToBigInt(message.to.toBuffer());
 
-        if (toAsBn.gtn(0) && toAsBn.lten(MAX_PRECOMPILE_NUMBER)) {
+        if (toAsNumber > 0 && toAsNumber <= this._maxPrecompileNumber) {
           const precompileTrace: PrecompileMessageTrace = {
-            precompile: toAsBn.toNumber(),
+            precompile: Number(toAsNumber),
             calldata: message.data,
             value: message.value,
             returnData: DUMMY_RETURN_DATA,
@@ -204,7 +209,7 @@ export class VMTracer {
 
       trace.error = result.execResult.exceptionError;
       trace.returnData = result.execResult.returnValue;
-      trace.gasUsed = result.gasUsed;
+      trace.gasUsed = result.execResult.executionGasUsed;
 
       if (isCreateTrace(trace)) {
         trace.deployedContract = result?.createdAddress?.toBuffer();