@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/public/public_tx_simulator/public_tx_simulator_interface.ts

@@ -0,0 +1,33 @@
+import type { PublicTxResult } from '@aztec/stdlib/avm';
+import type { Tx } from '@aztec/stdlib/tx';
+
+export interface PublicTxSimulatorInterface {
+  simulate(tx: Tx): Promise<PublicTxResult>;
+  /**
+   * Cancel the current simulation if one is in progress.
+   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * Safe to call even if no simulation is in progress.
+   * Optional - not all implementations support cancellation.
+   *
+   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+   *                        This is important because signaling cancellation doesn't immediately stop C++ -
+   *                        it only sets a flag that C++ checks at certain points. If C++ is in the middle
+   *                        of a slow operation (e.g., pad_trees), it won't stop until that completes.
+   * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+   */
+  cancel?(waitTimeoutMs?: number): Promise<void>;
+}
+
+export interface MeasuredPublicTxSimulatorInterface {
+  simulate(tx: Tx, txLabel: string): Promise<PublicTxResult>;
+  /**
+   * Cancel the current simulation if one is in progress.
+   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * Safe to call even if no simulation is in progress.
+   * Optional - not all implementations support cancellation.
+   *
+   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+   * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+   */
+  cancel?(waitTimeoutMs?: number): Promise<void>;
+}

package/src/public/public_tx_simulator/telemetry_public_tx_simulator.ts

@@ -0,0 +1,63 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+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 { ExecutorMetrics } from '../executor_metrics.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.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(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
+    config?: Partial<PublicSimulatorConfig>,
+  ) {
+    const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
+    super(merkleTree, contractsDB, globalVariables, metrics, config);
+    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: PublicPersistableStateManager,
+    callRequest: PublicCallRequestWithCalldata,
+    allocatedGas: Gas,
+    transactionFee: Fr,
+    fnName: string,
+  ): Promise<AvmFinalizedCallResult> {
+    return await super.simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName);
+  }
+}

package/src/public/side_effect_errors.ts

@@ -1,6 +1,96 @@
-export class SideEffectLimitReachedError extends Error {
+import {
+  L1_TO_L2_MSG_TREE_LEAF_COUNT,
+  MAX_L2_TO_L1_MSGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+  NOTE_HASH_TREE_LEAF_COUNT,
+} from '@aztec/constants';
+
+import { CheckedPublicExecutionError } from './public_errors.js';
+
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */
+export abstract class SideEffectError extends CheckedPublicExecutionError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SideEffectInsertionError';
+  }
+}
+
+export class SideEffectLimitReachedError extends SideEffectError {
   constructor(sideEffectType: string, limit: number) {
     super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
     this.name = 'SideEffectLimitReachedError';
   }
 }
+
+export class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+  constructor() {
+    super('contract calls to unique class IDs', MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS);
+    this.name = 'MaxCallsToUniqueContractClassIdsError';
+  }
+}
+
+export class NullifierLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('nullifier', MAX_NULLIFIERS_PER_TX);
+    this.name = 'NullifierLimitReachedError';
+  }
+}
+
+export class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('note hash', MAX_NOTE_HASHES_PER_TX);
+    this.name = 'NoteHashLimitReachedError';
+  }
+}
+
+export class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+    this.name = 'L2ToL1MessageLimitReachedError';
+  }
+}
+
+export class NullifierCollisionError extends SideEffectError {
+  constructor(message: string) {
+    super(`Nullifier collision: ${message}`);
+    this.name = 'NullifierCollisionError';
+  }
+}
+
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */
+export abstract class SideEffectReadError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SideEffectReadError';
+  }
+}
+
+export class IndexOutOfRangeError extends SideEffectReadError {
+  constructor(tree: string, index: number, limit: number) {
+    super(`Attempting to read index ${index} of ${tree} tree with maximum ${limit} leaves`);
+    this.name = 'IndexOutOfRangeError';
+  }
+}
+
+export class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+  constructor(index: number) {
+    super('note hash', index, NOTE_HASH_TREE_LEAF_COUNT);
+    this.name = 'NoteHashIndexOutOfRangeError';
+  }
+}
+
+export class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+  constructor(index: number) {
+    super('l1 to l2 message', index, L1_TO_L2_MSG_TREE_LEAF_COUNT);
+    this.name = 'L1ToL2MessageIndexOutOfRangeError';
+  }
+}