@aztec/simulator 0.55.1 → 0.57.0

package/src/public/public_processor.ts

@@ -3,9 +3,6 @@ import {
   NestedProcessReturnValues,
   type ProcessedTx,
   type ProcessedTxHandler,
-  PublicKernelType,
-  type PublicProvingRequest,
-  type SimulationError,
   Tx,
   type TxValidator,
   makeProcessedTx,
@@ -17,7 +14,6 @@ import {
   FEE_JUICE_ADDRESS,
   type GlobalVariables,
   type Header,
-  type KernelCircuitPublicInputs,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PublicDataUpdateRequest,
@@ -25,22 +21,16 @@ import {
 import { times } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
-import {
-  PublicExecutor,
-  type PublicStateDB,
-  type SimulationProvider,
-  computeFeePayerBalanceLeafSlot,
-  computeFeePayerBalanceStorageSlot,
-} from '@aztec/simulator';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 import { type ContractDataSource } from '@aztec/types/contracts';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { type AbstractPhaseManager } from './abstract_phase_manager.js';
-import { PhaseManagerFactory } from './phase_manager_factory.js';
-import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from './public_db_sources.js';
+import { type SimulationProvider } from '../providers/index.js';
+import { EnqueuedCallsProcessor } from './enqueued_calls_processor.js';
+import { PublicExecutor } from './executor.js';
+import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
+import { WorldStateDB } from './public_db_sources.js';
 import { RealPublicKernelCircuitSimulator } from './public_kernel.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
@@ -65,28 +55,25 @@ export class PublicProcessorFactory {
   public create(maybeHistoricalHeader: Header | undefined, globalVariables: GlobalVariables): PublicProcessor {
     const { merkleTree, telemetryClient } = this;
     const historicalHeader = maybeHistoricalHeader ?? merkleTree.getInitialHeader();
-    const publicContractsDB = new ContractsDataSourcePublicDB(this.contractDataSource);
 
-    const worldStatePublicDB = new WorldStatePublicDB(merkleTree);
-    const worldStateDB = new WorldStateDB(merkleTree);
-    const publicExecutor = new PublicExecutor(
-      worldStatePublicDB,
-      publicContractsDB,
-      worldStateDB,
-      historicalHeader,
-      telemetryClient,
-    );
-    return new PublicProcessor(
+    const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
+    const publicExecutor = new PublicExecutor(worldStateDB, telemetryClient);
+    const publicKernelSimulator = new RealPublicKernelCircuitSimulator(this.simulator);
+
+    return PublicProcessor.create(
       merkleTree,
       publicExecutor,
-      new RealPublicKernelCircuitSimulator(this.simulator),
+      publicKernelSimulator,
       globalVariables,
       historicalHeader,
-      publicContractsDB,
-      worldStatePublicDB,
+      worldStateDB,
       this.telemetryClient,
     );
   }
+
+  public getInitialHeader() {
+    return this.merkleTree.getInitialHeader();
+  }
 }
 
 /**
@@ -101,14 +88,44 @@ export class PublicProcessor {
     protected publicKernel: PublicKernelCircuitSimulator,
     protected globalVariables: GlobalVariables,
     protected historicalHeader: Header,
-    protected publicContractsDB: ContractsDataSourcePublicDB,
-    protected publicStateDB: PublicStateDB,
+    protected worldStateDB: WorldStateDB,
+    protected enqueuedCallsProcessor: EnqueuedCallsProcessor,
     telemetryClient: TelemetryClient,
     private log = createDebugLogger('aztec:sequencer:public-processor'),
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
   }
 
+  static create(
+    db: MerkleTreeOperations,
+    publicExecutor: PublicExecutor,
+    publicKernelSimulator: PublicKernelCircuitSimulator,
+    globalVariables: GlobalVariables,
+    historicalHeader: Header,
+    worldStateDB: WorldStateDB,
+    telemetryClient: TelemetryClient,
+  ) {
+    const enqueuedCallsProcessor = EnqueuedCallsProcessor.create(
+      db,
+      publicExecutor,
+      publicKernelSimulator,
+      globalVariables,
+      historicalHeader,
+      worldStateDB,
+    );
+
+    return new PublicProcessor(
+      db,
+      publicExecutor,
+      publicKernelSimulator,
+      globalVariables,
+      historicalHeader,
+      worldStateDB,
+      enqueuedCallsProcessor,
+      telemetryClient,
+    );
+  }
+
   get tracer(): Tracer {
     return this.metrics.tracer;
   }
@@ -151,7 +168,7 @@ export class PublicProcessor {
         processedTx.finalPublicDataUpdateRequests = await this.createFinalDataUpdateRequests(processedTx);
 
         // Commit the state updates from this transaction
-        await this.publicStateDB.commit();
+        await this.worldStateDB.commit();
         validateProcessedTx(processedTx);
 
         // Re-validate the transaction
@@ -217,14 +234,14 @@ export class PublicProcessor {
     const balance =
       existingBalanceWriteIndex > -1
         ? finalPublicDataUpdateRequests[existingBalanceWriteIndex].newValue
-        : await this.publicStateDB.storageRead(feeJuiceAddress, balanceSlot);
+        : 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})`);
     }
 
     const updatedBalance = balance.sub(txFee);
-    await this.publicStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
+    await this.worldStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
 
     finalPublicDataUpdateRequests[
       existingBalanceWriteIndex > -1 ? existingBalanceWriteIndex : MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
@@ -238,69 +255,31 @@ export class PublicProcessor {
   }))
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const timer = new Timer();
-    let returnValues: NestedProcessReturnValues[] = [];
-    const publicProvingRequests: PublicProvingRequest[] = [];
-    let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
-      tx,
-      this.db,
-      this.publicExecutor,
-      this.publicKernel,
-      this.globalVariables,
-      this.historicalHeader,
-      this.publicContractsDB,
-      this.publicStateDB,
-    );
-    this.log.debug(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
-    let publicKernelPublicInput = tx.data.toPublicKernelCircuitPublicInputs();
-    let lastKernelArtifact: ProtocolArtifact = 'PrivateKernelTailToPublicArtifact'; // All txs with public calls must carry tail to public proofs
-    let finalKernelOutput: KernelCircuitPublicInputs | undefined;
-    let revertReason: SimulationError | undefined;
-    const gasUsed: ProcessedTx['gasUsed'] = {};
-    let phaseCount = 0;
-    while (phase) {
-      phaseCount++;
-      const phaseTimer = new Timer();
-      const output = await phase.handle(tx, publicKernelPublicInput, lastKernelArtifact);
-
-      if (output.revertReason) {
-        this.metrics.recordRevertedPhase(phase.phase);
-      } else {
-        this.metrics.recordPhaseDuration(phase.phase, phaseTimer.ms());
-      }
 
-      gasUsed[phase.phase] = output.gasUsed;
-      if (phase.phase === PublicKernelType.APP_LOGIC) {
-        returnValues = output.returnValues;
-      }
-      publicProvingRequests.push(...output.publicProvingRequests);
-      publicKernelPublicInput = output.publicKernelOutput;
-      lastKernelArtifact = output.lastKernelArtifact;
-      finalKernelOutput = output.finalKernelOutput;
-      revertReason ??= output.revertReason;
-      phase = PhaseManagerFactory.phaseFromOutput(
-        publicKernelPublicInput,
-        phase,
-        this.db,
-        this.publicExecutor,
-        this.publicKernel,
-        this.globalVariables,
-        this.historicalHeader,
-        this.publicContractsDB,
-        this.publicStateDB,
-      );
-    }
+    const { tailKernelOutput, returnValues, revertReason, provingRequests, gasUsed, processedPhases } =
+      await this.enqueuedCallsProcessor.process(tx);
 
-    if (!finalKernelOutput) {
+    if (!tailKernelOutput) {
       this.metrics.recordFailedTx();
       throw new Error('Final public kernel was not executed.');
     }
 
+    processedPhases.forEach(phase => {
+      if (phase.revertReason) {
+        this.metrics.recordRevertedPhase(phase.phase);
+      } else {
+        this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
+      }
+    });
+
     this.metrics.recordClassRegistration(
       ...ContractClassRegisteredEvent.fromLogs(tx.unencryptedLogs.unrollLogs(), ClassRegistererAddress),
     );
 
+    const phaseCount = processedPhases.length;
     this.metrics.recordTx(phaseCount, timer.ms());
-    const processedTx = makeProcessedTx(tx, finalKernelOutput, publicProvingRequests, revertReason, gasUsed);
+
+    const processedTx = makeProcessedTx(tx, tailKernelOutput, provingRequests, revertReason, gasUsed);
     return [processedTx, returnValues];
   }
 }

package/src/public/public_processor_metrics.ts

@@ -1,4 +1,4 @@
-import { type PublicKernelType } from '@aztec/circuit-types';
+import { type PublicKernelPhase } from '@aztec/circuit-types';
 import { type ContractClassRegisteredEvent } from '@aztec/circuits.js';
 import {
   Attributes,
@@ -56,7 +56,7 @@ export class PublicProcessorMetrics {
     });
   }
 
-  recordPhaseDuration(phaseName: PublicKernelType, durationMs: number) {
+  recordPhaseDuration(phaseName: PublicKernelPhase, durationMs: number) {
     this.phaseCount.add(1, { [Attributes.TX_PHASE_NAME]: phaseName, [Attributes.OK]: true });
     this.phaseDuration.record(Math.ceil(durationMs), { [Attributes.TX_PHASE_NAME]: phaseName });
   }
@@ -75,7 +75,7 @@ export class PublicProcessorMetrics {
     });
   }
 
-  recordRevertedPhase(phaseName: PublicKernelType) {
+  recordRevertedPhase(phaseName: PublicKernelPhase) {
     this.phaseCount.add(1, { [Attributes.TX_PHASE_NAME]: phaseName, [Attributes.OK]: false });
   }
 

package/src/public/side_effect_errors.ts

@@ -0,0 +1,6 @@
+export class SideEffectLimitReachedError extends Error {
+  constructor(sideEffectType: string, limit: number) {
+    super(`Reached the limit on number of '${sideEffectType}' side effects: ${limit}`);
+    this.name = 'SideEffectLimitReachedError';
+  }
+}

package/src/public/side_effect_trace.ts

@@ -12,9 +12,19 @@ import {
   Gas,
   L2ToL1Message,
   LogHash,
+  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX,
+  MAX_L2_TO_L1_MSGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  MAX_PUBLIC_DATA_READS_PER_TX,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_UNENCRYPTED_LOGS_PER_TX,
   NoteHash,
   Nullifier,
-  type PublicCallRequest,
+  type PublicInnerCallRequest,
   ReadRequest,
   TreeLeafReadRequest,
 } from '@aztec/circuits.js';
@@ -26,6 +36,7 @@ import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import { createSimulationError } from '../common/errors.js';
 import { type PublicExecutionResult, resultToPublicCallRequest } from './execution.js';
+import { SideEffectLimitReachedError } from './side_effect_errors.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
 export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
@@ -53,9 +64,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   private allUnencryptedLogs: UnencryptedL2Log[] = [];
   private unencryptedLogsHashes: LogHash[] = [];
 
-  private publicCallRequests: PublicCallRequest[] = [];
-
-  private gotContractInstances: ContractInstanceWithAddress[] = [];
+  private publicCallRequests: PublicInnerCallRequest[] = [];
 
   private nestedExecutions: PublicExecutionResult[] = [];
 
@@ -81,10 +90,13 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.sideEffectCounter++;
   }
 
+  // TODO(dbanks12): checks against tx-wide limit need access to parent trace's length
+
   public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, _exists: boolean, _cached: boolean) {
-    // TODO(4805): check if some threshold is reached for max storage reads
-    // (need access to parent length, or trace needs to be initialized with parent's contents)
     // NOTE: exists and cached are unused for now but may be used for optimizations or kernel hints later
+    if (this.contractStorageReads.length >= MAX_PUBLIC_DATA_READS_PER_TX) {
+      throw new SideEffectLimitReachedError('contract storage read', MAX_PUBLIC_DATA_READS_PER_TX);
+    }
     this.contractStorageReads.push(
       new ContractStorageRead(slot, value, this.sideEffectCounter, AztecAddress.fromField(storageAddress)),
     );
@@ -96,8 +108,9 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
-    // TODO(4805): check if some threshold is reached for max storage writes
-    // (need access to parent length, or trace needs to be initialized with parent's contents)
+    if (this.contractStorageUpdateRequests.length >= MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX) {
+      throw new SideEffectLimitReachedError('contract storage write', MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
+    }
     this.contractStorageUpdateRequests.push(
       new ContractStorageUpdateRequest(slot, value, this.sideEffectCounter, storageAddress),
     );
@@ -107,32 +120,32 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
 
   // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
   public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
-    // TODO(4805): check if some threshold is reached for max note hash checks
     // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
-    // TODO(dbanks12): leafIndex is unused for now but later must be used by kernel to constrain that the kernel
-    // is in fact checking the leaf indicated by the user
+    if (this.noteHashReadRequests.length >= MAX_NOTE_HASH_READ_REQUESTS_PER_TX) {
+      throw new SideEffectLimitReachedError('note hash read request', MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+    }
     this.noteHashReadRequests.push(new TreeLeafReadRequest(noteHash, leafIndex));
     this.avmCircuitHints.noteHashExists.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(leafIndex), /*value=*/ exists ? Fr.ONE : Fr.ZERO),
     );
+    // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
   }
 
   public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
-    // TODO(4805): check if some threshold is reached for max new note hash
-    // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
-    // TODO(dbanks12): non-existent note hashes should emit a read request of the note hash that actually
-    // IS there, and the AVM circuit should accept THAT noteHash as a hint. The circuit will then compare
-    // the noteHash against the one provided by the user code to determine what to return to the user (exists or not),
-    // and will then propagate the actually-present noteHash to its public inputs.
+    if (this.noteHashes.length >= MAX_NOTE_HASHES_PER_TX) {
+      throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
+    }
     this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
     this.logger.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
   public traceNullifierCheck(_storageAddress: Fr, nullifier: Fr, _leafIndex: Fr, exists: boolean, _isPending: boolean) {
-    // TODO(4805): check if some threshold is reached for max new nullifier
     // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
     // NOTE: isPending and leafIndex are unused for now but may be used for optimizations or kernel hints later
+
+    this.enforceLimitOnNullifierChecks();
+
     const readRequest = new ReadRequest(nullifier, this.sideEffectCounter);
     if (exists) {
       this.nullifierReadRequests.push(readRequest);
@@ -147,8 +160,10 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
-    // TODO(4805): check if some threshold is reached for max new nullifier
     // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
+    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.logger.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
@@ -156,18 +171,21 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
 
   // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
   public traceL1ToL2MessageCheck(_contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean) {
-    // TODO(4805): check if some threshold is reached for max message reads
     // NOTE: contractAddress is unused but will be important when an AVM circuit processes an entire enqueued call
-    // TODO(dbanks12): leafIndex is unused for now but later must be used by kernel to constrain that the kernel
-    // is in fact checking the leaf indicated by the user
+    if (this.l1ToL2MsgReadRequests.length >= MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX) {
+      throw new SideEffectLimitReachedError('l1 to l2 message read request', MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX);
+    }
     this.l1ToL2MsgReadRequests.push(new TreeLeafReadRequest(msgHash, msgLeafIndex));
     this.avmCircuitHints.l1ToL2MessageExists.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(msgLeafIndex), /*value=*/ exists ? Fr.ONE : Fr.ZERO),
     );
+    // NOTE: counter does not increment for l1tol2 message checks (because it doesn't rely on pending messages)
   }
 
-  public traceNewL2ToL1Message(recipient: Fr, content: Fr) {
-    // TODO(4805): check if some threshold is reached for max messages
+  public traceNewL2ToL1Message(_contractAddress: Fr, recipient: Fr, content: Fr) {
+    if (this.newL2ToL1Messages.length >= MAX_L2_TO_L1_MSGS_PER_TX) {
+      throw new SideEffectLimitReachedError('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+    }
     const recipientAddress = EthAddress.fromField(recipient);
     this.newL2ToL1Messages.push(new L2ToL1Message(recipientAddress, content, this.sideEffectCounter));
     this.logger.debug(`NEW_L2_TO_L1_MSG cnt: ${this.sideEffectCounter}`);
@@ -175,7 +193,9 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public traceUnencryptedLog(contractAddress: Fr, log: Fr[]) {
-    // TODO(4805): check if some threshold is reached for max logs
+    if (this.unencryptedLogs.length >= MAX_UNENCRYPTED_LOGS_PER_TX) {
+      throw new SideEffectLimitReachedError('unencrypted log', MAX_UNENCRYPTED_LOGS_PER_TX);
+    }
     const ulog = new UnencryptedL2Log(
       AztecAddress.fromField(contractAddress),
       Buffer.concat(log.map(f => f.toBuffer())),
@@ -183,18 +203,17 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     const basicLogHash = Fr.fromBuffer(ulog.hash());
     this.unencryptedLogs.push(ulog);
     this.allUnencryptedLogs.push(ulog);
-    // We want the length of the buffer output from function_l2_logs -> toBuffer to equal the stored log length in the kernels.
-    // The kernels store the length of the processed log as 4 bytes; thus for this length value to match the log length stored in the kernels,
-    // we need to add four to the length here.
-    // https://github.com/AztecProtocol/aztec-packages/issues/6578#issuecomment-2125003435
+    // This length is for charging DA and is checked on-chain - has to be length of log preimage + 4 bytes.
+    // The .length call also has a +4 but that is unrelated
     this.unencryptedLogsHashes.push(new LogHash(basicLogHash, this.sideEffectCounter, new Fr(ulog.length + 4)));
     this.logger.debug(`NEW_UNENCRYPTED_LOG cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
   public traceGetContractInstance(instance: TracedContractInstance) {
-    // TODO(4805): check if some threshold is reached for max contract instance retrievals
-    this.gotContractInstances.push(instance);
+    this.enforceLimitOnNullifierChecks('(contract address nullifier from GETCONTRACTINSTANCE)');
+    // TODO(dbanks12): should emit a nullifier read request
+
     this.avmCircuitHints.contractInstances.items.push(
       new AvmContractInstanceHint(
         instance.address,
@@ -230,6 +249,11 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     /** Function name for logging */
     functionName: string = 'unknown',
   ) {
+    // TODO(4805): check if some threshold is reached for max nested calls (to unique contracts?)
+    // TODO(dbanks12): should emit a nullifier read request. There should be two thresholds.
+    // one for max unique contract calls, and another based on max nullifier reads.
+    // Since this trace function happens _after_ a nested call, such threshold limits must take
+    // place in another trace function that occurs _before_ a nested call.
     const result = nestedCallTrace.toPublicExecutionResult(
       nestedEnvironment,
       startGasLeft,
@@ -307,8 +331,6 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       unencryptedLogs: new UnencryptedFunctionL2Logs(this.unencryptedLogs),
       allUnencryptedLogs: new UnencryptedFunctionL2Logs(this.allUnencryptedLogs),
       unencryptedLogsHashes: this.unencryptedLogsHashes,
-      // TODO(dbanks12): process contract instance read requests in public kernel
-      //gotContractInstances: this.gotContractInstances,
 
       publicCallRequests: this.publicCallRequests,
       nestedExecutions: this.nestedExecutions,
@@ -318,6 +340,27 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       functionName,
     };
   }
+
+  private enforceLimitOnNullifierChecks(errorMsgOrigin: string = '') {
+    // NOTE: Why error if _either_ limit was reached? If user code emits either an existent or non-existent
+    // nullifier read request (NULLIFIEREXISTS, GETCONTRACTINSTANCE, *CALL), and one of the limits has been
+    // reached (MAX_NULLIFIER_NON_EXISTENT_RRS vs MAX_NULLIFIER_RRS), but not the other, we must prevent the
+    // sequencer from lying and saying "this nullifier exists, but MAX_NULLIFIER_RRS has been reached, so I'm
+    // going to skip the read request and just revert instead" when the nullifier actually doesn't exist
+    // (or vice versa). So, if either maximum has been reached, any nullifier-reading operation must error.
+    if (this.nullifierReadRequests.length >= MAX_NULLIFIER_READ_REQUESTS_PER_TX) {
+      throw new SideEffectLimitReachedError(
+        `nullifier read request ${errorMsgOrigin}`,
+        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+      );
+    }
+    if (this.nullifierNonExistentReadRequests.length >= MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX) {
+      throw new SideEffectLimitReachedError(
+        `nullifier non-existent read request ${errorMsgOrigin}`,
+        MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
+      );
+    }
+  }
 }
 
 /**
@@ -331,10 +374,5 @@ function createPublicExecutionRequest(avmEnvironment: AvmExecutionEnvironment):
     isDelegateCall: avmEnvironment.isDelegateCall,
     isStaticCall: avmEnvironment.isStaticCall,
   });
-  return new PublicExecutionRequest(
-    avmEnvironment.address,
-    callContext,
-    // execution request does not contain AvmContextInputs prefix
-    avmEnvironment.getCalldataWithoutPrefix(),
-  );
+  return new PublicExecutionRequest(avmEnvironment.address, callContext, avmEnvironment.calldata);
 }

package/src/public/side_effect_trace_interface.ts

@@ -8,6 +8,7 @@ import { type TracedContractInstance } from './side_effect_trace.js';
 export interface PublicSideEffectTraceInterface {
   fork(): PublicSideEffectTraceInterface;
   getCounter(): number;
+  // all "trace*" functions can throw SideEffectLimitReachedError
   tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean): void;
   tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr): void;
   traceNoteHashCheck(storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean): void;
@@ -15,8 +16,7 @@ export interface PublicSideEffectTraceInterface {
   traceNullifierCheck(storageAddress: Fr, nullifier: Fr, leafIndex: Fr, exists: boolean, isPending: boolean): void;
   traceNewNullifier(storageAddress: Fr, nullifier: Fr): void;
   traceL1ToL2MessageCheck(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean): void;
-  // TODO(dbanks12): should new message accept contract address as arg?
-  traceNewL2ToL1Message(recipient: Fr, content: Fr): void;
+  traceNewL2ToL1Message(contractAddress: Fr, recipient: Fr, content: Fr): void;
   traceUnencryptedLog(contractAddress: Fr, log: Fr[]): void;
   // TODO(dbanks12): odd that getContractInstance is a one-off in that it accepts an entire object instead of components
   traceGetContractInstance(instance: TracedContractInstance): void;

package/dest/avm/journal/host_storage.d.ts

@@ -1,13 +0,0 @@
-import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../../public/db_interfaces.js';
-/**
- * Host storage
- *
- * A wrapper around the node dbs
- */
-export declare class HostStorage {
-    readonly publicStateDb: PublicStateDB;
-    readonly contractsDb: PublicContractsDB;
-    readonly commitmentsDb: CommitmentsDB;
-    constructor(publicStateDb: PublicStateDB, contractsDb: PublicContractsDB, commitmentsDb: CommitmentsDB);
-}
-//# sourceMappingURL=host_storage.d.ts.map

package/dest/avm/journal/host_storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"host_storage.d.ts","sourceRoot":"","sources":["../../../src/avm/journal/host_storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE/G;;;;GAIG;AACH,qBAAa,WAAW;aAEJ,aAAa,EAAE,aAAa;aAC5B,WAAW,EAAE,iBAAiB;aAC9B,aAAa,EAAE,aAAa;gBAF5B,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,iBAAiB,EAC9B,aAAa,EAAE,aAAa;CAE/C"}

package/dest/avm/journal/host_storage.js

@@ -1,13 +0,0 @@
-/**
- * Host storage
- *
- * A wrapper around the node dbs
- */
-export class HostStorage {
-    constructor(publicStateDb, contractsDb, commitmentsDb) {
-        this.publicStateDb = publicStateDb;
-        this.contractsDb = contractsDb;
-        this.commitmentsDb = commitmentsDb;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9zdF9zdG9yYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F2bS9qb3VybmFsL2hvc3Rfc3RvcmFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLFdBQVc7SUFDdEIsWUFDa0IsYUFBNEIsRUFDNUIsV0FBOEIsRUFDOUIsYUFBNEI7UUFGNUIsa0JBQWEsR0FBYixhQUFhLENBQWU7UUFDNUIsZ0JBQVcsR0FBWCxXQUFXLENBQW1CO1FBQzlCLGtCQUFhLEdBQWIsYUFBYSxDQUFlO0lBQzNDLENBQUM7Q0FDTCJ9

package/dest/avm/opcodes/context_getters.d.ts

@@ -1,15 +0,0 @@
-import type { AvmContext } from '../avm_context.js';
-import { type MemoryValue } from '../avm_memory_types.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
-import { GetterInstruction } from './instruction_impl.js';
-export declare class L2GasLeft extends GetterInstruction {
-    static type: string;
-    static readonly opcode: Opcode;
-    protected getValue(context: AvmContext): MemoryValue;
-}
-export declare class DAGasLeft extends GetterInstruction {
-    static type: string;
-    static readonly opcode: Opcode;
-    protected getValue(context: AvmContext): MemoryValue;
-}
-//# sourceMappingURL=context_getters.d.ts.map

package/dest/avm/opcodes/context_getters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context_getters.d.ts","sourceRoot":"","sources":["../../../src/avm/opcodes/context_getters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAS,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,+CAA+C,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,qBAAa,SAAU,SAAQ,iBAAiB;IAC9C,MAAM,CAAC,IAAI,EAAE,MAAM,CAAe;IAClC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAoB;IAGlD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,WAAW;CAGrD;AAED,qBAAa,SAAU,SAAQ,iBAAiB;IAC9C,MAAM,CAAC,IAAI,EAAE,MAAM,CAAe;IAClC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAoB;IAElD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,WAAW;CAGrD"}

package/dest/avm/opcodes/context_getters.js

@@ -1,19 +0,0 @@
-import { Field } from '../avm_memory_types.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
-import { GetterInstruction } from './instruction_impl.js';
-export class L2GasLeft extends GetterInstruction {
-    // TODO(@spalladino) Protocol specs specifies that the value should be an Uint32, not a Field.
-    getValue(context) {
-        return new Field(context.machineState.l2GasLeft);
-    }
-}
-L2GasLeft.type = 'L2GASLEFT';
-L2GasLeft.opcode = Opcode.L2GASLEFT;
-export class DAGasLeft extends GetterInstruction {
-    getValue(context) {
-        return new Field(context.machineState.daGasLeft);
-    }
-}
-DAGasLeft.type = 'DAGASLEFT';
-DAGasLeft.opcode = Opcode.DAGASLEFT;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dF9nZXR0ZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F2bS9vcGNvZGVzL2NvbnRleHRfZ2V0dGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsS0FBSyxFQUFvQixNQUFNLHdCQUF3QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUN2RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUUxRCxNQUFNLE9BQU8sU0FBVSxTQUFRLGlCQUFpQjtJQUk5Qyw4RkFBOEY7SUFDcEYsUUFBUSxDQUFDLE9BQW1CO1FBQ3BDLE9BQU8sSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNuRCxDQUFDOztBQU5NLGNBQUksR0FBVyxXQUFXLENBQUM7QUFDbEIsZ0JBQU0sR0FBVyxNQUFNLENBQUMsU0FBUyxDQUFDO0FBUXBELE1BQU0sT0FBTyxTQUFVLFNBQVEsaUJBQWlCO0lBSXBDLFFBQVEsQ0FBQyxPQUFtQjtRQUNwQyxPQUFPLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDbkQsQ0FBQzs7QUFMTSxjQUFJLEdBQVcsV0FBVyxDQUFDO0FBQ2xCLGdCQUFNLEdBQVcsTUFBTSxDQUFDLFNBQVMsQ0FBQyJ9