@aztec/simulator 0.47.0 → 0.48.0

package/src/public/abstract_phase_manager.ts

@@ -3,6 +3,7 @@ import {
   type AvmProvingRequest,
   MerkleTreeId,
   type NestedProcessReturnValues,
+  type PublicExecutionRequest,
   type PublicKernelNonTailRequest,
   PublicKernelType,
   type PublicProvingRequest,
@@ -13,8 +14,6 @@ import {
 import {
   type AvmExecutionHints,
   AztecAddress,
-  CallRequest,
-  ClientIvcProof,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
@@ -40,7 +39,7 @@ import {
   NoteHash,
   Nullifier,
   PublicCallData,
-  type PublicCallRequest,
+  PublicCallRequest,
   PublicCallStackItem,
   PublicCircuitPublicInputs,
   PublicKernelCircuitPrivateInputs,
@@ -62,7 +61,6 @@ import {
   getVKSiblingPath,
 } from '@aztec/noir-protocol-circuits-types';
 import {
-  type PublicExecutionRequest,
   type PublicExecutionResult,
   type PublicExecutor,
   accumulateReturnValues,
@@ -165,76 +163,18 @@ export abstract class AbstractPhaseManager {
     previousKernelArtifact: ProtocolArtifact,
   ): Promise<PhaseResult>;
 
-  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelType, PublicCallRequest[]> {
-    const data = tx.data.forPublic;
-    if (!data) {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: [],
-        [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: [],
-        [PublicKernelType.TAIL]: [],
-      };
-    }
-    const publicCallsStack = tx.enqueuedPublicFunctionCalls.slice().reverse();
-    const nonRevertibleCallStack = data.endNonRevertibleData.publicCallStack.filter(i => !i.isEmpty());
-    const revertibleCallStack = data.end.publicCallStack.filter(i => !i.isEmpty());
-
-    const callRequestsStack = publicCallsStack
-      .map(call => call.toCallRequest())
-      .filter(
-        // filter out enqueued calls that are not in the public call stack
-        // TODO mitch left a question about whether this is only needed when unit testing
-        // with mock data
-        call => revertibleCallStack.find(p => p.equals(call)) || nonRevertibleCallStack.find(p => p.equals(call)),
-      );
-
-    const teardownCallStack = tx.publicTeardownFunctionCall.isEmpty() ? [] : [tx.publicTeardownFunctionCall];
-
-    if (callRequestsStack.length === 0) {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: [],
-        [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    }
-
-    // find the first call that is revertible
-    const firstRevertibleCallIndex = callRequestsStack.findIndex(
-      c => revertibleCallStack.findIndex(p => p.equals(c)) !== -1,
-    );
-
-    if (firstRevertibleCallIndex === 0) {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: [],
-        [PublicKernelType.APP_LOGIC]: publicCallsStack,
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    } else if (firstRevertibleCallIndex === -1) {
-      // there's no app logic, split the functions between setup (many) and teardown (just one function call)
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: publicCallsStack,
-        [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    } else {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex),
-        [PublicKernelType.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    }
+  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelType, PublicExecutionRequest[]> {
+    const teardownRequest = tx.getPublicTeardownExecutionRequest();
+    return {
+      [PublicKernelType.NON_PUBLIC]: [],
+      [PublicKernelType.SETUP]: tx.getNonRevertiblePublicExecutionRequests(),
+      [PublicKernelType.APP_LOGIC]: tx.getRevertiblePublicExecutionRequests(),
+      [PublicKernelType.TEARDOWN]: teardownRequest ? [teardownRequest] : [],
+      [PublicKernelType.TAIL]: [],
+    };
   }
 
-  protected extractEnqueuedPublicCalls(tx: Tx): PublicCallRequest[] {
+  protected extractEnqueuedPublicCalls(tx: Tx): PublicExecutionRequest[] {
     const calls = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx)[this.phase];
 
     return calls;
@@ -245,7 +185,7 @@ export abstract class AbstractPhaseManager {
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousKernelArtifact: ProtocolArtifact,
   ): Promise<TxPublicCallsResult> {
-    const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
+    const enqueuedCalls = [...this.extractEnqueuedPublicCalls(tx)].reverse();
 
     if (!enqueuedCalls || !enqueuedCalls.length) {
       return {
@@ -299,7 +239,7 @@ export abstract class AbstractPhaseManager {
 
         // Sanity check for a current upstream assumption.
         // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
-        const functionSelector = result.executionRequest.functionSelector.toString();
+        const functionSelector = result.executionRequest.callContext.functionSelector.toString();
         if (result.reverted && !result.revertReason) {
           throw new Error(
             `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
@@ -420,7 +360,7 @@ export abstract class AbstractPhaseManager {
     const previousKernel = this.getPreviousKernelData(previousOutput, previousCircuit);
 
     // We take a deep copy (clone) of these inputs to be passed to the prover
-    const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, ClientIvcProof.empty(), callData);
+    const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
     switch (this.phase) {
       case PublicKernelType.SETUP:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitSetup(inputs), 'PublicKernelSetupArtifact'];
@@ -460,13 +400,6 @@ export abstract class AbstractPhaseManager {
     const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
     this.historicalHeader.state.partial.publicDataTree.root = Fr.fromBuffer(publicDataTreeInfo.root);
 
-    const callStackPreimages = await this.getPublicCallStackPreimages(result);
-    const publicCallStackHashes = padArrayEnd(
-      callStackPreimages.map(c => c.getCompressed().hash()),
-      Fr.ZERO,
-      MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
-    );
-
     const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
       callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
@@ -507,7 +440,11 @@ export abstract class AbstractPhaseManager {
         ContractStorageUpdateRequest.empty(),
         MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
       ),
-      publicCallStackHashes,
+      publicCallRequests: padArrayEnd(
+        result.publicCallRequests,
+        PublicCallRequest.empty(),
+        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+      ),
       unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
       historicalHeader: this.historicalHeader,
       globalVariables: this.globalVariables,
@@ -520,23 +457,12 @@ export abstract class AbstractPhaseManager {
 
     return new PublicCallStackItem(
       result.executionRequest.contractAddress,
-      new FunctionData(result.executionRequest.functionSelector, false),
+      new FunctionData(result.executionRequest.callContext.functionSelector, false),
       publicCircuitPublicInputs,
       isExecutionRequest,
     );
   }
 
-  protected async getPublicCallStackPreimages(result: PublicExecutionResult): Promise<PublicCallStackItem[]> {
-    const nested = result.nestedExecutions;
-    if (nested.length > MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL) {
-      throw new Error(
-        `Public call stack size exceeded (max ${MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL}, got ${nested.length})`,
-      );
-    }
-
-    return await Promise.all(nested.map(n => this.getPublicCallStackItem(n)));
-  }
-
   /**
    * Looks at the side effects of a transaction and returns the highest counter
    * @param tx - A transaction
@@ -562,10 +488,7 @@ export abstract class AbstractPhaseManager {
 
     let max = 0;
     for (const sideEffect of sideEffectCounters) {
-      if ('startSideEffectCounter' in sideEffect) {
-        // look at both start and end counters because for enqueued public calls start > 0 while end === 0
-        max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
-      } else if ('counter' in sideEffect) {
+      if ('counter' in sideEffect) {
         max = Math.max(max, sideEffect.counter);
       } else {
         throw new Error('Unknown side effect type');
@@ -593,10 +516,6 @@ export abstract class AbstractPhaseManager {
   protected async getPublicCallData(result: PublicExecutionResult, isExecutionRequest = false) {
     const bytecodeHash = await this.getBytecodeHash(result);
     const callStackItem = await this.getPublicCallStackItem(result, isExecutionRequest);
-    const publicCallRequests = (await this.getPublicCallStackPreimages(result)).map(c =>
-      c.toCallRequest(callStackItem.publicInputs.callContext),
-    );
-    const publicCallStack = padArrayEnd(publicCallRequests, CallRequest.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL);
-    return new PublicCallData(callStackItem, publicCallStack, makeEmptyProof(), bytecodeHash);
+    return new PublicCallData(callStackItem, makeEmptyProof(), bytecodeHash);
   }
 }

package/src/public/execution.ts

@@ -1,18 +1,26 @@
-import { type SimulationError, type UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
+import {
+  type PublicExecutionRequest,
+  type SimulationError,
+  type UnencryptedFunctionL2Logs,
+} from '@aztec/circuit-types';
 import {
   type AvmExecutionHints,
   type ContractStorageRead,
   type ContractStorageUpdateRequest,
   type Fr,
+  Gas,
   type L2ToL1Message,
   type LogHash,
   type NoteHash,
   type Nullifier,
-  type PublicCallRequest,
+  PublicCallRequest,
+  PublicCallStackItemCompressed,
   type ReadRequest,
+  RevertCode,
 } from '@aztec/circuits.js';
+import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 
-import { type Gas } from '../avm/avm_gas.js';
+import { type Gas as AvmGas } from '../avm/avm_gas.js';
 
 /**
  * The public function execution result.
@@ -26,9 +34,9 @@ export interface PublicExecutionResult {
   /** The side effect counter after executing this function call */
   endSideEffectCounter: Fr;
   /** How much gas was available for this public execution. */
-  startGasLeft: Gas;
+  startGasLeft: AvmGas;
   /** How much gas was left after this public execution. */
-  endGasLeft: Gas;
+  endGasLeft: AvmGas;
   /** Transaction fee set for this tx. */
   transactionFee: Fr;
 
@@ -79,6 +87,8 @@ export interface PublicExecutionResult {
 
   // TODO(dbanks12): add contract instance read requests
 
+  /** The requests to call public functions made by this call. */
+  publicCallRequests: PublicCallRequest[];
   /** The results of nested calls. */
   nestedExecutions: this[];
 
@@ -89,15 +99,6 @@ export interface PublicExecutionResult {
   functionName: string;
 }
 
-/**
- * The execution request of a public function.
- * A subset of PublicCallRequest
- */
-export type PublicExecutionRequest = Pick<
-  PublicCallRequest,
-  'contractAddress' | 'functionSelector' | 'callContext' | 'args'
->;
-
 /**
  * Returns if the input is a public execution result and not just a public execution.
  * @param input - Public execution or public execution result.
@@ -131,3 +132,18 @@ export function checkValidStaticCall(
     throw new Error('Static call cannot update the state, emit L2->L1 messages or generate logs');
   }
 }
+
+export function resultToPublicCallRequest(result: PublicExecutionResult) {
+  const request = result.executionRequest;
+  const item = new PublicCallStackItemCompressed(
+    request.contractAddress,
+    request.callContext,
+    computeVarArgsHash(request.args),
+    computeVarArgsHash(result.returnValues),
+    // TODO(@just-mitch): need better mapping from simulator to revert code.
+    result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
+    Gas.from(result.startGasLeft),
+    Gas.from(result.endGasLeft),
+  );
+  return new PublicCallRequest(item, result.startSideEffectCounter.toNumber());
+}

package/src/public/executor.ts

@@ -1,7 +1,9 @@
+import { type PublicExecutionRequest } from '@aztec/circuit-types';
 import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
 import { Fr, Gas, type GlobalVariables, type Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import { AvmContext } from '../avm/avm_context.js';
 import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
@@ -10,19 +12,25 @@ import { AvmSimulator } from '../avm/avm_simulator.js';
 import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db_interfaces.js';
-import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
+import { type PublicExecutionResult } from './execution.js';
+import { ExecutorMetrics } from './executor_metrics.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
 
 /**
  * Handles execution of public functions.
  */
 export class PublicExecutor {
+  metrics: ExecutorMetrics;
+
   constructor(
     private readonly publicStorageDB: PublicStateDB,
     private readonly contractsDb: PublicContractsDB,
     private readonly commitmentsDb: CommitmentsDB,
     private readonly header: Header,
-  ) {}
+    client: TelemetryClient,
+  ) {
+    this.metrics = new ExecutorMetrics(client, 'PublicExecutor');
+  }
 
   static readonly log = createDebugLogger('aztec:simulator:public_executor');
 
@@ -47,7 +55,7 @@ export class PublicExecutor {
     startSideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
     const address = executionRequest.contractAddress;
-    const selector = executionRequest.functionSelector;
+    const selector = executionRequest.callContext.functionSelector;
     const fnName = (await this.contractsDb.getDebugFunctionName(address, selector)) ?? `${address}:${selector}`;
 
     PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}.`);
@@ -101,6 +109,12 @@ export class PublicExecutor {
       fnName,
     );
 
+    if (publicExecutionResult.reverted) {
+      this.metrics.recordFunctionSimulationFailure();
+    } else {
+      this.metrics.recordFunctionSimulation(bytecode.length, timer.ms());
+    }
+
     return publicExecutionResult;
   }
 }
@@ -122,7 +136,7 @@ function createAvmExecutionEnvironment(
     executionRequest.contractAddress,
     executionRequest.callContext.storageContractAddress,
     executionRequest.callContext.msgSender,
-    executionRequest.functionSelector,
+    executionRequest.callContext.functionSelector,
     /*contractCallDepth=*/ Fr.zero(),
     transactionFee,
     header,

package/src/public/executor_metrics.ts

@@ -0,0 +1,48 @@
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export class ExecutorMetrics {
+  private fnCount: UpDownCounter;
+  private fnDuration: Histogram;
+  private bytecodeSize: Histogram;
+
+  constructor(client: TelemetryClient, name = 'PublicExecutor') {
+    const meter = client.getMeter(name);
+
+    this.fnCount = meter.createUpDownCounter(Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT, {
+      description: 'Number of functions executed',
+    });
+
+    this.fnDuration = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_DURATION, {
+      description: 'How long it takes to execute a function',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.bytecodeSize = meter.createHistogram(Metrics.PUBLIC_EXECUTION_SIMULATION_BYTECODE_SIZE, {
+      description: 'Size of the function bytecode',
+      unit: 'By',
+      valueType: ValueType.INT,
+    });
+  }
+
+  recordFunctionSimulation(bytecodeSize: number, durationMs: number) {
+    this.fnCount.add(1, {
+      [Attributes.OK]: true,
+    });
+    this.bytecodeSize.record(bytecodeSize);
+    this.fnDuration.record(Math.ceil(durationMs));
+  }
+
+  recordFunctionSimulationFailure() {
+    this.fnCount.add(1, {
+      [Attributes.OK]: false,
+    });
+  }
+}

package/src/public/fee_payment.ts

@@ -1,26 +1,24 @@
-import { GAS_TOKEN_ADDRESS } from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
+import { FEE_JUICE_ADDRESS } from '@aztec/circuits.js';
+import { computePublicDataTreeLeafSlot, deriveStorageSlotInMap } from '@aztec/circuits.js/hash';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { GasTokenArtifact } from '@aztec/protocol-contracts/gas-token';
-
-import { computeSlotForMapping } from '../utils.js';
+import { FeeJuiceArtifact } from '@aztec/protocol-contracts/fee-juice';
 
 /**
- * Computes the storage slot within the gas token contract for the balance of the fee payer.
+ * Computes the storage slot within the Fee Juice contract for the balance of the fee payer.
  */
 export function computeFeePayerBalanceStorageSlot(feePayer: AztecAddress) {
-  return computeSlotForMapping(GasTokenArtifact.storageLayout.balances.slot, feePayer);
+  return deriveStorageSlotInMap(FeeJuiceArtifact.storageLayout.balances.slot, feePayer);
 }
 
 /**
- * Computes the leaf slot in the public data tree for the balance of the fee payer in the gas token.
+ * Computes the leaf slot in the public data tree for the balance of the fee payer in the Fee Juice.
  */
 export function computeFeePayerBalanceLeafSlot(feePayer: AztecAddress): Fr {
   if (feePayer.isZero()) {
     return Fr.ZERO;
   }
-  const gasToken = AztecAddress.fromBigInt(GAS_TOKEN_ADDRESS);
+  const feeJuice = AztecAddress.fromBigInt(FEE_JUICE_ADDRESS);
   const balanceSlot = computeFeePayerBalanceStorageSlot(feePayer);
-  return computePublicDataTreeLeafSlot(gasToken, balanceSlot);
+  return computePublicDataTreeLeafSlot(feeJuice, balanceSlot);
 }

package/src/public/hints_builder.ts

@@ -1,4 +1,4 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
+import { type IndexedTreeId, MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
   type MAX_NULLIFIERS_PER_TX,
@@ -23,7 +23,7 @@ import {
   buildSiloedNullifierReadRequestHints,
 } from '@aztec/circuits.js';
 import { type Tuple } from '@aztec/foundation/serialize';
-import { type IndexedTreeId, type MerkleTreeOperations } from '@aztec/world-state';
+import { type MerkleTreeOperations } from '@aztec/world-state';
 
 export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}

package/src/public/index.ts

@@ -1,6 +1,6 @@
 export * from './abstract_phase_manager.js';
 export * from './db_interfaces.js';
-export { isPublicExecutionResult, type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
+export { isPublicExecutionResult, type PublicExecutionResult } from './execution.js';
 export { PublicExecutor } from './executor.js';
 export * from './fee_payment.js';
 export { HintsBuilder } from './hints_builder.js';

package/src/public/public_processor.ts

@@ -13,7 +13,8 @@ import {
 } from '@aztec/circuit-types';
 import {
   AztecAddress,
-  GAS_TOKEN_ADDRESS,
+  ContractClassRegisteredEvent,
+  FEE_JUICE_ADDRESS,
   type GlobalVariables,
   type Header,
   type KernelCircuitPublicInputs,
@@ -23,7 +24,9 @@ import {
 } from '@aztec/circuits.js';
 import { times } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
 import {
   PublicExecutor,
   type PublicStateDB,
@@ -40,6 +43,7 @@ import { PhaseManagerFactory } from './phase_manager_factory.js';
 import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from './public_db_sources.js';
 import { RealPublicKernelCircuitSimulator } from './public_kernel.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+import { PublicProcessorMetrics } from './public_processor_metrics.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
@@ -56,18 +60,24 @@ export class PublicProcessorFactory {
    * Creates a new instance of a PublicProcessor.
    * @param historicalHeader - The header of a block previous to the one in which the tx is included.
    * @param globalVariables - The global variables for the block being processed.
-   * @param newContracts - Provides access to contract bytecode for public executions.
    * @returns A new instance of a PublicProcessor.
    */
-  public create(historicalHeader: Header | undefined, globalVariables: GlobalVariables): PublicProcessor {
-    historicalHeader = historicalHeader ?? this.merkleTree.getInitialHeader();
-
+  public create(maybeHistoricalHeader: Header | undefined, globalVariables: GlobalVariables): PublicProcessor {
+    const { merkleTree, telemetryClient } = this;
+    const historicalHeader = maybeHistoricalHeader ?? merkleTree.getInitialHeader();
     const publicContractsDB = new ContractsDataSourcePublicDB(this.contractDataSource);
-    const worldStatePublicDB = new WorldStatePublicDB(this.merkleTree);
-    const worldStateDB = new WorldStateDB(this.merkleTree);
-    const publicExecutor = new PublicExecutor(worldStatePublicDB, publicContractsDB, worldStateDB, historicalHeader);
+
+    const worldStatePublicDB = new WorldStatePublicDB(merkleTree);
+    const worldStateDB = new WorldStateDB(merkleTree);
+    const publicExecutor = new PublicExecutor(
+      worldStatePublicDB,
+      publicContractsDB,
+      worldStateDB,
+      historicalHeader,
+      telemetryClient,
+    );
     return new PublicProcessor(
-      this.merkleTree,
+      merkleTree,
       publicExecutor,
       new RealPublicKernelCircuitSimulator(this.simulator),
       globalVariables,
@@ -84,7 +94,7 @@ export class PublicProcessorFactory {
  * any public function calls in them. Txs with private calls only are unaffected.
  */
 export class PublicProcessor {
-  public readonly tracer: Tracer;
+  private metrics: PublicProcessorMetrics;
   constructor(
     protected db: MerkleTreeOperations,
     protected publicExecutor: PublicExecutor,
@@ -96,7 +106,11 @@ export class PublicProcessor {
     telemetryClient: TelemetryClient,
     private log = createDebugLogger('aztec:sequencer:public-processor'),
   ) {
-    this.tracer = telemetryClient.getTracer('PublicProcessor');
+    this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
+  }
+
+  get tracer(): Tracer {
+    return this.metrics.tracer;
   }
 
   /**
@@ -188,12 +202,12 @@ export class PublicProcessor {
       return finalPublicDataUpdateRequests;
     }
 
-    const gasToken = AztecAddress.fromBigInt(GAS_TOKEN_ADDRESS);
+    const feeJuiceAddress = AztecAddress.fromBigInt(FEE_JUICE_ADDRESS);
     const balanceSlot = computeFeePayerBalanceStorageSlot(feePayer);
     const leafSlot = computeFeePayerBalanceLeafSlot(feePayer);
     const txFee = tx.data.getTransactionFee(this.globalVariables.gasFees);
 
-    this.log.debug(`Deducting ${txFee} balance in gas tokens for ${feePayer}`);
+    this.log.debug(`Deducting ${txFee} balance in Fee Juice for ${feePayer}`);
 
     const existingBalanceWriteIndex = finalPublicDataUpdateRequests.findIndex(request =>
       request.leafSlot.equals(leafSlot),
@@ -202,14 +216,14 @@ export class PublicProcessor {
     const balance =
       existingBalanceWriteIndex > -1
         ? finalPublicDataUpdateRequests[existingBalanceWriteIndex].newValue
-        : await this.publicStateDB.storageRead(gasToken, balanceSlot);
+        : await this.publicStateDB.storageRead(feeJuiceAddress, balanceSlot);
 
     if (balance.lt(txFee)) {
       throw new Error(`Not enough balance for fee payer to pay for transaction (got ${balance} needs ${txFee})`);
     }
 
     const updatedBalance = balance.sub(txFee);
-    await this.publicStateDB.storageWrite(gasToken, balanceSlot, updatedBalance);
+    await this.publicStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
 
     finalPublicDataUpdateRequests[
       existingBalanceWriteIndex > -1 ? existingBalanceWriteIndex : MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
@@ -222,6 +236,7 @@ export class PublicProcessor {
     [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+    const timer = new Timer();
     let returnValues: NestedProcessReturnValues[] = [];
     const publicProvingRequests: PublicProvingRequest[] = [];
     let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
@@ -240,8 +255,18 @@ export class PublicProcessor {
     let finalKernelOutput: KernelCircuitPublicInputs | undefined;
     let revertReason: SimulationError | undefined;
     const gasUsed: ProcessedTx['gasUsed'] = {};
+    let phaseCount = 0;
     while (phase) {
+      phaseCount++;
+      const phaseTimer = new Timer();
       const output = await phase.handle(tx, publicKernelPublicInput, lastKernelArtifact);
+
+      if (output.revertReason) {
+        this.metrics.recordRevertedPhase(phase.phase);
+      } else {
+        this.metrics.recordPhaseDuration(phase.phase, phaseTimer.ms());
+      }
+
       gasUsed[phase.phase] = output.gasUsed;
       if (phase.phase === PublicKernelType.APP_LOGIC) {
         returnValues = output.returnValues;
@@ -265,9 +290,15 @@ export class PublicProcessor {
     }
 
     if (!finalKernelOutput) {
+      this.metrics.recordFailedTx();
       throw new Error('Final public kernel was not executed.');
     }
 
+    this.metrics.recordClassRegistration(
+      ...ContractClassRegisteredEvent.fromLogs(tx.unencryptedLogs.unrollLogs(), ClassRegistererAddress),
+    );
+
+    this.metrics.recordTx(phaseCount, timer.ms());
     const processedTx = makeProcessedTx(tx, finalKernelOutput, publicProvingRequests, revertReason, gasUsed);
     return [processedTx, returnValues];
   }