@aztec/simulator 0.47.1 → 0.48.0

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/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];
   }

package/src/public/public_processor_metrics.ts

@@ -0,0 +1,90 @@
+import { type PublicKernelType } from '@aztec/circuit-types';
+import { type ContractClassRegisteredEvent } from '@aztec/circuits.js';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export class PublicProcessorMetrics {
+  public readonly tracer: Tracer;
+
+  private txDuration: Histogram;
+  private txCount: UpDownCounter;
+  private txPhaseCount: UpDownCounter;
+
+  private phaseDuration: Histogram;
+  private phaseCount: UpDownCounter;
+
+  private bytecodeDeployed: Histogram;
+
+  constructor(client: TelemetryClient, name = 'PublicProcessor') {
+    this.tracer = client.getTracer(name);
+    const meter = client.getMeter(name);
+
+    this.txDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_DURATION, {
+      description: 'How long it takes to process a transaction',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.txCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_COUNT, {
+      description: 'Number of transactions processed',
+    });
+
+    this.txPhaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT, {
+      description: 'Number of phases processed',
+    });
+
+    this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION, {
+      description: 'How long it takes to process a phase',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.phaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_PHASE_COUNT, {
+      description: 'Number of failed phases',
+    });
+
+    this.bytecodeDeployed = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE, {
+      description: 'Size of deployed bytecode',
+      unit: 'By',
+    });
+  }
+
+  recordPhaseDuration(phaseName: PublicKernelType, durationMs: number) {
+    this.phaseCount.add(1, { [Attributes.TX_PHASE_NAME]: phaseName, [Attributes.OK]: true });
+    this.phaseDuration.record(Math.ceil(durationMs), { [Attributes.TX_PHASE_NAME]: phaseName });
+  }
+
+  recordTx(phaseCount: number, durationMs: number) {
+    this.txPhaseCount.add(phaseCount);
+    this.txDuration.record(Math.ceil(durationMs));
+    this.txCount.add(1, {
+      [Attributes.OK]: true,
+    });
+  }
+
+  recordFailedTx() {
+    this.txCount.add(1, {
+      [Attributes.OK]: false,
+    });
+  }
+
+  recordRevertedPhase(phaseName: PublicKernelType) {
+    this.phaseCount.add(1, { [Attributes.TX_PHASE_NAME]: phaseName, [Attributes.OK]: false });
+  }
+
+  recordClassRegistration(...events: ContractClassRegisteredEvent[]) {
+    let totalBytecode = 0;
+    for (const event of events) {
+      totalBytecode += event.packedPublicBytecode.length;
+    }
+
+    this.bytecodeDeployed.record(totalBytecode);
+  }
+}

package/dest/utils.d.ts

@@ -1,12 +0,0 @@
-import { type Fr } from '@aztec/foundation/fields';
-/**
- * Computes the resulting storage slot for an entry in a mapping.
- * @param mappingSlot - The slot of the mapping within state.
- * @param key - The key of the mapping.
- * @returns The slot in the contract storage where the value is stored.
- */
-export declare function computeSlotForMapping(mappingSlot: Fr, key: {
-    /** Serialize to a field. */
-    toField: () => Fr;
-}): Fr;
-//# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,EAAE,EACf,GAAG,EAAE;IACH,4BAA4B;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,MAGF"}

package/dest/utils.js

@@ -1,11 +0,0 @@
-import { pedersenHash } from '@aztec/foundation/crypto';
-/**
- * Computes the resulting storage slot for an entry in a mapping.
- * @param mappingSlot - The slot of the mapping within state.
- * @param key - The key of the mapping.
- * @returns The slot in the contract storage where the value is stored.
- */
-export function computeSlotForMapping(mappingSlot, key) {
-    return pedersenHash([mappingSlot, key.toField()]);
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBR3hEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQixDQUNuQyxXQUFlLEVBQ2YsR0FHQztJQUVELE9BQU8sWUFBWSxDQUFDLENBQUMsV0FBVyxFQUFFLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDcEQsQ0FBQyJ9

package/src/utils.ts

@@ -1,18 +0,0 @@
-import { pedersenHash } from '@aztec/foundation/crypto';
-import { type Fr } from '@aztec/foundation/fields';
-
-/**
- * Computes the resulting storage slot for an entry in a mapping.
- * @param mappingSlot - The slot of the mapping within state.
- * @param key - The key of the mapping.
- * @returns The slot in the contract storage where the value is stored.
- */
-export function computeSlotForMapping(
-  mappingSlot: Fr,
-  key: {
-    /** Serialize to a field. */
-    toField: () => Fr;
-  },
-) {
-  return pedersenHash([mappingSlot, key.toField()]);
-}