@aztec/simulator 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/public/public_tx_simulator/factories.ts

@@ -0,0 +1,43 @@
+import type { LoggerBindings } from '@aztec/foundation/log';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { TelemetryCppPublicTxSimulator } from './cpp_public_tx_simulator.js';
+import { DumpingCppPublicTxSimulator } from './dumping_cpp_public_tx_simulator.js';
+
+/**
+ * Creates a public tx simulator for block building.
+ * Uses DumpingCppPublicTxSimulator if DUMP_AVM_INPUTS_TO_DIR env var is set (for CI/testing avm circuit),
+ * otherwise uses TelemetryCppPublicTxSimulator (for production).
+ */
+export function createPublicTxSimulatorForBlockBuilding(
+  merkleTree: MerkleTreeWriteOperations,
+  contractsDB: PublicContractsDB,
+  globalVariables: GlobalVariables,
+  telemetryClient: TelemetryClient,
+  bindings?: LoggerBindings,
+) {
+  const config = PublicSimulatorConfig.from({
+    skipFeeEnforcement: false,
+    collectDebugLogs: false,
+    collectHints: false,
+    collectPublicInputs: false,
+    collectStatistics: false,
+    collectCallMetadata: false,
+  });
+
+  const dumpDir = process.env.DUMP_AVM_INPUTS_TO_DIR;
+  if (dumpDir) {
+    // must collect hints and PIs for dumping
+    const dumpingConfig = {
+      ...config,
+      collectHints: true,
+      collectPublicInputs: true,
+    };
+    return new DumpingCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, dumpingConfig, dumpDir, bindings);
+  }
+  return new TelemetryCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, telemetryClient, config, bindings);
+}

package/src/public/public_tx_simulator/index.ts

@@ -1,2 +1,7 @@
 export * from './public_tx_simulator.js';
+export { CppPublicTxSimulator, TelemetryCppPublicTxSimulator } from './cpp_public_tx_simulator.js';
+export { DumpingCppPublicTxSimulator } from './dumping_cpp_public_tx_simulator.js';
+export { createPublicTxSimulatorForBlockBuilding } from './factories.js';
+export type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 export { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';
+export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -1,5 +1,6 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { Timer } from '@aztec/foundation/timer';
+import type { PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
 import type { Gas } from '@aztec/stdlib/gas';
 import type { AvmSimulationStats } from '@aztec/stdlib/stats';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
@@ -10,22 +11,21 @@ import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js'
 import type { PublicContractsDB } from '../public_db_sources.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { PublicTxContext } from './public_tx_context.js';
-import { type ProcessedPhase, type PublicTxResult, PublicTxSimulator } from './public_tx_simulator.js';
+import { PublicTxSimulator } from './public_tx_simulator.js';
+import type { MeasuredPublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 
 /**
  * A public tx simulator that tracks miscellaneous simulation metrics without telemetry.
  */
-export class MeasuredPublicTxSimulator extends PublicTxSimulator {
+export class MeasuredPublicTxSimulator extends PublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
   constructor(
     merkleTree: MerkleTreeWriteOperations,
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
-    doMerkleOperations: boolean = false,
-    skipFeeEnforcement: boolean = false,
-    clientInitiatedSimulation: boolean = false,
     protected readonly metrics: ExecutorMetricsInterface,
+    config?: Partial<PublicSimulatorConfig>,
   ) {
-    super(merkleTree, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement, clientInitiatedSimulation);
+    super(merkleTree, contractsDB, globalVariables, config);
   }
 
   public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
@@ -34,25 +34,24 @@ export class MeasuredPublicTxSimulator extends PublicTxSimulator {
     try {
       avmResult = await super.simulate(tx);
     } finally {
-      this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.revertCode);
+      this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.gasUsed, avmResult?.revertCode);
     }
     return avmResult;
   }
 
-  protected override async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
+  protected override async insertNonRevertiblesFromPrivate(context: PublicTxContext) {
     const timer = new Timer();
-    await super.insertNonRevertiblesFromPrivate(context, tx);
+    await super.insertNonRevertiblesFromPrivate(context);
     this.metrics.recordPrivateEffectsInsertion(timer.us(), 'non-revertible');
   }
 
-  protected override async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<boolean> {
+  protected override async insertRevertiblesFromPrivate(context: PublicTxContext) {
     const timer = new Timer();
-    const result = await super.insertRevertiblesFromPrivate(context, tx);
+    await super.insertRevertiblesFromPrivate(context);
     this.metrics.recordPrivateEffectsInsertion(timer.us(), 'revertible');
-    return result;
   }
 
-  protected override async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
+  protected override async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext) {
     const timer = new Timer();
     const result = await super.simulatePhase(phase, context);
     result.durationMs = timer.ms();

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -3,12 +3,11 @@ import {
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   AvmAccumulatedData,
   AvmAccumulatedDataArrayLengths,
@@ -17,6 +16,7 @@ import {
   RevertCode,
 } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { AllContractDeploymentData, type ContractDeploymentData } from '@aztec/stdlib/contract';
 import type { SimulationError } from '@aztec/stdlib/errors';
 import { computeEffectiveGasFees, computeTransactionFee } from '@aztec/stdlib/fees';
 import { Gas, GasSettings } from '@aztec/stdlib/gas';
@@ -28,11 +28,12 @@ import {
   PublicCallRequestArrayLengths,
   countAccumulatedItems,
 } from '@aztec/stdlib/kernel';
-import { PublicLog } from '@aztec/stdlib/logs';
+import { FlatPublicLogs } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
+  ProtocolContracts,
   PublicCallRequestWithCalldata,
   TreeSnapshots,
   type Tx,
@@ -71,6 +72,8 @@ export class PublicTxContext {
     public readonly state: PhaseStateManager,
     private readonly startTreeSnapshots: TreeSnapshots,
     private readonly globalVariables: GlobalVariables,
+    private readonly protocolContracts: ProtocolContracts,
+    private readonly proverId: Fr,
     private readonly gasSettings: GasSettings,
     private readonly gasUsedByPrivate: Gas,
     private readonly gasAllocatedToPublic: Gas,
@@ -78,12 +81,15 @@ export class PublicTxContext {
     private readonly setupCallRequests: PublicCallRequestWithCalldata[],
     private readonly appLogicCallRequests: PublicCallRequestWithCalldata[],
     private readonly teardownCallRequests: PublicCallRequestWithCalldata[],
+    public readonly nonRevertibleContractDeploymentData: ContractDeploymentData,
+    public readonly revertibleContractDeploymentData: ContractDeploymentData,
     public readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly feePayer: AztecAddress,
     private readonly trace: SideEffectTrace,
+    bindings?: LoggerBindings,
   ) {
-    this.log = createLogger(`simulator:public_tx_context`);
+    this.log = createLogger(`simulator:public_tx_context`, bindings);
   }
 
   public static async create(
@@ -91,11 +97,16 @@ export class PublicTxContext {
     contractsDB: PublicContractsDBInterface,
     tx: Tx,
     globalVariables: GlobalVariables,
-    doMerkleOperations: boolean,
+    protocolContracts: ProtocolContracts,
+    proverId: Fr,
+    bindings?: LoggerBindings,
   ) {
+    const contractDeploymentData = AllContractDeploymentData.fromTx(tx);
+    const nonRevertibleContractDeploymentData = contractDeploymentData.getNonRevertibleContractDeploymentData();
+    const revertibleContractDeploymentData = contractDeploymentData.getRevertibleContractDeploymentData();
     const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
 
-    const trace = new SideEffectTrace();
+    const trace = new SideEffectTrace(0, bindings);
 
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
@@ -104,9 +115,9 @@ export class PublicTxContext {
       treesDB,
       contractsDB,
       trace,
-      doMerkleOperations,
       firstNullifier,
       globalVariables.timestamp,
+      bindings,
     );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
@@ -116,9 +127,11 @@ export class PublicTxContext {
 
     return new PublicTxContext(
       tx.getTxHash(),
-      new PhaseStateManager(txStateManager),
+      new PhaseStateManager(txStateManager, bindings),
       await txStateManager.getTreeSnapshots(),
       globalVariables,
+      protocolContracts,
+      proverId,
       gasSettings,
       gasUsedByPrivate,
       gasAllocatedToPublic,
@@ -126,10 +139,13 @@ export class PublicTxContext {
       getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP),
       getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.APP_LOGIC),
       getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.TEARDOWN),
+      nonRevertibleContractDeploymentData,
+      revertibleContractDeploymentData,
       tx.data.forPublic!.nonRevertibleAccumulatedData,
       tx.data.forPublic!.revertibleAccumulatedData,
       tx.data.feePayer,
       trace,
+      bindings,
     );
   }
 
@@ -331,7 +347,6 @@ export class PublicTxContext {
       avmNoteHashes.length,
       avmNullifiers.length,
       avmL2ToL1Msgs.length,
-      finalPublicLogs.length,
       finalPublicDataWrites.length,
     );
 
@@ -347,7 +362,7 @@ export class PublicTxContext {
         MAX_NULLIFIERS_PER_TX,
       ),
       /*l2ToL1Msgs=*/ padArrayEnd(avmL2ToL1Msgs, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
-      /*publicLogs=*/ padArrayEnd(finalPublicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_TX),
+      /*publicLogs=*/ FlatPublicLogs.fromLogs(finalPublicLogs),
       /*publicDataWrites=*/ padArrayEnd(
         finalPublicDataWrites,
         PublicDataWrite.empty(),
@@ -376,11 +391,13 @@ export class PublicTxContext {
 
     return new AvmCircuitPublicInputs(
       this.globalVariables,
+      this.protocolContracts,
       this.startTreeSnapshots,
       /*startGasUsed=*/ this.gasUsedByPrivate,
       this.gasSettings,
       computeEffectiveGasFees(this.globalVariables.gasFees, this.gasSettings),
       this.feePayer,
+      this.proverId,
       /*publicCallRequestArrayLengths=*/ new PublicCallRequestArrayLengths(
         this.setupCallRequests.length,
         this.appLogicCallRequests.length,
@@ -428,8 +445,11 @@ class PhaseStateManager {
 
   private currentlyActiveStateManager: PublicPersistableStateManager | undefined;
 
-  constructor(private readonly txStateManager: PublicPersistableStateManager) {
-    this.log = createLogger(`simulator:public_phase_state_manager`);
+  constructor(
+    private readonly txStateManager: PublicPersistableStateManager,
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger(`simulator:public_phase_state_manager`, bindings);
   }
 
   async fork() {