@aztec/simulator 0.47.0 → 0.48.0

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/src/public/side_effect_trace.ts

@@ -1,4 +1,4 @@
-import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import { PublicExecutionRequest, UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
 import {
   AvmContractInstanceHint,
   AvmExecutionHints,
@@ -14,6 +14,7 @@ import {
   LogHash,
   NoteHash,
   Nullifier,
+  type PublicCallRequest,
   ReadRequest,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
@@ -23,7 +24,7 @@ import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import { createSimulationError } from '../common/errors.js';
-import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
+import { type PublicExecutionResult, resultToPublicCallRequest } from './execution.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
 export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
@@ -51,6 +52,8 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   private allUnencryptedLogs: UnencryptedL2Log[] = [];
   private unencryptedLogsHashes: LogHash[] = [];
 
+  private publicCallRequests: PublicCallRequest[] = [];
+
   private gotContractInstances: ContractInstanceWithAddress[] = [];
 
   private nestedExecutions: PublicExecutionResult[] = [];
@@ -247,6 +250,9 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       result.startGasLeft.daGas - result.endGasLeft.daGas,
       result.startGasLeft.l2Gas - result.endGasLeft.l2Gas,
     );
+
+    this.publicCallRequests.push(resultToPublicCallRequest(result));
+
     this.avmCircuitHints.externalCalls.items.push(
       new AvmExternalCallHint(
         /*success=*/ new Fr(result.reverted ? 0 : 1),
@@ -305,6 +311,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       // TODO(dbanks12): process contract instance read requests in public kernel
       //gotContractInstances: this.gotContractInstances,
 
+      publicCallRequests: this.publicCallRequests,
       nestedExecutions: this.nestedExecutions,
 
       avmCircuitHints: this.avmCircuitHints,
@@ -325,11 +332,10 @@ function createPublicExecutionRequest(avmEnvironment: AvmExecutionEnvironment):
     isDelegateCall: avmEnvironment.isDelegateCall,
     isStaticCall: avmEnvironment.isStaticCall,
   });
-  return {
-    contractAddress: avmEnvironment.address,
-    functionSelector: avmEnvironment.functionSelector,
+  return new PublicExecutionRequest(
+    avmEnvironment.address,
     callContext,
     // execution request does not contain AvmContextInputs prefix
-    args: avmEnvironment.getCalldataWithoutPrefix(),
-  };
+    avmEnvironment.getCalldataWithoutPrefix(),
+  );
 }

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()]);
-}