@aztec/simulator 0.0.1-commit.0b941701 → 0.0.1-commit.0dc957cde

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -7,7 +7,7 @@ import {
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   AvmAccumulatedData,
   AvmAccumulatedDataArrayLengths,
@@ -87,8 +87,9 @@ export class PublicTxContext {
     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(
@@ -98,13 +99,14 @@ export class PublicTxContext {
     globalVariables: GlobalVariables,
     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];
 
@@ -115,6 +117,7 @@ export class PublicTxContext {
       trace,
       firstNullifier,
       globalVariables.timestamp,
+      bindings,
     );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
@@ -124,7 +127,7 @@ export class PublicTxContext {
 
     return new PublicTxContext(
       tx.getTxHash(),
-      new PhaseStateManager(txStateManager),
+      new PhaseStateManager(txStateManager, bindings),
       await txStateManager.getTreeSnapshots(),
       globalVariables,
       protocolContracts,
@@ -142,6 +145,7 @@ export class PublicTxContext {
       tx.data.forPublic!.revertibleAccumulatedData,
       tx.data.feePayer,
       trace,
+      bindings,
     );
   }
 
@@ -170,14 +174,8 @@ export class PublicTxContext {
     }
     if (phase === TxExecutionPhase.SETUP) {
       this.log.warn(`Setup phase reverted! The transaction will be thrown out.`);
-    } else if (phase === TxExecutionPhase.APP_LOGIC) {
-      this.revertCode = RevertCode.APP_LOGIC_REVERTED;
-    } else if (phase === TxExecutionPhase.TEARDOWN) {
-      if (this.revertCode.equals(RevertCode.APP_LOGIC_REVERTED)) {
-        this.revertCode = RevertCode.BOTH_REVERTED;
-      } else {
-        this.revertCode = RevertCode.TEARDOWN_REVERTED;
-      }
+    } else if (phase === TxExecutionPhase.APP_LOGIC || phase === TxExecutionPhase.TEARDOWN) {
+      this.revertCode = RevertCode.REVERTED;
     }
   }
 
@@ -243,8 +241,12 @@ export class PublicTxContext {
   }
 
   /**
-   * The gasUsed by public and private,
-   * as if the entire teardown gas limit was consumed.
+   * The gasUsed by public and private, as if the entire teardown gas limit was consumed.
+   *
+   * This is intentional: teardown is used for gas accounting and refunds, so the transaction
+   * fee must be deterministic _before_ teardown executes. If fees depended on teardown's actual
+   * consumption there would be a circular dependency. Billing the full teardown gas limit
+   * (set by the user) makes the fee known in advance and available to the teardown function.
    */
   getTotalGasUsed(): Gas {
     return this.gasUsedByPrivate.add(this.gasUsedByPublic);
@@ -441,8 +443,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() {

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -1,6 +1,6 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress, ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import { AvmExecutionHints, AvmTxHint, PublicSimulatorConfig, PublicTxEffect, PublicTxResult } from '@aztec/stdlib/avm';
@@ -27,7 +27,6 @@ import { type PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import {
   L2ToL1MessageLimitReachedError,
   NoteHashLimitReachedError,
-  NullifierCollisionError,
   NullifierLimitReachedError,
 } from '../side_effect_errors.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
@@ -81,6 +80,7 @@ type ProcessedPhase = {
 export class PublicTxSimulator implements PublicTxSimulatorInterface {
   protected log: Logger;
   protected readonly config: PublicSimulatorConfig;
+  protected readonly bindings?: LoggerBindings;
 
   constructor(
     protected merkleTree: MerkleTreeWriteOperations,
@@ -88,9 +88,11 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     protected globalVariables: GlobalVariables,
     config?: Partial<PublicSimulatorConfig>,
     protected protocolContracts: ProtocolContracts = ProtocolContractsList,
+    bindings?: LoggerBindings,
   ) {
     this.config = PublicSimulatorConfig.from(config ?? {});
-    this.log = createLogger(`simulator:public_tx_simulator`);
+    this.bindings = bindings;
+    this.log = createLogger(`simulator:public_tx_simulator`, bindings);
   }
 
   /**
@@ -119,6 +121,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
       this.globalVariables,
       this.protocolContracts,
       this.config.proverId,
+      this.bindings,
     );
 
     // This will throw if there is a nullifier collision.
@@ -143,7 +146,8 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     hintingContractsDB.createCheckpoint();
 
     try {
-      // This will throw if there is a nullifier collision or other insertion error (limit reached).
+      // This may throw: a side-effect limit error triggers a soft revert (caught below), while a
+      // nullifier collision is unrecoverable and propagates out of simulate() to throw out the tx.
       await this.insertRevertiblesFromPrivate(context);
 
       // Only proceed with app logic if there was no revert during revertible insertion.
@@ -195,8 +199,8 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
 
     // Such transactions should be filtered by GasTxValidator.
     assert(
-      context.getActualGasUsed().l2Gas <= AVM_MAX_PROCESSABLE_L2_GAS,
-      `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the AVM maximum processable gas of ${AVM_MAX_PROCESSABLE_L2_GAS}`,
+      context.getActualGasUsed().l2Gas <= MAX_PROCESSABLE_L2_GAS,
+      `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the maximum processable gas of ${MAX_PROCESSABLE_L2_GAS}`,
     );
     await this.payFee(context);
 
@@ -397,7 +401,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     // However, things work as expected because later calls to getters on the hintingContractsDB
     // will pick up the new contracts and will generate the necessary hints.
     // So, a consumer of the hints will always see the new contracts.
-    await this.contractsDB.addContracts(context.nonRevertibleContractDeploymentData);
+    this.contractsDB.addContracts(context.nonRevertibleContractDeploymentData);
   }
 
   /**
@@ -405,9 +409,13 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
    * Throws TxSimRevertibleInsertionsRevert if there is some checked error during revertible insertions.
    * This function checks for the following errors:
    * - NullifierLimitReachedError
-   * - NullifierCollisionError
    * - NoteHashLimitReachedError
    * - L2ToL1MessageLimitReachedError
+   *
+   * Note: NullifierCollisionError is intentionally NOT caught here. A nullifier collision
+   * during revertible insertions is unprovable (the nullifier originated from private, so
+   * a collision indicates the tx should never have been proposed). It propagates as-is to
+   * make the transaction unrecoverable, matching the AVM circuit behavior.
    */
   protected async insertRevertiblesFromPrivate(context: PublicTxContext) {
     const stateManager = context.state.getActiveStateManager();
@@ -417,7 +425,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
         await stateManager.writeSiloedNullifier(siloedNullifier);
       }
     } catch (e: any) {
-      if (e instanceof NullifierLimitReachedError || e instanceof NullifierCollisionError) {
+      if (e instanceof NullifierLimitReachedError) {
         context.revert(
           TxExecutionPhase.APP_LOGIC,
           new SimulationError(
@@ -427,7 +435,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
         );
         throw new TxSimRevertibleInsertionsRevert();
       } else {
-        // Unchecked/unknown error - re-throw as-is
+        // Unchecked/unknown error or NullifierCollisionError (unrecoverable) - re-throw as-is
         throw e;
       }
     }
@@ -482,7 +490,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     // However, things work as expected because later calls to getters on the hintingContractsDB
     // will pick up the new contracts and will generate the necessary hints.
     // So, a consumer of the hints will always see the new contracts.
-    await this.contractsDB.addContracts(context.revertibleContractDeploymentData);
+    this.contractsDB.addContracts(context.revertibleContractDeploymentData);
   }
 
   private async payFee(context: PublicTxContext) {

package/src/public/side_effect_trace.ts

@@ -9,7 +9,7 @@ import {
 } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type LogLevel, createLogger } from '@aztec/foundation/log';
+import { type LogLevel, type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
@@ -61,7 +61,7 @@ export class SideEffectArrayLengths {
  * Trace side effects for an enqueued public call's execution.
  */
 export class SideEffectTrace implements PublicSideEffectTraceInterface {
-  public log = createLogger('simulator:side_effect_trace');
+  public log: Logger;
 
   /** The side effect counter increments with every call to the trace. */
   private sideEffectCounter: number;
@@ -79,6 +79,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   constructor(
     /** The counter of this trace's first side effect. */
     public readonly startSideEffectCounter: number = 0,
+    bindings?: LoggerBindings,
     /** Track parent's (or previous kernel's) lengths so the AVM can properly enforce TX-wide limits,
      *  otherwise the public kernel can fail to prove because TX limits are breached.
      */
@@ -90,11 +91,13 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     private debugLogMemoryReads: number = 0,
   ) {
     this.sideEffectCounter = startSideEffectCounter;
+    this.log = createLogger('simulator:side_effect_trace', bindings);
   }
 
   public fork() {
     return new SideEffectTrace(
       this.sideEffectCounter,
+      this.log.getBindings(),
       new SideEffectArrayLengths(
         this.previousSideEffectArrayLengths.publicDataWrites + this.userPublicDataWritesLength,
         this.previousSideEffectArrayLengths.protocolPublicDataWrites + this.protocolPublicDataWritesLength,

package/src/public/state_manager/state_manager.ts

@@ -2,7 +2,7 @@ import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PROTOCOL_CONTRACTS } f
 import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { type LogLevel, createLogger } from '@aztec/foundation/log';
+import { type LogLevel, type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -42,7 +42,7 @@ import { PublicStorage } from './public_storage.js';
  * Manages merging of successful/reverted child state into current state.
  */
 export class PublicPersistableStateManager {
-  private readonly log = createLogger('simulator:state_manager');
+  private readonly log: Logger;
 
   /** Make sure a forked state is never merged twice. */
   private alreadyMergedIntoParent = false;
@@ -56,7 +56,10 @@ export class PublicPersistableStateManager {
     private readonly doMerkleOperations: boolean = true,
     private readonly publicStorage: PublicStorage = new PublicStorage(treesDB),
     private readonly nullifiers: NullifierManager = new NullifierManager(treesDB),
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('simulator:state_manager', bindings);
+  }
 
   /**
    * Create a new state manager
@@ -67,8 +70,19 @@ export class PublicPersistableStateManager {
     trace: PublicSideEffectTraceInterface,
     firstNullifier: Fr,
     timestamp: UInt64,
+    bindings?: LoggerBindings,
   ): PublicPersistableStateManager {
-    return new PublicPersistableStateManager(treesDB, contractsDB, trace, firstNullifier, timestamp);
+    return new PublicPersistableStateManager(
+      treesDB,
+      contractsDB,
+      trace,
+      firstNullifier,
+      timestamp,
+      undefined,
+      undefined,
+      undefined,
+      bindings,
+    );
   }
 
   /**
@@ -85,6 +99,7 @@ export class PublicPersistableStateManager {
       this.doMerkleOperations,
       this.publicStorage.fork(),
       this.nullifiers.fork(),
+      this.log.getBindings(),
     );
   }
 
@@ -233,7 +248,15 @@ export class PublicPersistableStateManager {
   public async checkNullifierExists(contractAddress: AztecAddress, nullifier: Fr): Promise<boolean> {
     this.log.trace(`Checking existence of nullifier (address=${contractAddress}, nullifier=${nullifier})`);
     const siloedNullifier = await siloNullifier(contractAddress, nullifier);
+    return this.checkSiloedNullifierExists(siloedNullifier);
+  }
 
+  /**
+   * Check if a siloed nullifier exists.
+   * @param siloedNullifier - the siloed nullifier to check
+   * @returns exists - whether the nullifier exists in the nullifier set
+   */
+  public async checkSiloedNullifierExists(siloedNullifier: Fr): Promise<boolean> {
     if (this.doMerkleOperations) {
       const exists = await this.treesDB.checkNullifierExists(siloedNullifier);
       this.log.trace(`Checked siloed nullifier ${siloedNullifier} (exists=${exists})`);

package/src/public/test_executor_metrics.ts

@@ -1,5 +1,5 @@
 import { sum } from '@aztec/foundation/collection';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { RevertCode } from '@aztec/stdlib/avm';
 import type { GasUsed } from '@aztec/stdlib/gas';
@@ -21,6 +21,7 @@ export interface PublicTxMetrics {
   totalDurationMs: number;
   manaUsed: number | undefined;
   totalInstructionsExecuted: number;
+  bytecodeSizes: { contractName: string; sizeBytes: number }[];
   nonRevertiblePrivateInsertionsUs: number | undefined;
   revertiblePrivateInsertionsUs: number | undefined;
   enqueuedCalls: PublicEnqueuedCallMetrics[];
@@ -62,6 +63,7 @@ function createEmptyTxMetrics(): PublicTxMetrics {
     totalDurationMs: 0,
     manaUsed: 0,
     totalInstructionsExecuted: 0,
+    bytecodeSizes: [],
     nonRevertiblePrivateInsertionsUs: undefined,
     revertiblePrivateInsertionsUs: undefined,
     enqueuedCalls: [],
@@ -88,8 +90,8 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
   private currentTxLabel: string | undefined;
   private txTimer: Timer | undefined;
 
-  constructor() {
-    this.logger = createLogger(`simulator:test_executor_metrics`);
+  constructor(bindings?: LoggerBindings) {
+    this.logger = createLogger(`simulator:test_executor_metrics`, bindings);
   }
 
   startRecordingTxSimulation(txLabel: string) {
@@ -172,6 +174,12 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
     }
   }
 
+  recordBytecodeSize(txLabel: string, contractName: string, sizeBytes: number) {
+    const txMetrics = this.txMetrics.get(txLabel);
+    assert(txMetrics, `Cannot record bytecode size for unknown tx label: ${txLabel}`);
+    txMetrics.bytecodeSizes.push({ contractName, sizeBytes });
+  }
+
   recordProverMetrics(txLabel: string, metrics: Partial<PublicTxMetrics>) {
     if (!this.txMetrics.has(txLabel)) {
       this.txMetrics.set(txLabel, createEmptyTxMetrics());
@@ -216,6 +224,15 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
       ) {
         pretty += `${INDENT0}Total instructions executed: ${fmtNum(txMetrics.totalInstructionsExecuted)}\n`;
       }
+      if (
+        (filter === PublicTxMetricsFilter.TOTALS || filter === PublicTxMetricsFilter.ALL) &&
+        txMetrics.bytecodeSizes.length > 0
+      ) {
+        pretty += `${INDENT0}Bytecode sizes:\n`;
+        for (const { contractName, sizeBytes } of txMetrics.bytecodeSizes) {
+          pretty += `${INDENT1}${contractName}: ${fmtNum(sizeBytes, 'bytes')}\n`;
+        }
+      }
       if (filter === PublicTxMetricsFilter.DURATIONS || filter === PublicTxMetricsFilter.ALL) {
         pretty += `${INDENT0}Private insertions:\n`;
         pretty += `${INDENT1}Non-revertible: ${fmtNum(txMetrics.nonRevertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
@@ -387,6 +404,13 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
           });
         }
       }
+      for (const { contractName, sizeBytes } of txMetrics.bytecodeSizes) {
+        data.push({
+          name: `${txLabel}/bytecodeSizeBytes/${contractName}`,
+          value: sizeBytes,
+          unit: 'bytes',
+        });
+      }
     }
     return JSON.stringify(data, null, indent);
   }