@aztec/simulator 0.82.2 → 0.82.3

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -1,6 +1,5 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import {
@@ -14,7 +13,6 @@ import {
 import { SimulationError } from '@aztec/stdlib/errors';
 import type { Gas, GasUsed } from '@aztec/stdlib/gas';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
-import type { AvmSimulationStats } from '@aztec/stdlib/stats';
 import {
   type GlobalVariables,
   NestedProcessReturnValues,
@@ -22,7 +20,6 @@ import {
   Tx,
   TxExecutionPhase,
 } from '@aztec/stdlib/tx';
-import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { strict as assert } from 'assert';
 
@@ -30,13 +27,12 @@ import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmPersistableStateManager, AvmSimulator } from '../avm/index.js';
 import { NullifierCollisionError } from '../avm/journal/nullifiers.js';
-import { ExecutorMetrics } from '../executor_metrics.js';
 import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import { PublicTxContext } from './public_tx_context.js';
 
 export type ProcessedPhase = {
   phase: TxExecutionPhase;
-  durationMs: number;
+  durationMs?: number;
   returnValues: NestedProcessReturnValues[];
   reverted: boolean;
   revertReason?: SimulationError;
@@ -53,25 +49,18 @@ export type PublicTxResult = {
 };
 
 export class PublicTxSimulator {
-  metrics: ExecutorMetrics;
-
-  private log: Logger;
+  protected log: Logger;
 
   constructor(
     private treesDB: PublicTreesDB,
-    private contractsDB: PublicContractsDB,
+    protected contractsDB: PublicContractsDB,
     private globalVariables: GlobalVariables,
     private doMerkleOperations: boolean = false,
     private skipFeeEnforcement: boolean = false,
-    telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
     this.log = createLogger(`simulator:public_tx_simulator`);
-    this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
   }
 
-  get tracer(): Tracer {
-    return this.metrics.tracer;
-  }
   /**
    * Simulate a transaction's public portion including all of its phases.
    * @param tx - The transaction to simulate.
@@ -79,11 +68,9 @@ export class PublicTxSimulator {
    */
   public async simulate(tx: Tx): Promise<PublicTxResult> {
     try {
-      const startTime = process.hrtime.bigint();
+      const txHash = await this.computeTxHash(tx);
 
-      const txHash = await tx.getTxHash();
       this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, { txHash });
-
       const context = await PublicTxContext.create(
         this.treesDB,
         this.contractsDB,
@@ -92,13 +79,7 @@ export class PublicTxSimulator {
         this.doMerkleOperations,
       );
 
-      const nonRevertStart = process.hrtime.bigint();
-      await this.insertNonRevertiblesFromPrivate(context);
-      // add new contracts to the contracts db so that their functions may be found and called
-      // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-      await this.contractsDB.addNewNonRevertibleContracts(tx);
-      const nonRevertEnd = process.hrtime.bigint();
-      this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
+      await this.insertNonRevertiblesFromPrivate(context, tx);
 
       const processedPhases: ProcessedPhase[] = [];
       if (context.hasPhase(TxExecutionPhase.SETUP)) {
@@ -106,14 +87,8 @@ export class PublicTxSimulator {
         processedPhases.push(setupResult);
       }
 
-      const revertStart = process.hrtime.bigint();
-      const success = await this.insertRevertiblesFromPrivate(context);
+      const success = await this.insertRevertiblesFromPrivate(context, tx);
       if (success) {
-        // add new contracts to the contracts db so that their functions may be found and called
-        await this.contractsDB.addNewRevertibleContracts(tx);
-        const revertEnd = process.hrtime.bigint();
-        this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
-
         // Only proceed with app logic if there was no revert during revertible insertion
         if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
           const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
@@ -131,7 +106,7 @@ export class PublicTxSimulator {
       await context.halt();
       await this.payFee(context);
 
-      const publicInputs = await context.generateAvmCircuitPublicInputs(await this.treesDB.getStateReference());
+      const publicInputs = await context.generateAvmCircuitPublicInputs();
       const avmProvingRequest = PublicTxSimulator.generateProvingRequest(publicInputs, context.hints);
 
       const revertCode = context.getFinalRevertCode();
@@ -142,11 +117,10 @@ export class PublicTxSimulator {
       // Commit contracts from this TX to the block-level cache and clear tx cache
       // If the tx reverted, only commit non-revertible contracts
       // NOTE: You can't create contracts in public, so this is only relevant for private-created contracts
+      // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+      // However things should work as they are now because the hinted db would still pick up the new contracts.
       this.contractsDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
 
-      const endTime = process.hrtime.bigint();
-      this.log.debug(`Public TX simulator took ${Number(endTime - startTime) / 1_000_000} ms\n`);
-
       return {
         avmProvingRequest,
         gasUsed: {
@@ -162,10 +136,16 @@ export class PublicTxSimulator {
     } finally {
       // Make sure there are no new contracts in the tx-level cache.
       // They should either be committed to block-level cache or cleared.
+      // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+      // However things should work as they are now because the hinted db would still pick up the new contracts.
       this.contractsDB.clearContractsForTx();
     }
   }
 
+  protected async computeTxHash(tx: Tx) {
+    return await tx.getTxHash();
+  }
+
   /**
    * Simulate the setup phase of a transaction's public execution.
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
@@ -229,7 +209,7 @@ export class PublicTxSimulator {
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
    * @returns The phase result.
    */
-  private async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
+  protected async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
     const callRequests = context.getCallRequestsForPhase(phase);
 
     this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
@@ -241,7 +221,6 @@ export class PublicTxSimulator {
     const returnValues: NestedProcessReturnValues[] = [];
     let reverted = false;
     let revertReason: SimulationError | undefined;
-    const phaseTimer = new Timer();
     for (let i = callRequests.length - 1; i >= 0; i--) {
       if (reverted) {
         break;
@@ -261,7 +240,6 @@ export class PublicTxSimulator {
 
     return {
       phase,
-      durationMs: phaseTimer.ms(),
       returnValues,
       reverted,
       revertReason,
@@ -275,13 +253,7 @@ export class PublicTxSimulator {
    * @param callRequest - The public function call request, including the calldata.
    * @returns The result of execution.
    */
-  @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, callRequest) => ({
-    [Attributes.TX_HASH]: context.txHash.toString(),
-    [Attributes.TARGET_ADDRESS]: callRequest.request.contractAddress.toString(),
-    [Attributes.SENDER_ADDRESS]: callRequest.request.msgSender.toString(),
-    [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString(),
-  }))
-  private async simulateEnqueuedCall(
+  protected async simulateEnqueuedCall(
     phase: TxExecutionPhase,
     context: PublicTxContext,
     callRequest: PublicCallRequestWithCalldata,
@@ -335,19 +307,12 @@ export class PublicTxSimulator {
    * while still simulating phases and generating a proving request.
    *
    * @param stateManager - The state manager for AvmSimulation
-   * @param context - The context of the currently executing public transaction portion
    * @param callRequest - The public function call request, including the calldata.
    * @param allocatedGas - The gas allocated to the enqueued call
    * @param fnName - The name of the function
    * @returns The result of execution.
    */
-  @trackSpan(
-    'PublicTxSimulator.simulateEnqueuedCallInternal',
-    (_stateManager, _callRequest, _allocatedGas, _transactionFee, fnName) => ({
-      [Attributes.APP_CIRCUIT_NAME]: fnName,
-    }),
-  )
-  private async simulateEnqueuedCallInternal(
+  protected async simulateEnqueuedCallInternal(
     stateManager: AvmPersistableStateManager,
     { request, calldata }: PublicCallRequestWithCalldata,
     allocatedGas: Gas,
@@ -360,7 +325,6 @@ export class PublicTxSimulator {
     this.log.debug(
       `Executing enqueued public call to external function ${fnName}@${address} with ${allocatedGas.l2Gas} allocated L2 gas.`,
     );
-    const timer = new Timer();
 
     const simulator = await AvmSimulator.create(
       stateManager,
@@ -373,32 +337,13 @@ export class PublicTxSimulator {
       allocatedGas,
     );
     const avmCallResult = await simulator.execute();
-    const result = avmCallResult.finalize();
-
-    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.recordFunctionSimulationFailure();
-    } else {
-      this.metrics.recordFunctionSimulation(timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, fnName);
-    }
-
-    return result;
+    return avmCallResult.finalize();
   }
 
   /**
    * Insert the non-revertible accumulated data from private into the public state.
    */
-  public async insertNonRevertiblesFromPrivate(context: PublicTxContext) {
+  protected async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
     const stateManager = context.state.getActiveStateManager();
     try {
       await stateManager.writeSiloedNullifiersFromPrivate(context.nonRevertibleAccumulatedDataFromPrivate.nullifiers);
@@ -414,13 +359,18 @@ export class PublicTxSimulator {
         await stateManager.writeUniqueNoteHash(noteHash);
       }
     }
+    // add new contracts to the contracts db so that their functions may be found and called
+    // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+    // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+    // However things should work as they are now because the hinted db would still pick up the new contracts.
+    await this.contractsDB.addNewNonRevertibleContracts(tx);
   }
 
   /**
    * Insert the revertible accumulated data from private into the public state.
    * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
    */
-  public async insertRevertiblesFromPrivate(context: PublicTxContext): /*success=*/ Promise<boolean> {
+  protected async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): /*success=*/ Promise<boolean> {
     // Fork the state manager so we can rollback to end of setup if app logic reverts.
     await context.state.fork();
     const stateManager = context.state.getActiveStateManager();
@@ -448,6 +398,11 @@ export class PublicTxSimulator {
         await stateManager.writeSiloedNoteHash(noteHash);
       }
     }
+    // add new contracts to the contracts db so that their functions may be found and called
+    // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+    // However things should work as they are now because the hinted db would still pick up the new contracts.
+    await this.contractsDB.addNewRevertibleContracts(tx);
+
     return /*success=*/ true;
   }
 

package/src/public/public_tx_simulator/telemetry_public_tx_simulator.ts

@@ -0,0 +1,62 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { Gas } from '@aztec/stdlib/gas';
+import { type GlobalVariables, PublicCallRequestWithCalldata, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+
+import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import type { AvmPersistableStateManager } from '../avm/index.js';
+import { ExecutorMetrics } from '../executor_metrics.js';
+import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import { MeasuredPublicTxSimulator } from './measured_public_tx_simulator.js';
+import { PublicTxContext } from './public_tx_context.js';
+
+/**
+ * A public tx simulator that tracks runtime/production metrics with telemetry.
+ */
+export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
+  /* tracer needed by trackSpans */
+  public readonly tracer: Tracer;
+
+  constructor(
+    treesDB: PublicTreesDB,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    doMerkleOperations: boolean = false,
+    skipFeeEnforcement: boolean = false,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {
+    const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
+    super(treesDB, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement, metrics);
+    this.tracer = metrics.tracer;
+  }
+
+  @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, callRequest) => ({
+    [Attributes.TX_HASH]: context.txHash.toString(),
+    [Attributes.TARGET_ADDRESS]: callRequest.request.contractAddress.toString(),
+    [Attributes.SENDER_ADDRESS]: callRequest.request.msgSender.toString(),
+    [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString(),
+  }))
+  protected override async simulateEnqueuedCall(
+    phase: TxExecutionPhase,
+    context: PublicTxContext,
+    callRequest: PublicCallRequestWithCalldata,
+  ): Promise<AvmFinalizedCallResult> {
+    return await super.simulateEnqueuedCall(phase, context, callRequest);
+  }
+
+  @trackSpan(
+    'PublicTxSimulator.simulateEnqueuedCallInternal',
+    (_stateManager, _callRequest, _allocatedGas, _transactionFee, fnName) => ({
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    }),
+  )
+  protected override async simulateEnqueuedCallInternal(
+    stateManager: AvmPersistableStateManager,
+    callRequest: PublicCallRequestWithCalldata,
+    allocatedGas: Gas,
+    transactionFee: Fr,
+    fnName: string,
+  ): Promise<AvmFinalizedCallResult> {
+    return await super.simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName);
+  }
+}

package/src/public/test_executor_metrics.ts

@@ -0,0 +1,222 @@
+import { sum } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import type { RevertCode } from '@aztec/stdlib/avm';
+
+import { strict as assert } from 'assert';
+
+import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
+
+export interface PublicEnqueuedCallMetrics {
+  fnName: string;
+  durationMs: number;
+  manaUsed: number;
+  totalInstructions: number;
+  reverted: boolean;
+}
+
+export interface PublicTxMetrics {
+  totalDurationMs: number;
+  manaUsed: number;
+  totalInstructions: number;
+  txHashMs: number | undefined;
+  nonRevertiblePrivateInsertionsUs: number | undefined;
+  revertiblePrivateInsertionsUs: number | undefined;
+  enqueuedCalls: PublicEnqueuedCallMetrics[];
+  revertedCode: RevertCode | undefined;
+}
+
+const NUM_SPACES = 4;
+const H1 = '# ';
+const H2 = '\n## ';
+const INDENT = ' '.repeat(NUM_SPACES);
+const INDENT0 = '- ';
+const INDENT1 = INDENT + '- ';
+const INDENT2 = INDENT + INDENT + '- ';
+const H_LINE = '\n---------------------------------------------------------------------';
+
+export enum PublicTxMetricsFilter {
+  ALL,
+  TOTALS,
+  DURATIONS,
+  INSTRUCTIONS,
+}
+
+export class TestExecutorMetrics implements ExecutorMetricsInterface {
+  private logger: Logger;
+  // tx label -> tx metrics
+  private txMetrics: Map<string, PublicTxMetrics> = new Map();
+  private currentTxLabel: string | undefined;
+  private txTimer: Timer | undefined;
+
+  constructor() {
+    this.logger = createLogger(`simulator:test_executor_metrics`);
+  }
+
+  startRecordingTxSimulation(txLabel: string) {
+    assert(!this.currentTxLabel, 'Cannot start recording tx simulation when another is live');
+    assert(!this.txMetrics.has(txLabel), 'Cannot start recording metrics for tx with duplicate label');
+    this.txMetrics.set(txLabel, {
+      totalDurationMs: 0,
+      manaUsed: 0,
+      totalInstructions: 0,
+      txHashMs: undefined,
+      nonRevertiblePrivateInsertionsUs: undefined,
+      revertiblePrivateInsertionsUs: undefined,
+      enqueuedCalls: [],
+      revertedCode: undefined,
+    });
+    this.currentTxLabel = txLabel;
+    this.txTimer = new Timer();
+  }
+
+  stopRecordingTxSimulation(txLabel: string, revertedCode?: RevertCode) {
+    assert(this.currentTxLabel === txLabel, 'Cannot stop recording metrics for tx when another is live');
+
+    const txMetrics = this.txMetrics.get(txLabel)!;
+
+    // total duration of tx
+    txMetrics.totalDurationMs = this.txTimer!.ms();
+    this.logger.debug(`Public TX simulation of ${txLabel} took ${txMetrics.totalDurationMs}ms`);
+
+    // add manaUsed across all enqueued calls
+    txMetrics.manaUsed = sum(txMetrics.enqueuedCalls.map(call => call.manaUsed));
+    // add totalInstructions across all enqueued calls
+    txMetrics.totalInstructions = sum(txMetrics.enqueuedCalls.map(call => call.totalInstructions));
+    txMetrics.revertedCode = revertedCode;
+
+    this.currentTxLabel = undefined;
+  }
+
+  recordEnqueuedCallSimulation(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number) {
+    this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructions, false);
+  }
+
+  recordEnqueuedCallSimulationFailure(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number) {
+    this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructions, true);
+  }
+
+  #recordEnqueuedCallSimulation(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructions: number,
+    reverted: boolean,
+  ) {
+    assert(this.currentTxLabel, 'Cannot record enqueued call simulation when no tx is live');
+    const txMetrics = this.txMetrics.get(this.currentTxLabel)!;
+    txMetrics.enqueuedCalls.push({
+      fnName,
+      durationMs,
+      manaUsed,
+      totalInstructions,
+      reverted,
+    });
+  }
+
+  recordTxHashComputation(durationMs: number) {
+    assert(this.currentTxLabel, 'Cannot record tx hash computation time when no tx is live');
+    const txMetrics = this.txMetrics.get(this.currentTxLabel)!;
+    assert(txMetrics.txHashMs === undefined, 'Cannot RE-record tx hash computation time');
+    txMetrics.txHashMs = durationMs;
+  }
+
+  recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible') {
+    assert(this.currentTxLabel, 'Cannot record private effects insertion when no tx is live');
+    const txMetrics = this.txMetrics.get(this.currentTxLabel)!;
+    if (type === 'revertible') {
+      assert(
+        txMetrics.revertiblePrivateInsertionsUs === undefined,
+        'Cannot RE-record revertible insertions of private effects',
+      );
+      txMetrics.revertiblePrivateInsertionsUs = durationUs;
+    } else {
+      assert(
+        txMetrics.nonRevertiblePrivateInsertionsUs === undefined,
+        'Cannot RE-record non-revertible insertions of private effects',
+      );
+      txMetrics.nonRevertiblePrivateInsertionsUs = durationUs;
+    }
+  }
+
+  prettyPrint(filter: PublicTxMetricsFilter = PublicTxMetricsFilter.ALL) {
+    this.logger.info(this.toPrettyString(filter));
+  }
+
+  toPrettyString(filter: PublicTxMetricsFilter = PublicTxMetricsFilter.ALL) {
+    let pretty = '';
+    //pretty += H_LINE + '\n';
+    pretty += `${H1}Public TX Simulation Metrics (${PublicTxMetricsFilter[filter]})\n`;
+    for (const [txLabel, txMetrics] of this.txMetrics.entries()) {
+      //pretty += H_LINE + '\n';
+      pretty += `${H2}TX Label: ${txLabel}\n`;
+      if (
+        filter == PublicTxMetricsFilter.DURATIONS ||
+        filter === PublicTxMetricsFilter.TOTALS ||
+        filter === PublicTxMetricsFilter.ALL
+      ) {
+        pretty += `${INDENT0}Total duration: ${fmtNum(txMetrics.totalDurationMs, 'ms')}\n`;
+      }
+      if (filter === PublicTxMetricsFilter.TOTALS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT0}Total mana used: ${fmtNum(txMetrics.manaUsed)}\n`;
+        const manaPerSecond = Math.round((txMetrics.manaUsed * 1000) / txMetrics.totalDurationMs);
+        pretty += `${INDENT0}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+      }
+
+      if (
+        filter === PublicTxMetricsFilter.INSTRUCTIONS ||
+        filter === PublicTxMetricsFilter.TOTALS ||
+        filter === PublicTxMetricsFilter.ALL
+      ) {
+        pretty += `${INDENT0}Total instructions executed: ${fmtNum(txMetrics.totalInstructions)}\n`;
+      }
+      if (filter === PublicTxMetricsFilter.DURATIONS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT0}Tx hash computation: ${fmtNum(txMetrics.txHashMs!, 'ms')}\n`;
+        pretty += `${INDENT0}Private insertions:\n`;
+        pretty += `${INDENT1}Non-revertible: ${fmtNum(txMetrics.nonRevertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
+        pretty += `${INDENT1}Revertible: ${fmtNum(txMetrics.revertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
+      }
+      if (filter !== PublicTxMetricsFilter.TOTALS) {
+        // totals exclude enqueued calls
+        pretty += this.#enqueuedCallsToPrettyString(txMetrics, filter);
+      }
+      if (txMetrics.revertedCode !== undefined && !txMetrics.revertedCode.isOK()) {
+        pretty += `${INDENT0}Reverted code: ${txMetrics.revertedCode?.getDescription()}\n`;
+      }
+      pretty += H_LINE + '\n';
+    }
+    return pretty;
+  }
+
+  #enqueuedCallsToPrettyString(txMetrics: PublicTxMetrics, filter: PublicTxMetricsFilter) {
+    let pretty = '';
+    pretty += `${INDENT0}Enqueued public calls:\n`;
+    for (const enqueuedCall of txMetrics.enqueuedCalls) {
+      pretty += `${INDENT1}**Fn: ${enqueuedCall.fnName}**\n`;
+      if (filter === PublicTxMetricsFilter.DURATIONS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT2}Duration: ${fmtNum(enqueuedCall.durationMs, 'ms')}\n`;
+      }
+      if (filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT2}Mana used: ${fmtNum(enqueuedCall.manaUsed)}\n`;
+        const manaPerSecond = Math.round((enqueuedCall.manaUsed * 1000) / enqueuedCall.durationMs);
+        pretty += `${INDENT2}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+      }
+
+      if (filter === PublicTxMetricsFilter.INSTRUCTIONS || filter === PublicTxMetricsFilter.ALL) {
+        pretty += `${INDENT2}Instructions executed: ${fmtNum(enqueuedCall.totalInstructions)}\n`;
+      }
+      if (enqueuedCall.reverted) {
+        pretty += `${INDENT2}Reverted!\n`;
+      }
+    }
+    return pretty;
+  }
+
+  toJSON(indent = 2) {
+    return JSON.stringify(Object.fromEntries(this.txMetrics.entries()), null, indent);
+  }
+}
+
+function fmtNum(num: number, unit?: string) {
+  return `\`${num.toLocaleString()}${unit ? ` ${unit}` : ''}\``;
+}