@aztec/simulator 0.0.1-commit.9372f48 → 0.0.1-commit.949a33fd8

package/src/public/fixtures/utils.ts

@@ -2,10 +2,8 @@ import {
   CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE,
   CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
   CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-  DEFAULT_DA_GAS_LIMIT,
-  DEFAULT_L2_GAS_LIMIT,
-  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
-  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+  MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT,
+  MAX_PROCESSABLE_L2_GAS,
   PRIVATE_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -14,7 +12,13 @@ import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '@aztec/protocol-contracts
 import { bufferAsFields } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import {
+  FALLBACK_TEARDOWN_DA_GAS_LIMIT,
+  FALLBACK_TEARDOWN_L2_GAS_LIMIT,
+  Gas,
+  GasFees,
+  GasSettings,
+} from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import {
   LogHash,
@@ -62,13 +66,14 @@ export async function createTxForPublicCalls(
   feePayer = AztecAddress.zero(),
   gasUsedByPrivate: Gas = Gas.empty(),
   globals: GlobalVariables = GlobalVariables.empty(),
+  gasLimits?: Gas,
 ): Promise<Tx> {
   assert(
     setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== undefined,
     "Can't create public tx with no enqueued calls",
   );
   // use max limits
-  const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+  gasLimits = gasLimits ?? new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
 
   const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
 
@@ -128,19 +133,19 @@ export async function createTxForPublicCalls(
 
   const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
   const teardownGasLimits = teardownCallRequest
-    ? new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT)
+    ? new Gas(FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT)
     : Gas.empty();
   const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const header = BlockHeader.empty({ globalVariables: globals });
   const constantData = new TxConstantData(header, txContext, Fr.zero(), Fr.zero());
-  const includeByTimestamp = 0n; // Not used in the simulator.
+  const expirationTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
-    includeByTimestamp,
+    expirationTimestamp,
     forPublic,
   );
 
@@ -163,7 +168,7 @@ export async function createTxForPrivateOnly(
   gasUsedByPrivate: Gas = new Gas(10, 10),
 ): Promise<Tx> {
   // use max limits
-  const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+  const gasLimits = new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
 
   const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
 
@@ -171,13 +176,13 @@ export async function createTxForPrivateOnly(
   const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
-  const includeByTimestamp = 0n; // Not used in the simulator.
+  const expirationTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
-    includeByTimestamp,
+    expirationTimestamp,
     /*forPublic=*/ undefined,
     forRollup,
   );

package/src/public/fuzzing/avm_fuzzer_simulator.ts

@@ -146,7 +146,7 @@ async function createTxFromHint(cppTx: AvmTxHint): Promise<Tx> {
     constants,
     cppTx.gasUsedByPrivate,
     cppTx.feePayer,
-    0n, // includeByTimestamp
+    0n, // expirationTimestamp
     forPublic,
     undefined, // forRollup - not needed for public simulation
   );

package/src/public/hinting_db_sources.ts

@@ -410,12 +410,12 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
     }
   }
 
-  public async createCheckpoint(): Promise<void> {
+  public async createCheckpoint(): Promise<number> {
     const actionCounter = this.checkpointActionCounter++;
     const oldCheckpointId = this.getCurrentCheckpointId();
     const treesStateHash = await this.getTreesStateHash();
 
-    await this.db.createCheckpoint();
+    const depth = await this.db.createCheckpoint();
     this.checkpointStack.push(this.nextCheckpointId++);
     const newCheckpointId = this.getCurrentCheckpointId();
 
@@ -424,14 +424,16 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
     HintingMerkleWriteOperations.log.trace(
       `[createCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`,
     );
+
+    return depth;
   }
 
-  public commitAllCheckpoints(): Promise<void> {
-    throw new Error('commitAllCheckpoints is not supported in HintingMerkleWriteOperations.');
+  public commitAllCheckpointsTo(_depth: number): Promise<void> {
+    throw new Error('commitAllCheckpointsTo is not supported in HintingMerkleWriteOperations.');
   }
 
-  public revertAllCheckpoints(): Promise<void> {
-    throw new Error('revertAllCheckpoints is not supported in HintingMerkleWriteOperations.');
+  public revertAllCheckpointsTo(_depth: number): Promise<void> {
+    throw new Error('revertAllCheckpointsTo is not supported in HintingMerkleWriteOperations.');
   }
 
   public async commitCheckpoint(): Promise<void> {
@@ -572,7 +574,7 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
     return await this.db.close();
   }
 
-  async [Symbol.dispose](): Promise<void> {
+  async [Symbol.asyncDispose](): Promise<void> {
     await this.close();
   }
 

package/src/public/public_db_sources.ts

@@ -55,10 +55,10 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     this.log = createLogger('simulator:contracts-data-source', bindings);
   }
 
-  public async addContracts(contractDeploymentData: ContractDeploymentData): Promise<void> {
+  public addContracts(contractDeploymentData: ContractDeploymentData): void {
     const currentState = this.getCurrentState();
 
-    await this.addContractClassesFromEvents(
+    this.addContractClassesFromEvents(
       ContractClassPublishedEvent.extractContractClassEvents(contractDeploymentData.getContractClassLogs()),
       currentState,
     );
@@ -69,10 +69,10 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     );
   }
 
-  public async addNewContracts(tx: Tx): Promise<void> {
+  public addNewContracts(tx: Tx): void {
     const contractDeploymentData = AllContractDeploymentData.fromTx(tx);
-    await this.addContracts(contractDeploymentData.getNonRevertibleContractDeploymentData());
-    await this.addContracts(contractDeploymentData.getRevertibleContractDeploymentData());
+    this.addContracts(contractDeploymentData.getNonRevertibleContractDeploymentData());
+    this.addContracts(contractDeploymentData.getRevertibleContractDeploymentData());
   }
 
   /**
@@ -81,7 +81,7 @@ export class PublicContractsDB implements PublicContractsDBInterface {
    */
   public createCheckpoint(): void {
     const currentState = this.getCurrentState();
-    const newState = currentState.deepCopy();
+    const newState = currentState.fork();
     this.contractStateStack.push(newState);
   }
 
@@ -174,17 +174,15 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     return await this.dataSource.getDebugFunctionName(address, selector);
   }
 
-  private async addContractClassesFromEvents(
+  private addContractClassesFromEvents(
     contractClassEvents: ContractClassPublishedEvent[],
     state: ContractsDbCheckpoint,
   ) {
-    await Promise.all(
-      contractClassEvents.map(async (event: ContractClassPublishedEvent) => {
-        this.log.debug(`Adding class ${event.contractClassId.toString()} to contract state`);
-        const contractClass = await event.toContractClassPublic();
-        state.addClass(event.contractClassId, contractClass);
-      }),
-    );
+    for (const event of contractClassEvents) {
+      this.log.debug(`Adding class ${event.contractClassId.toString()} to contract state`);
+      const contractClass = event.toContractClassPublic();
+      state.addClass(event.contractClassId, contractClass);
+    }
   }
 
   private addContractInstancesFromEvents(

package/src/public/public_processor/guarded_merkle_tree.ts

@@ -82,7 +82,7 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
     return this.guardAndPush(() => this.target.close());
   }
 
-  async [Symbol.dispose](): Promise<void> {
+  async [Symbol.asyncDispose](): Promise<void> {
     await this.close();
   }
   getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
@@ -134,7 +134,7 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
   ): Promise<(BlockNumber | undefined)[]> {
     return this.guardAndPush(() => this.target.getBlockNumbersForLeafIndices(treeId, leafIndices));
   }
-  createCheckpoint(): Promise<void> {
+  createCheckpoint(): Promise<number> {
     return this.guardAndPush(() => this.target.createCheckpoint());
   }
   commitCheckpoint(): Promise<void> {
@@ -143,11 +143,11 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
   revertCheckpoint(): Promise<void> {
     return this.guardAndPush(() => this.target.revertCheckpoint());
   }
-  commitAllCheckpoints(): Promise<void> {
-    return this.guardAndPush(() => this.target.commitAllCheckpoints());
+  commitAllCheckpointsTo(depth: number): Promise<void> {
+    return this.guardAndPush(() => this.target.commitAllCheckpointsTo(depth));
   }
-  revertAllCheckpoints(): Promise<void> {
-    return this.guardAndPush(() => this.target.revertAllCheckpoints());
+  revertAllCheckpointsTo(depth: number): Promise<void> {
+    return this.guardAndPush(() => this.target.revertAllCheckpointsTo(depth));
   }
   findSiblingPaths<ID extends MerkleTreeId>(
     treeId: ID,

package/src/public/public_processor/public_processor.ts

@@ -25,6 +25,7 @@ import type {
   PublicProcessorValidator,
   SequencerConfig,
 } from '@aztec/stdlib/interfaces/server';
+import { type DebugLog, type DebugLogStore, NullDebugLogStore } from '@aztec/stdlib/logs';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
@@ -130,7 +131,6 @@ class PublicProcessorTimeoutError extends Error {
  */
 export class PublicProcessor implements Traceable {
   private metrics: PublicProcessorMetrics;
-
   constructor(
     protected globalVariables: GlobalVariables,
     private guardedMerkleTree: GuardedMerkleTreeOperations,
@@ -140,6 +140,7 @@ export class PublicProcessor implements Traceable {
     telemetryClient: TelemetryClient = getTelemetryClient(),
     private log: Logger,
     private opts: Pick<SequencerConfig, 'fakeProcessingDelayPerTxMs' | 'fakeThrowAfterProcessingTxCount'> = {},
+    private debugLogStore: DebugLogStore = new NullDebugLogStore(),
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
   }
@@ -159,12 +160,13 @@ export class PublicProcessor implements Traceable {
     txs: Iterable<Tx> | AsyncIterable<Tx>,
     limits: PublicProcessorLimits = {},
     validator: PublicProcessorValidator = {},
-  ): Promise<[ProcessedTx[], FailedTx[], Tx[], NestedProcessReturnValues[], number]> {
-    const { maxTransactions, maxBlockSize, deadline, maxBlockGas, maxBlobFields } = limits;
+  ): Promise<[ProcessedTx[], FailedTx[], Tx[], NestedProcessReturnValues[], DebugLog[]]> {
+    const { maxTransactions, deadline, maxBlockGas, maxBlobFields, isBuildingProposal } = limits;
     const { preprocessValidator, nullifierCache } = validator;
     const result: ProcessedTx[] = [];
     const usedTxs: Tx[] = [];
     const failed: FailedTx[] = [];
+    const debugLogs: DebugLog[] = [];
     const timer = new Timer();
 
     let totalSizeInBytes = 0;
@@ -172,6 +174,8 @@ export class PublicProcessor implements Traceable {
     let totalPublicGas = new Gas(0, 0);
     let totalBlockGas = new Gas(0, 0);
     let totalBlobFields = 0;
+    let silentlySkippedCount = 0;
+    let totalSilentlySkippedDurationMs = 0;
 
     for await (const tx of txs) {
       // Only process up to the max tx limit
@@ -186,22 +190,23 @@ export class PublicProcessor implements Traceable {
         break;
       }
 
-      // Skip this tx if it'd exceed max block size
       const txHash = tx.getTxHash().toString();
-      const preTxSizeInBytes = tx.getEstimatedPrivateTxEffectsSize();
-      if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
-        this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
-          txHash,
-          sizeInBytes: preTxSizeInBytes,
-          totalSizeInBytes,
-          maxBlockSize,
-        });
+
+      // Skip this tx if its estimated blob fields would exceed the limit.
+      // Only done during proposal building: during re-execution we must process the exact txs from the proposal.
+      const txBlobFields = tx.getPrivateTxEffectsSizeInFields();
+      if (isBuildingProposal && maxBlobFields !== undefined && totalBlobFields + txBlobFields > maxBlobFields) {
+        this.log.warn(
+          `Skipping tx ${txHash} with ${txBlobFields} fields from private side effects due to blob fields limit`,
+          { txHash, txBlobFields, totalBlobFields, maxBlobFields },
+        );
         continue;
       }
 
-      // Skip this tx if its gas limit would exceed the block gas limit
+      // Skip this tx if its gas limit would exceed the block gas limit (either da or l2).
+      // Only done during proposal building: during re-execution we must process the exact txs from the proposal.
       const txGasLimit = tx.data.constants.txContext.gasSettings.gasLimits;
-      if (maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
+      if (isBuildingProposal && maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
         this.log.warn(`Skipping processing of tx ${txHash} due to block gas limit`, {
           txHash,
           txGasLimit,
@@ -241,7 +246,9 @@ export class PublicProcessor implements Traceable {
       this.contractsDB.createCheckpoint();
 
       try {
-        const [processedTx, returnValues] = await this.processTx(tx, deadline);
+        const [txProcessingTimeMs, [processedTx, returnValues, txDebugLogs]] = await elapsed(() =>
+          this.processTx(tx, deadline),
+        );
 
         // Inject a fake processing failure after N txs if requested
         const fakeThrowAfter = this.opts.fakeThrowAfterProcessingTxCount;
@@ -250,23 +257,9 @@ export class PublicProcessor implements Traceable {
         }
 
         const txBlobFields = processedTx.txEffect.getNumBlobFields();
-
-        // If the actual size of this tx would exceed block size, skip it
         const txSize = txBlobFields * Fr.SIZE_IN_BYTES;
-        if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
-          this.log.debug(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
-            txHash,
-            sizeInBytes: txSize,
-            totalSizeInBytes,
-            maxBlockSize,
-          });
-          // Need to revert the checkpoint here and don't go any further
-          await checkpoint.revert();
-          this.contractsDB.revertCheckpoint();
-          continue;
-        }
 
-        // If the actual blob fields of this tx would exceed the limit, skip it
+        // If the actual blob fields of this tx would exceed the limit, skip it.
         // Note: maxBlobFields already accounts for block end blob fields and previous blocks in checkpoint.
         if (maxBlobFields !== undefined && totalBlobFields + txBlobFields > maxBlobFields) {
           this.log.debug(
@@ -276,25 +269,54 @@ export class PublicProcessor implements Traceable {
               txBlobFields,
               totalBlobFields,
               maxBlobFields,
+              txProcessingTimeMs,
             },
           );
+          silentlySkippedCount += 1;
+          totalSilentlySkippedDurationMs += txProcessingTimeMs;
+          this.metrics.recordSilentlySkipped(txProcessingTimeMs);
           // Need to revert the checkpoint here and don't go any further
           await checkpoint.revert();
           this.contractsDB.revertCheckpoint();
           continue;
         }
 
+        // During re-execution, check if the actual gas used by this tx would push the block over the gas limit.
+        // Unlike the proposal-building check (which uses declared gas limits pessimistically before processing),
+        // this uses actual gas and stops processing when the limit is exceeded.
+        if (
+          !isBuildingProposal &&
+          maxBlockGas !== undefined &&
+          totalBlockGas.add(processedTx.gasUsed.totalGas).gtAny(maxBlockGas)
+        ) {
+          this.log.warn(`Stopping re-execution since tx ${txHash} would push block gas over limit`, {
+            txHash,
+            txGas: processedTx.gasUsed.totalGas,
+            totalBlockGas,
+            maxBlockGas,
+          });
+          await checkpoint.revert();
+          this.contractsDB.revertCheckpoint();
+          break;
+        }
+
         // FIXME(fcarreiro): it's ugly to have to notify the validator of nullifiers.
         // I'd rather pass the validators the processedTx as well and let them deal with it.
         nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
         result.push(processedTx);
         usedTxs.push(tx);
         returns = returns.concat(returnValues);
+        debugLogs.push(...txDebugLogs);
+
+        this.debugLogStore.storeLogs(processedTx.hash.toString(), txDebugLogs);
 
         totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
         totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
         totalSizeInBytes += txSize;
         totalBlobFields += txBlobFields;
+
+        // Commit the tx-level contracts checkpoint on success
+        this.contractsDB.commitCheckpoint();
       } catch (err: any) {
         if (err?.name === 'PublicProcessorTimeoutError') {
           this.log.warn(`Stopping tx processing due to timeout.`);
@@ -314,14 +336,10 @@ export class PublicProcessor implements Traceable {
           // 1. At least one outstanding checkpoint that has not been committed (the one created before we processed the tx).
           // 2. Possible state updates on that checkpoint or any others created during execution.
 
-          // First we revert a checkpoint as managed by the ForkCheckpoint. This will revert whatever is the current checkpoint
-          // which may not be the one originally created by this object. But that is ok, we do this to fulfil the ForkCheckpoint
-          // lifecycle expectations and ensure it doesn't attempt to commit later on.
-          await checkpoint.revert();
-
-          // Now we want to revert any/all remaining checkpoints, destroying any outstanding state updates.
-          // This needs to be done directly on the underlying fork as the guarded fork has been stopped.
-          await this.guardedMerkleTree.getUnderlyingFork().revertAllCheckpoints();
+          // Revert all checkpoints at or above this checkpoint's depth (inclusive), destroying any outstanding state
+          // updates from this tx and any nested checkpoints created during execution. This preserves any checkpoints
+          // created by callers below our depth.
+          await checkpoint.revertToCheckpoint();
 
           // Revert any contracts added to the DB for the tx.
           this.contractsDB.revertCheckpoint();
@@ -333,9 +351,9 @@ export class PublicProcessor implements Traceable {
           break;
         }
 
-        // Roll back state to start of TX before proceeding to next TX
-        await checkpoint.revert();
-        await this.guardedMerkleTree.getUnderlyingFork().revertAllCheckpoints();
+        // Roll back state to start of TX before proceeding to next TX.
+        // Reverts all checkpoints at or above this checkpoint's depth, preserving any caller checkpoints below.
+        await checkpoint.revertToCheckpoint();
         this.contractsDB.revertCheckpoint();
         const errorMessage = err instanceof Error || err instanceof AssertionError ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${txHash.toString()}: ${errorMessage} ${err?.stack}`);
@@ -347,7 +365,6 @@ export class PublicProcessor implements Traceable {
       } finally {
         // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was previously reverted
         await checkpoint.commit();
-        this.contractsDB.commitCheckpointOkIfNone();
       }
     }
 
@@ -355,15 +372,26 @@ export class PublicProcessor implements Traceable {
     const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
     this.metrics.recordAllTxs(totalPublicGas, rate);
 
-    this.log.info(`Processed ${result.length} successful txs and ${failed.length} failed txs in ${duration}s`, {
-      duration,
-      rate,
-      totalPublicGas,
-      totalBlockGas,
-      totalSizeInBytes,
-    });
+    const silentlySkippedDurationMs = Math.round(totalSilentlySkippedDurationMs);
+    this.log.info(
+      `Processed ${result.length} successful txs and ${failed.length} failed txs ` +
+        `(${silentlySkippedCount} silently skipped, ${silentlySkippedDurationMs}ms wasted) ` +
+        `in ${duration}s`,
+      {
+        blockNumber: this.globalVariables.blockNumber,
+        successfulCount: result.length,
+        failedCount: failed.length,
+        duration,
+        rate,
+        totalPublicGas,
+        totalBlockGas,
+        totalSizeInBytes,
+        silentlySkippedCount,
+        silentlySkippedDurationMs,
+      },
+    );
 
-    return [result, failed, usedTxs, returns, totalBlobFields];
+    return [result, failed, usedTxs, returns, debugLogs];
   }
 
   private async checkWorldStateUnchanged(
@@ -383,8 +411,13 @@ export class PublicProcessor implements Traceable {
   }
 
   @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.getTxHash().toString() }))
-  private async processTx(tx: Tx, deadline: Date | undefined): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
-    const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
+  private async processTx(
+    tx: Tx,
+    deadline: Date | undefined,
+  ): Promise<[ProcessedTx, NestedProcessReturnValues[], DebugLog[]]> {
+    const [time, [processedTx, returnValues, debugLogs]] = await elapsed(() =>
+      this.processTxWithinDeadline(tx, deadline),
+    );
 
     this.log.verbose(
       !tx.hasPublicCalls()
@@ -407,7 +440,7 @@ export class PublicProcessor implements Traceable {
       },
     );
 
-    return [processedTx, returnValues ?? []];
+    return [processedTx, returnValues ?? [], debugLogs];
   }
 
   private async doTreeInsertionsForPrivateOnlyTx(processedTx: ProcessedTx): Promise<void> {
@@ -441,10 +474,9 @@ export class PublicProcessor implements Traceable {
   private async processTxWithinDeadline(
     tx: Tx,
     deadline: Date | undefined,
-  ): Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> {
-    const innerProcessFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> = tx.hasPublicCalls()
-      ? () => this.processTxWithPublicCalls(tx)
-      : () => this.processPrivateOnlyTx(tx);
+  ): Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined, DebugLog[]]> {
+    const innerProcessFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined, DebugLog[]]> =
+      tx.hasPublicCalls() ? () => this.processTxWithPublicCalls(tx) : () => this.processPrivateOnlyTx(tx);
 
     // Fake a delay per tx if instructed (used for tests)
     const fakeDelayPerTxMs = this.opts.fakeProcessingDelayPerTxMs;
@@ -512,7 +544,7 @@ export class PublicProcessor implements Traceable {
   @trackSpan('PublicProcessor.processPrivateOnlyTx', (tx: Tx) => ({
     [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
-  private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx, undefined]> {
+  private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx, undefined, DebugLog[]]> {
     const gasFees = this.globalVariables.gasFees;
     const transactionFee = computeTransactionFee(gasFees, tx.data.constants.txContext.gasSettings, tx.data.gasUsed);
 
@@ -535,15 +567,15 @@ export class PublicProcessor implements Traceable {
     // Fee payment insertion has already been done. Do the rest.
     await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
 
-    await this.contractsDB.addNewContracts(tx);
+    this.contractsDB.addNewContracts(tx);
 
-    return [processedTx, undefined];
+    return [processedTx, undefined, []];
   }
 
   @trackSpan('PublicProcessor.processTxWithPublicCalls', tx => ({
     [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
-  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[], DebugLog[]]> {
     const timer = new Timer();
 
     const result = await this.publicTxSimulator.simulate(tx);
@@ -581,7 +613,7 @@ export class PublicProcessor implements Traceable {
       revertReason,
     );
 
-    return [processedTx, appLogicReturnValues];
+    return [processedTx, appLogicReturnValues, result.logs ?? []];
   }
 
   /**

package/src/public/public_processor/public_processor_metrics.ts

@@ -30,6 +30,9 @@ export class PublicProcessorMetrics {
 
   private treeInsertionDuration: Histogram;
 
+  private silentlySkippedCount: UpDownCounter;
+  private silentlySkippedDuration: Histogram;
+
   constructor(client: TelemetryClient, name = 'PublicProcessor') {
     this.tracer = client.getTracer(name);
     const meter = client.getMeter(name);
@@ -60,6 +63,10 @@ export class PublicProcessorMetrics {
     this.gasRate = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_GAS_RATE);
 
     this.treeInsertionDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TREE_INSERTION);
+
+    this.silentlySkippedCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_SILENTLY_SKIPPED_COUNT);
+
+    this.silentlySkippedDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_SILENTLY_SKIPPED_DURATION);
   }
 
   recordPhaseDuration(phaseName: TxExecutionPhase, durationMs: number) {
@@ -123,4 +130,9 @@ export class PublicProcessorMetrics {
   recordTreeInsertions(durationUs: number) {
     this.treeInsertionDuration.record(Math.ceil(durationUs));
   }
+
+  recordSilentlySkipped(durationMs: number) {
+    this.silentlySkippedCount.add(1);
+    this.silentlySkippedDuration.record(Math.ceil(durationMs));
+  }
 }

package/src/public/public_tx_simulator/contract_provider_for_cpp.ts

@@ -52,6 +52,7 @@ export class ContractProviderForCpp implements ContractProvider {
     return serializeWithMessagePack(contractClass);
   };
 
+  // eslint-disable-next-line require-await
   public addContracts = async (contractDeploymentDataBuffer: Buffer): Promise<void> => {
     this.log.trace(`Contract provider callback: addContracts`);
 
@@ -62,7 +63,7 @@ export class ContractProviderForCpp implements ContractProvider {
 
     // Add contracts to the contracts DB
     this.log.trace(`Calling contractsDB.addContracts`);
-    await this.contractsDB.addContracts(contractDeploymentData);
+    this.contractsDB.addContracts(contractDeploymentData);
   };
 
   public getBytecodeCommitment = async (classId: string): Promise<Buffer | undefined> => {

package/src/public/public_tx_simulator/cpp_public_tx_simulator.ts

@@ -1,4 +1,4 @@
-import { type Logger, type LoggerBindings, createLogger, logLevel } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { type CancellationToken, avmSimulate, cancelSimulation, createCancellationToken } from '@aztec/native';
 import { ProtocolContractsList } from '@aztec/protocol-contracts';
@@ -100,8 +100,7 @@ export class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxS
       inputBuffer,
       contractProvider,
       wsCppHandle,
-      logLevel,
-      // TODO: re-enable logging
+      this.log.level,
       undefined,
       this.cancellationToken,
     );

package/src/public/public_tx_simulator/cpp_public_tx_simulator_with_hinted_dbs.ts

@@ -1,4 +1,4 @@
-import { type Logger, type LoggerBindings, createLogger, logLevel } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { avmSimulateWithHintedDbs } from '@aztec/native';
 import {
   AvmCircuitInputs,
@@ -75,7 +75,7 @@ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements
 
     let resultBuffer: Buffer;
     try {
-      resultBuffer = await avmSimulateWithHintedDbs(inputBuffer, logLevel);
+      resultBuffer = await avmSimulateWithHintedDbs(inputBuffer, this.log.level);
     } catch (error: any) {
       throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
     }

package/src/public/public_tx_simulator/factories.ts

@@ -19,10 +19,11 @@ export function createPublicTxSimulatorForBlockBuilding(
   globalVariables: GlobalVariables,
   telemetryClient: TelemetryClient,
   bindings?: LoggerBindings,
+  collectDebugLogs = false,
 ) {
   const config = PublicSimulatorConfig.from({
     skipFeeEnforcement: false,
-    collectDebugLogs: false,
+    collectDebugLogs,
     collectHints: false,
     collectPublicInputs: false,
     collectStatistics: false,