@aztec/simulator 0.65.0 → 0.65.2

package/src/public/public_db_sources.ts

@@ -14,11 +14,12 @@ import {
   ContractInstanceDeployedEvent,
   type ContractInstanceWithAddress,
   Fr,
-  FunctionSelector,
+  type FunctionSelector,
   type L1_TO_L2_MSG_TREE_HEIGHT,
   type NULLIFIER_TREE_HEIGHT,
   type NullifierLeafPreimage,
   type PublicDataTreeLeafPreimage,
+  computePublicBytecodeCommitment,
 } from '@aztec/circuits.js';
 import { computeL1ToL2MessageNullifier, computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -38,11 +39,11 @@ import {
 export class ContractsDataSourcePublicDB implements PublicContractsDB {
   private instanceCache = new Map<string, ContractInstanceWithAddress>();
   private classCache = new Map<string, ContractClassPublic>();
+  private bytecodeCommitmentCache = new Map<string, Fr>();
 
   private log = createDebugLogger('aztec:sequencer:contracts-data-source');
 
   constructor(private dataSource: ContractDataSource) {}
-
   /**
    * Add new contracts from a transaction
    * @param tx - The transaction to add contracts from.
@@ -92,6 +93,31 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     return this.classCache.get(contractClassId.toString()) ?? (await this.dataSource.getContractClass(contractClassId));
   }
 
+  public async getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
+    // Try and retrieve from cache
+    const key = contractClassId.toString();
+    const result = this.bytecodeCommitmentCache.get(key);
+    if (result !== undefined) {
+      return result;
+    }
+    // Now try from the store
+    const fromStore = await this.dataSource.getBytecodeCommitment(contractClassId);
+    if (fromStore !== undefined) {
+      this.bytecodeCommitmentCache.set(key, fromStore);
+      return fromStore;
+    }
+
+    // Not in either the store or the cache, build it here and cache
+    const contractClass = await this.getContractClass(contractClassId);
+    if (contractClass === undefined) {
+      return undefined;
+    }
+
+    const value = computePublicBytecodeCommitment(contractClass.packedBytecode);
+    this.bytecodeCommitmentCache.set(key, value);
+    return value;
+  }
+
   async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
     const instance = await this.getContractInstance(address);
     if (!instance) {
@@ -105,19 +131,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
   }
 
   public async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    const artifact = await this.dataSource.getContractArtifact(address);
-    if (!artifact) {
-      return Promise.resolve(undefined);
-    }
-
-    const f = artifact.functions.find(f =>
-      FunctionSelector.fromNameAndParameters(f.name, f.parameters).equals(selector),
-    );
-    if (!f) {
-      return Promise.resolve(undefined);
-    }
-
-    return Promise.resolve(`${artifact.name}:${f.name}`);
+    return await this.dataSource.getContractFunctionName(address, selector);
   }
 }
 

package/src/public/public_processor.ts

@@ -80,7 +80,7 @@ export class PublicProcessor {
     protected worldStateDB: WorldStateDB,
     protected publicTxSimulator: PublicTxSimulator,
     telemetryClient: TelemetryClient,
-    private log = createDebugLogger('aztec:sequencer:public-processor'),
+    private log = createDebugLogger('aztec:simulator:public-processor'),
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
   }
@@ -201,6 +201,7 @@ export class PublicProcessor {
     feePayer: AztecAddress,
   ): Promise<PublicDataWrite | undefined> {
     if (feePayer.isZero()) {
+      this.log.debug(`No one is paying the fee of ${txFee.toBigInt()}`);
       return;
     }
 
@@ -208,7 +209,7 @@ export class PublicProcessor {
     const balanceSlot = computeFeePayerBalanceStorageSlot(feePayer);
     const leafSlot = computeFeePayerBalanceLeafSlot(feePayer);
 
-    this.log.debug(`Deducting ${txFee} balance in Fee Juice for ${feePayer}`);
+    this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
 
     const existingBalanceWrite = publicDataWrites.find(write => write.leafSlot.equals(leafSlot));
 
@@ -217,7 +218,9 @@ export class PublicProcessor {
       : await this.worldStateDB.storageRead(feeJuiceAddress, balanceSlot);
 
     if (balance.lt(txFee)) {
-      throw new Error(`Not enough balance for fee payer to pay for transaction (got ${balance} needs ${txFee})`);
+      throw new Error(
+        `Not enough balance for fee payer to pay for transaction (got ${balance.toBigInt()} needs ${txFee.toBigInt()})`,
+      );
     }
 
     const updatedBalance = balance.sub(txFee);
@@ -226,6 +229,9 @@ export class PublicProcessor {
     return new PublicDataWrite(leafSlot, updatedBalance);
   }
 
+  @trackSpan('PublicProcessor.processPrivateOnlyTx', (tx: Tx) => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
+  }))
   private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx]> {
     const gasFees = this.globalVariables.gasFees;
     const transactionFee = tx.data.gasUsed.computeFee(gasFees);
@@ -276,7 +282,8 @@ export class PublicProcessor {
     );
 
     const phaseCount = processedPhases.length;
-    this.metrics.recordTx(phaseCount, timer.ms());
+    const durationMs = timer.ms();
+    this.metrics.recordTx(phaseCount, durationMs);
 
     const data = avmProvingRequest.inputs.output;
     const feePaymentPublicDataWrite = await this.getFeePaymentPublicDataWrite(

package/src/public/public_tx_context.ts

@@ -1,5 +1,6 @@
 import {
   type AvmProvingRequest,
+  MerkleTreeId,
   type MerkleTreeReadOperations,
   type PublicExecutionRequest,
   type SimulationError,
@@ -67,10 +68,9 @@ export class PublicTxContext {
     private readonly setupExecutionRequests: PublicExecutionRequest[],
     private readonly appLogicExecutionRequests: PublicExecutionRequest[],
     private readonly teardownExecutionRequests: PublicExecutionRequest[],
-    private readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
-    private readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
+    public readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
+    public readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public trace: PublicEnqueuedCallSideEffectTrace, // FIXME(dbanks12): should be private
-    private doMerkleOperations: boolean,
   ) {
     this.log = createDebugLogger(`aztec:public_tx_context`);
     this.gasUsed = startGasUsed;
@@ -84,23 +84,12 @@ export class PublicTxContext {
     doMerkleOperations: boolean,
   ) {
     const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
-    const revertibleAccumulatedDataFromPrivate = tx.data.forPublic!.revertibleAccumulatedData;
-    const nonRevertibleNullifiersFromPrivate = nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter(
-      n => !n.isEmpty(),
-    );
-    const _revertibleNullifiersFromPrivate = revertibleAccumulatedDataFromPrivate.nullifiers.filter(n => !n.isEmpty());
 
     const innerCallTrace = new PublicSideEffectTrace();
-
     const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(
-      /*publicDataReads*/ 0,
       /*publicDataWrites*/ 0,
-      /*noteHashReadRequests*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.noteHashes),
-      /*nullifierReadRequests*/ 0,
-      /*nullifierNonExistentReadRequests*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.nullifiers),
-      /*l1ToL2MsgReadRequests*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
       /*unencryptedLogsHashes*/ 0,
     );
@@ -111,12 +100,7 @@ export class PublicTxContext {
     const trace = new DualSideEffectTrace(innerCallTrace, enqueuedCallTrace);
 
     // Transaction level state manager that will be forked for revertible phases.
-    const txStateManager = await AvmPersistableStateManager.newWithPendingSiloedNullifiers(
-      worldStateDB,
-      trace,
-      nonRevertibleNullifiersFromPrivate,
-      doMerkleOperations,
-    );
+    const txStateManager = await AvmPersistableStateManager.create(worldStateDB, trace, doMerkleOperations);
 
     return new PublicTxContext(
       new PhaseStateManager(txStateManager),
@@ -134,7 +118,6 @@ export class PublicTxContext {
       tx.data.forPublic!.nonRevertibleAccumulatedData,
       tx.data.forPublic!.revertibleAccumulatedData,
       enqueuedCallTrace,
-      doMerkleOperations,
     );
   }
 
@@ -144,6 +127,9 @@ export class PublicTxContext {
    * Actual transaction fee and actual total consumed gas can now be queried.
    */
   halt() {
+    if (this.state.isForked()) {
+      this.state.mergeForkedState();
+    }
     this.halted = true;
   }
 
@@ -315,6 +301,11 @@ export class PublicTxContext {
    */
   private generateAvmCircuitPublicInputs(endStateReference: StateReference): AvmCircuitPublicInputs {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
+    // TODO(dbanks12): use the state roots from ephemeral trees
+    endStateReference.partial.nullifierTree.root = this.state
+      .getActiveStateManager()
+      .merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!
+      .getRoot();
     return generateAvmCircuitPublicInputs(
       this.trace,
       this.globalVariables,
@@ -379,16 +370,21 @@ export class PublicTxContext {
  * so that we can conditionally fork at the start of a phase.
  *
  * There is a state manager that lives at the level of the entire transaction,
- * but for setup and teardown the active state manager will be a fork of the
+ * but for app logic and teardown the active state manager will be a fork of the
  * transaction level one.
  */
 class PhaseStateManager {
+  private log: DebugLogger;
+
   private currentlyActiveStateManager: AvmPersistableStateManager | undefined;
 
-  constructor(private readonly txStateManager: AvmPersistableStateManager) {}
+  constructor(private readonly txStateManager: AvmPersistableStateManager) {
+    this.log = createDebugLogger(`aztec:public_phase_state_manager`);
+  }
 
   fork() {
     assert(!this.currentlyActiveStateManager, 'Cannot fork when already forked');
+    this.log.debug(`Forking phase state manager`);
     this.currentlyActiveStateManager = this.txStateManager.fork();
   }
 
@@ -402,12 +398,14 @@ class PhaseStateManager {
 
   mergeForkedState() {
     assert(this.currentlyActiveStateManager, 'No forked state to merge');
+    this.log.debug(`Merging in forked state`);
     this.txStateManager.merge(this.currentlyActiveStateManager!);
     // Drop the forked state manager now that it is merged
     this.currentlyActiveStateManager = undefined;
   }
 
   discardForkedState() {
+    this.log.debug(`Discarding forked state`);
     assert(this.currentlyActiveStateManager, 'No forked state to discard');
     this.txStateManager.reject(this.currentlyActiveStateManager!);
     // Drop the forked state manager. We don't want it!

package/src/public/public_tx_simulator.ts

@@ -20,10 +20,13 @@ import {
 } from '@aztec/circuits.js';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { type TelemetryClient } from '@aztec/telemetry-client';
+import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
+
+import { strict as assert } from 'assert';
 
 import { type AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmPersistableStateManager, AvmSimulator } from '../avm/index.js';
+import { NullifierCollisionError } from '../avm/journal/nullifiers.js';
 import { getPublicFunctionDebugName } from '../common/debug_fn_name.js';
 import { ExecutorMetrics } from './executor_metrics.js';
 import { type WorldStateDB } from './public_db_sources.js';
@@ -55,15 +58,18 @@ export class PublicTxSimulator {
   constructor(
     private db: MerkleTreeReadOperations,
     private worldStateDB: WorldStateDB,
-    client: TelemetryClient,
+    telemetryClient: TelemetryClient,
     private globalVariables: GlobalVariables,
     private realAvmProvingRequests: boolean = true,
     private doMerkleOperations: boolean = false,
   ) {
     this.log = createDebugLogger(`aztec:public_tx_simulator`);
-    this.metrics = new ExecutorMetrics(client, 'PublicTxSimulator');
+    this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
   }
 
+  get tracer(): Tracer {
+    return this.metrics.tracer;
+  }
   /**
    * Simulate a transaction's public portion including all of its phases.
    * @param tx - The transaction to simulate.
@@ -89,11 +95,14 @@ export class PublicTxSimulator {
     // FIXME: we shouldn't need to directly modify worldStateDb here!
     await this.worldStateDB.addNewContracts(tx);
 
+    await this.insertNonRevertiblesFromPrivate(context);
     const processedPhases: ProcessedPhase[] = [];
     if (context.hasPhase(TxExecutionPhase.SETUP)) {
       const setupResult: ProcessedPhase = await this.simulateSetupPhase(context);
       processedPhases.push(setupResult);
     }
+
+    await this.insertRevertiblesFromPrivate(context);
     if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
       const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
       processedPhases.push(appLogicResult);
@@ -149,9 +158,7 @@ export class PublicTxSimulator {
    * @returns The phase result.
    */
   private async simulateAppLogicPhase(context: PublicTxContext): Promise<ProcessedPhase> {
-    // Fork the state manager so that we can rollback state if app logic or teardown reverts.
-    // Don't need to fork for setup since it's non-revertible (if setup fails, transaction is thrown out).
-    context.state.fork();
+    assert(context.state.isForked(), 'App logic phase should operate with forked state.');
 
     const result = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
 
@@ -175,7 +182,7 @@ export class PublicTxSimulator {
    */
   private async simulateTeardownPhase(context: PublicTxContext): Promise<ProcessedPhase> {
     if (!context.state.isForked()) {
-      // If state isn't forked (app logic was empty or reverted), fork now
+      // If state isn't forked (app logic reverted), fork now
       // so we can rollback to the end of setup if teardown reverts.
       context.state.fork();
     }
@@ -244,6 +251,12 @@ export class PublicTxSimulator {
    * @param executionRequest - The execution request (includes args)
    * @returns The result of execution.
    */
+  @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, _callRequest, executionRequest) => ({
+    [Attributes.TX_HASH]: context.getTxHash().toString(),
+    [Attributes.TARGET_ADDRESS]: executionRequest.callContext.contractAddress.toString(),
+    [Attributes.SENDER_ADDRESS]: executionRequest.callContext.msgSender.toString(),
+    [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString(),
+  }))
   private async simulateEnqueuedCall(
     phase: TxExecutionPhase,
     context: PublicTxContext,
@@ -312,6 +325,12 @@ export class PublicTxSimulator {
    * @param fnName - The name of the function
    * @returns The result of execution.
    */
+  @trackSpan(
+    'PublicTxSimulator.simulateEnqueuedCallInternal',
+    (_stateManager, _executionRequest, _allocatedGas, _transactionFee, fnName) => ({
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    }),
+  )
   private async simulateEnqueuedCallInternal(
     stateManager: AvmPersistableStateManager,
     executionRequest: PublicExecutionRequest,
@@ -356,9 +375,44 @@ export class PublicTxSimulator {
     if (result.reverted) {
       this.metrics.recordFunctionSimulationFailure();
     } else {
-      this.metrics.recordFunctionSimulation(timer.ms());
+      this.metrics.recordFunctionSimulation(timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, fnName);
     }
 
     return result;
   }
+
+  /**
+   * Insert the non-revertible accumulated data from private into the public state.
+   */
+  public async insertNonRevertiblesFromPrivate(context: PublicTxContext) {
+    const stateManager = context.state.getActiveStateManager();
+    try {
+      await stateManager.writeSiloedNullifiersFromPrivate(context.nonRevertibleAccumulatedDataFromPrivate.nullifiers);
+    } catch (e) {
+      if (e instanceof NullifierCollisionError) {
+        throw new NullifierCollisionError(
+          `Nullifier collision encountered when inserting non-revertible nullifiers from private.\nDetails: ${e.message}\n.Stack:${e.stack}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * Insert the revertible accumulated data from private into the public state.
+   * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
+   */
+  public async insertRevertiblesFromPrivate(context: PublicTxContext) {
+    // Fork the state manager so we can rollback to end of setup if app logic reverts.
+    context.state.fork();
+    const stateManager = context.state.getActiveStateManager();
+    try {
+      await stateManager.writeSiloedNullifiersFromPrivate(context.revertibleAccumulatedDataFromPrivate.nullifiers);
+    } catch (e) {
+      if (e instanceof NullifierCollisionError) {
+        throw new NullifierCollisionError(
+          `Nullifier collision encountered when inserting revertible nullifiers from private. Details:\n${e.message}\n.Stack:${e.stack}`,
+        );
+      }
+    }
+  }
 }

package/src/public/side_effect_trace.ts

@@ -45,6 +45,7 @@ import {
   TreeLeafReadRequest,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { assert } from 'console';
@@ -214,8 +215,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public traceNullifierCheck(
-    _contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
     exists: boolean,
     lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
     lowLeafIndex: Fr = Fr.zero(),
@@ -226,7 +226,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
 
     this.enforceLimitOnNullifierChecks();
 
-    const readRequest = new ReadRequest(nullifier, this.sideEffectCounter);
+    const readRequest = new ReadRequest(siloedNullifier, this.sideEffectCounter);
     if (exists) {
       this.nullifierReadRequests.push(readRequest);
     } else {
@@ -245,8 +245,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public traceNewNullifier(
-    _contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
     lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
     lowLeafIndex: Fr = Fr.zero(),
     lowLeafPath: Fr[] = emptyNullifierPath(),
@@ -256,7 +255,8 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     if (this.nullifiers.length >= MAX_NULLIFIERS_PER_TX) {
       throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
     }
-    this.nullifiers.push(new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
+    // this will be wrong for siloedNullifier
+    this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
     // New hinting
     const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
     this.avmCircuitHints.nullifierWriteHints.items.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
@@ -362,9 +362,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       new AvmContractBytecodeHints(bytecode, instance, contractClass),
     );
     this.log.debug(
-      `Bytecode retrieval for contract execution traced: exists=${exists}, instance=${JSON.stringify(
-        contractInstance,
-      )}`,
+      `Bytecode retrieval for contract execution traced: exists=${exists}, instance=${jsonStringify(contractInstance)}`,
     );
   }
 

package/src/public/side_effect_trace_interface.ts

@@ -40,16 +40,14 @@ export interface PublicSideEffectTraceInterface {
   traceNoteHashCheck(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr, exists: boolean, path?: Fr[]): void;
   traceNewNoteHash(contractAddress: AztecAddress, noteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
   traceNullifierCheck(
-    contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
     exists: boolean,
     lowLeafPreimage?: NullifierLeafPreimage,
     lowLeafIndex?: Fr,
     lowLeafPath?: Fr[],
   ): void;
   traceNewNullifier(
-    contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
     lowLeafPreimage?: NullifierLeafPreimage,
     lowLeafIndex?: Fr,
     lowLeafPath?: Fr[],

package/src/public/transitional_adapters.ts

@@ -20,7 +20,6 @@ import {
   MAX_NOTE_HASHES_PER_TX,
   MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIERS_PER_CALL,
-  MAX_NULLIFIERS_PER_TX,
   MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
@@ -146,16 +145,6 @@ export function generateAvmCircuitPublicInputs(
     }
   }
 
-  const nullifiersFromPrivate = revertCode.isOK()
-    ? mergeAccumulatedData(
-        avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.nullifiers,
-        avmCircuitPublicInputs.previousRevertibleAccumulatedData.nullifiers,
-      )
-    : avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.nullifiers;
-  avmCircuitPublicInputs.accumulatedData.nullifiers = assertLength(
-    mergeAccumulatedData(nullifiersFromPrivate, avmCircuitPublicInputs.accumulatedData.nullifiers),
-    MAX_NULLIFIERS_PER_TX,
-  );
   const msgsFromPrivate = revertCode.isOK()
     ? mergeAccumulatedData(
         avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs,