@aztec/simulator 0.82.2 → 0.82.3

package/src/public/public_tx_simulator/apps_tests/amm_test.ts

@@ -0,0 +1,316 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { AMMContractArtifact } from '@aztec/noir-contracts.js/AMM';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import { PublicTxSimulationTester } from '../../fixtures/public_tx_simulation_tester.js';
+import { deployToken } from './token_test.js';
+
+const INITIAL_TOKEN_BALANCE = 1_000_000_000n;
+/**
+ * THIS TEST IS BRITTLE! If it breaks, don't try fixing it.
+ * `.skip` it or literally just delete it and notify AVM team.
+ * You do NOT need permission to remove this test!
+ */
+export async function ammTest(tester: PublicTxSimulationTester, logger: Logger) {
+  const startTime = performance.now();
+
+  const admin = AztecAddress.fromNumber(42);
+  const sender = AztecAddress.fromNumber(111);
+
+  logger.debug(`Deploying tokens`);
+  const token0 = await deployToken(tester, admin, /*seed=*/ 0);
+  const token1 = await deployToken(tester, admin, /*seed=*/ 1);
+  const liquidityToken = await deployToken(tester, admin, /*seed=*/ 2);
+  logger.debug(`Deploying AMM`);
+  const constructorArgs = [token0, token1, liquidityToken];
+  const amm = await tester.registerAndDeployContract(
+    constructorArgs,
+    /*deployer=*/ admin,
+    AMMContractArtifact,
+    /*skipNullifierInsertion=*/ false,
+    /*seed=*/ 3,
+  );
+
+  const ammConstructorResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'constructor',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        fnName: 'constructor',
+        args: constructorArgs,
+        address: amm.address,
+      },
+    ],
+  );
+  expect(ammConstructorResult.revertCode.isOK()).toBe(true);
+
+  logger.debug(`Setting AMM as minter for liquidity token`);
+
+  // set the AMM as the minter for the liquidity token
+  const setMinterResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'set_minter',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        fnName: 'set_minter',
+        args: [/*minter=*/ amm, /*approve=*/ true],
+        address: liquidityToken.address,
+      },
+    ],
+  );
+  expect(setMinterResult.revertCode.isOK()).toBe(true);
+
+  logger.debug(`Adding liquidity`);
+  const amount0Max = (INITIAL_TOKEN_BALANCE * 6n) / 10n;
+  const amount0Min = (INITIAL_TOKEN_BALANCE * 4n) / 10n;
+  const amount1Max = (INITIAL_TOKEN_BALANCE * 5n) / 10n;
+  const amount1Min = (INITIAL_TOKEN_BALANCE * 4n) / 10n;
+
+  const addLiquidityResult = await addLiquidity(
+    tester,
+    sender,
+    /*amm=*/ amm,
+    /*token0=*/ token0,
+    /*token1=*/ token1,
+    /*liquidityToken=*/ liquidityToken,
+    /*amount0Max=*/ amount0Max,
+    /*amount1Max=*/ amount1Max,
+    /*amount0Min=*/ amount0Min,
+    /*amount1Min=*/ amount1Min,
+  );
+  expect(addLiquidityResult.revertCode.isOK()).toBe(true);
+
+  logger.debug(`Swapping tokens`);
+  const swapResult = await swapExactTokensForTokens(
+    tester,
+    sender,
+    /*amm=*/ amm,
+    /*tokenIn=*/ token0,
+    /*tokenOut=*/ token1,
+    /*amountIn=*/ amount0Min / 10n, // something smaller than total liquidity
+    /*amountOutMin=*/ amount1Min / 100n, // something even smaller
+  );
+  expect(swapResult.revertCode.isOK()).toBe(true);
+
+  logger.debug(`Removing liquidity`);
+  const removeLiquidityResult = await removeLiquidity(
+    tester,
+    sender,
+    /*amm=*/ amm,
+    /*token0=*/ token0,
+    /*token1=*/ token1,
+    /*liquidityToken=*/ liquidityToken,
+    /*liquidity=*/ 100n,
+    /*amount0Min=*/ 1n, // remove some tiny amount
+    /*amount1Min=*/ 1n,
+  );
+  expect(removeLiquidityResult.revertCode.isOK()).toBe(true);
+
+  const endTime = performance.now();
+
+  logger.info(`AMM public tx simulator test took ${endTime - startTime}ms\n`);
+}
+
+async function addLiquidity(
+  tester: PublicTxSimulationTester,
+  sender: AztecAddress,
+  amm: ContractInstanceWithAddress,
+  token0: ContractInstanceWithAddress,
+  token1: ContractInstanceWithAddress,
+  liquidityToken: ContractInstanceWithAddress,
+  amount0Max: bigint,
+  amount1Max: bigint,
+  amount0Min: bigint,
+  amount1Min: bigint,
+  _nonce?: bigint,
+) {
+  const refundToken0PartialNote = {
+    commitment: new Fr(42),
+  };
+  const refundToken1PartialNote = {
+    commitment: new Fr(66),
+  };
+  const liquidityPartialNote = {
+    commitment: new Fr(99),
+  };
+
+  return await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'add_liquidity',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      // token0.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ amount0Max],
+        address: token0.address,
+      },
+      // token0.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [refundToken0PartialNote],
+        address: token0.address,
+      },
+      // token1.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ amount1Max],
+        address: token1.address,
+      },
+      // token1.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [refundToken1PartialNote],
+        address: token1.address,
+      },
+      // liquidityToken.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: liquidityToken.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [liquidityPartialNote],
+        address: liquidityToken.address,
+      },
+      // amm.add_liquidity enqueues a call to _add_liquidity
+      {
+        sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_add_liquidity',
+        args: [
+          /*config=*/ {
+            token0: token0.address,
+            token1: token1.address,
+            // eslint-disable-next-line camelcase
+            liquidity_token: liquidityToken.address,
+          },
+          refundToken0PartialNote,
+          refundToken1PartialNote,
+          liquidityPartialNote,
+          amount0Max,
+          amount1Max,
+          amount0Min,
+          amount1Min,
+        ],
+        address: amm.address,
+      },
+    ],
+  );
+}
+
+async function swapExactTokensForTokens(
+  tester: PublicTxSimulationTester,
+  sender: AztecAddress,
+  amm: ContractInstanceWithAddress,
+  tokenIn: ContractInstanceWithAddress,
+  tokenOut: ContractInstanceWithAddress,
+  amountIn: bigint,
+  amountOutMin: bigint,
+  _nonce?: bigint,
+) {
+  const tokenOutPartialNote = {
+    commitment: new Fr(66),
+  };
+
+  return await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'swap_exact_tokens_for_tokens',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      // tokenIn.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: tokenIn.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ amountIn],
+        address: tokenIn.address,
+      },
+      // tokenOut.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: tokenOut.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [tokenOutPartialNote],
+        address: tokenOut.address,
+      },
+
+      {
+        sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_swap_exact_tokens_for_tokens',
+        args: [tokenIn.address, tokenOut.address, amountIn, amountOutMin, tokenOutPartialNote],
+        address: amm.address,
+      },
+    ],
+  );
+}
+
+async function removeLiquidity(
+  tester: PublicTxSimulationTester,
+  sender: AztecAddress,
+  amm: ContractInstanceWithAddress,
+  token0: ContractInstanceWithAddress,
+  token1: ContractInstanceWithAddress,
+  liquidityToken: ContractInstanceWithAddress,
+  liquidity: bigint,
+  amount0Min: bigint,
+  amount1Min: bigint,
+  _nonce?: bigint,
+) {
+  const token0PartialNote = {
+    commitment: new Fr(111),
+  };
+  const token1PartialNote = {
+    commitment: new Fr(222),
+  };
+
+  return await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'remove_liquidity',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      // liquidityToken.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: liquidityToken.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ liquidity],
+        address: liquidityToken.address,
+      },
+      // token0.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [token0PartialNote],
+        address: token0.address,
+      },
+      // token1.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [token1PartialNote],
+        address: token1.address,
+      },
+      // amm.remove_liquidity enqueues a call to _remove_liquidity
+      {
+        sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_remove_liquidity',
+        args: [
+          /*config=*/ {
+            token0: token0.address,
+            token1: token1.address,
+            // eslint-disable-next-line camelcase
+            liquidity_token: liquidityToken.address,
+          },
+          liquidity,
+          token0PartialNote,
+          token1PartialNote,
+          amount0Min,
+          amount1Min,
+        ],
+        address: amm.address,
+      },
+    ],
+  );
+}

package/src/public/public_tx_simulator/apps_tests/token_test.ts

@@ -0,0 +1,138 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import { PublicTxSimulationTester } from '../../fixtures/public_tx_simulation_tester.js';
+
+export async function tokenTest(tester: PublicTxSimulationTester, logger: Logger) {
+  const startTime = performance.now();
+
+  const admin = AztecAddress.fromNumber(42);
+  const sender = AztecAddress.fromNumber(111);
+  const receiver = AztecAddress.fromNumber(222);
+
+  const token = await deployToken(tester, admin);
+
+  const mintAmount = 100n;
+  const mintResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'mint_to_public',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'mint_to_public',
+        args: [/*to=*/ sender, mintAmount],
+      },
+    ],
+  );
+  expect(mintResult.revertCode.isOK()).toBe(true);
+  await checkBalance(tester, token, sender, sender, mintAmount);
+
+  const nonce = new Fr(0);
+  const transferAmount = 50n;
+  const transferResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'transfer_in_public',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'transfer_in_public',
+        args: [/*from=*/ sender, /*to=*/ receiver, transferAmount, nonce],
+      },
+    ],
+  );
+  expect(transferResult.revertCode.isOK()).toBe(true);
+  await checkBalance(tester, token, sender, receiver, mintAmount - transferAmount);
+  await checkBalance(tester, token, sender, receiver, transferAmount);
+
+  const balResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'balance_of_public',
+    sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'balance_of_public',
+        args: [/*owner=*/ receiver],
+        isStaticCall: true,
+      },
+    ],
+  );
+  expect(balResult.revertCode.isOK()).toBe(true);
+
+  const burnResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'burn_public',
+    /*sender=*/ receiver,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'burn_public',
+        args: [/*from=*/ receiver, transferAmount, nonce],
+      },
+    ],
+  );
+  expect(burnResult.revertCode.isOK()).toBe(true);
+  await checkBalance(tester, token, sender, receiver, 0n);
+
+  const endTime = performance.now();
+
+  logger.info(`TokenContract public tx simulator test took ${endTime - startTime}ms\n`);
+}
+
+export async function deployToken(tester: PublicTxSimulationTester, admin: AztecAddress, seed = 0) {
+  const constructorArgs = [admin, /*name=*/ 'Token', /*symbol=*/ 'TOK', /*decimals=*/ new Fr(18)];
+  const token = await tester.registerAndDeployContract(
+    constructorArgs,
+    /*deployer=*/ admin,
+    TokenContractArtifact,
+    /*skipNullifierInsertion=*/ false,
+    seed,
+  );
+
+  const result = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'Token.constructor',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        fnName: 'constructor',
+        args: constructorArgs,
+        address: token.address,
+      },
+    ],
+  );
+  expect(result.revertCode.isOK()).toBe(true);
+  return token;
+}
+
+async function checkBalance(
+  tester: PublicTxSimulationTester,
+  token: ContractInstanceWithAddress,
+  sender: AztecAddress,
+  account: AztecAddress,
+  expectedBalance: bigint,
+) {
+  const balResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'balance_of_public',
+    sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'balance_of_public',
+        args: [/*owner=*/ account],
+        isStaticCall: true,
+      },
+    ],
+  );
+  expect(balResult.revertCode.isOK()).toBe(true);
+  // should be 1 call with 1 return value that is expectedBalance
+  expect(balResult.processedPhases).toEqual([
+    expect.objectContaining({ returnValues: [expect.objectContaining({ values: [new Fr(expectedBalance)] })] }),
+  ]);
+}

package/src/public/public_tx_simulator/index.ts

@@ -0,0 +1,2 @@
+export * from './public_tx_simulator.js';
+export { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -0,0 +1,111 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { Timer } from '@aztec/foundation/timer';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { AvmSimulationStats } from '@aztec/stdlib/stats';
+import { type GlobalVariables, PublicCallRequestWithCalldata, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+
+import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import type { AvmPersistableStateManager } from '../avm/index.js';
+import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
+import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import { PublicTxContext } from './public_tx_context.js';
+import { type ProcessedPhase, type PublicTxResult, PublicTxSimulator } from './public_tx_simulator.js';
+
+/**
+ * A public tx simulator that tracks miscellaneous simulation metrics without telemetry.
+ */
+export class MeasuredPublicTxSimulator extends PublicTxSimulator {
+  constructor(
+    treesDB: PublicTreesDB,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    doMerkleOperations: boolean = false,
+    skipFeeEnforcement: boolean = false,
+    protected readonly metrics: ExecutorMetricsInterface,
+  ) {
+    super(treesDB, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement);
+  }
+
+  public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
+    this.metrics.startRecordingTxSimulation(txLabel);
+    let avmResult: PublicTxResult | undefined;
+    try {
+      avmResult = await super.simulate(tx);
+    } finally {
+      this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.revertCode);
+    }
+    return avmResult;
+  }
+
+  protected override async computeTxHash(tx: Tx) {
+    const timer = new Timer();
+    const txHash = await super.computeTxHash(tx);
+    this.metrics.recordTxHashComputation(timer.ms());
+    return txHash;
+  }
+
+  protected override async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
+    const timer = new Timer();
+    await super.insertNonRevertiblesFromPrivate(context, tx);
+    this.metrics.recordPrivateEffectsInsertion(timer.us(), 'non-revertible');
+  }
+
+  protected override async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<boolean> {
+    const timer = new Timer();
+    const result = await super.insertRevertiblesFromPrivate(context, tx);
+    this.metrics.recordPrivateEffectsInsertion(timer.us(), 'revertible');
+    return result;
+  }
+
+  protected override async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
+    const timer = new Timer();
+    const result = await super.simulatePhase(phase, context);
+    result.durationMs = timer.ms();
+    return result;
+  }
+
+  protected override async simulateEnqueuedCallInternal(
+    stateManager: AvmPersistableStateManager,
+    callRequest: PublicCallRequestWithCalldata,
+    allocatedGas: Gas,
+    transactionFee: Fr,
+    fnName: string,
+  ): Promise<AvmFinalizedCallResult> {
+    const timer = new Timer();
+    const result = await super.simulateEnqueuedCallInternal(
+      stateManager,
+      callRequest,
+      allocatedGas,
+      transactionFee,
+      fnName,
+    );
+
+    this.log.verbose(
+      result.reverted
+        ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason}.`
+        : `Simulation of enqueued public call ${fnName} completed successfully.`,
+      {
+        eventName: 'avm-simulation',
+        appCircuitName: fnName,
+        duration: timer.ms(),
+      } satisfies AvmSimulationStats,
+    );
+
+    if (result.reverted) {
+      this.metrics.recordEnqueuedCallSimulationFailure(
+        fnName,
+        timer.ms(),
+        allocatedGas.sub(result.gasLeft).l2Gas,
+        result.totalInstructions,
+      );
+    } else {
+      this.metrics.recordEnqueuedCallSimulation(
+        fnName,
+        timer.ms(),
+        allocatedGas.sub(result.gasLeft).l2Gas,
+        result.totalInstructions,
+      );
+    }
+    return result;
+  }
+}

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -39,7 +39,7 @@ import { inspect } from 'util';
 
 import type { PublicContractsDBInterface } from '../../server.js';
 import { AvmPersistableStateManager } from '../avm/index.js';
-import { HintingPublicContractsDB } from '../hinting_db_sources.js';
+import { HintingPublicContractsDB, HintingPublicTreesDB } from '../hinting_db_sources.js';
 import type { PublicTreesDB } from '../public_db_sources.js';
 import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
 import { getCallRequestsWithCalldataByPhase } from '../utils.js';
@@ -107,11 +107,11 @@ export class PublicTxContext {
     // We wrap the DB to collect AVM hints.
     const hints = new AvmExecutionHints();
     const hintingContractsDB = new HintingPublicContractsDB(contractsDB, hints);
-    // TODO: Wrap merkle db.
+    const hintingTreesDB = new HintingPublicTreesDB(treesDB, hints);
 
     // Transaction level state manager that will be forked for revertible phases.
     const txStateManager = AvmPersistableStateManager.create(
-      treesDB,
+      hintingTreesDB,
       hintingContractsDB,
       trace,
       doMerkleOperations,
@@ -308,7 +308,7 @@ export class PublicTxContext {
   /**
    * Generate the public inputs for the AVM circuit.
    */
-  public async generateAvmCircuitPublicInputs(endStateReference: StateReference): Promise<AvmCircuitPublicInputs> {
+  public async generateAvmCircuitPublicInputs(): Promise<AvmCircuitPublicInputs> {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
     const stateManager = this.state.getActiveStateManager();
 
@@ -319,14 +319,10 @@ export class PublicTxContext {
       this.startStateReference.partial.publicDataTree,
     );
 
-    // Will be patched/padded at the end of this fn
-    const endTreeSnapshots = new TreeSnapshots(
-      endStateReference.l1ToL2MessageTree,
-      endStateReference.partial.noteHashTree,
-      endStateReference.partial.nullifierTree,
-      endStateReference.partial.publicDataTree,
-    );
-
+    // FIXME: We are first creating the PIs with the wrong endTreeSnapshots, then patching them.
+    // This is because we need to know the lengths of the accumulated data arrays to pad them.
+    // We should refactor this to avoid this hack.
+    // We should just get the info we need from the trace, and create the rest of the PIs here.
     const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(
       this.globalVariables,
       startTreeSnapshots,
@@ -338,7 +334,7 @@ export class PublicTxContext {
       /*teardownCallRequest=*/ this.teardownCallRequests.length
         ? this.teardownCallRequests[0].request
         : PublicCallRequest.empty(),
-      endTreeSnapshots,
+      /*endTreeSnapshots=*/ TreeSnapshots.empty(), // Will be patched/padded at the end of this fn
       /*endGasUsed=*/ this.getTotalGasUsed(),
       /*transactionFee=*/ this.getTransactionFeeUnsafe(),
       /*reverted=*/ !this.revertCode.isOK(),