@aztec/sequencer-client 0.27.1 → 0.28.0

package/src/block_builder/solo_block_builder.ts

@@ -4,6 +4,7 @@ import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
   BaseOrMergeRollupPublicInputs,
+  BaseParityInputs,
   BaseRollupInputs,
   ConstantRollupData,
   GlobalVariables,
@@ -20,6 +21,7 @@ import {
   NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  NUM_BASE_PARITY_PER_ROOT_PARITY,
   NullifierLeafPreimage,
   PUBLIC_DATA_SUBTREE_HEIGHT,
   PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH,
@@ -33,6 +35,8 @@ import {
   RollupKernelCircuitPublicInputs,
   RollupKernelData,
   RollupTypes,
+  RootParityInput,
+  RootParityInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
   StateDiffHints,
@@ -85,6 +89,7 @@ export class SoloBlockBuilder implements BlockBuilder {
    * Builds an L2 block with the given number containing the given txs, updating state trees.
    * @param globalVariables - Global variables to be used in the block.
    * @param txs - Processed transactions to include in the block.
+   * @param newModelL1ToL2Messages - L1 to L2 messages emitted by the new inbox.
    * @param newL1ToL2Messages - L1 to L2 messages to be part of the block.
    * @param timestamp - Timestamp of the block.
    * @returns The new L2 block and a correctness proof as returned by the root rollup circuit.
@@ -92,13 +97,19 @@ export class SoloBlockBuilder implements BlockBuilder {
   public async buildL2Block(
     globalVariables: GlobalVariables,
     txs: ProcessedTx[],
+    newModelL1ToL2Messages: Fr[], // TODO(#4492): Rename this when purging the old inbox
     newL1ToL2Messages: Fr[],
   ): Promise<[L2Block, Proof]> {
     // Check txs are good for processing by checking if all the tree snapshots in header are non-empty
     this.validateTxs(txs);
 
     // We fill the tx batch with empty txs, we process only one tx at a time for now
-    const [circuitsOutput, proof] = await this.runCircuits(globalVariables, txs, newL1ToL2Messages);
+    const [circuitsOutput, proof] = await this.runCircuits(
+      globalVariables,
+      txs,
+      newModelL1ToL2Messages,
+      newL1ToL2Messages,
+    );
 
     // Collect all new nullifiers, commitments, and contracts from all txs in this block
     const txEffects: TxEffect[] = txs.map(tx => toTxEffect(tx));
@@ -149,7 +160,8 @@ export class SoloBlockBuilder implements BlockBuilder {
   protected async runCircuits(
     globalVariables: GlobalVariables,
     txs: ProcessedTx[],
-    newL1ToL2Messages: Fr[],
+    newModelL1ToL2Messages: Fr[], // TODO(#4492): Rename this when purging the old inbox
+    newL1ToL2Messages: Fr[], // TODO(#4492): Nuke this when purging the old inbox
   ): Promise<[RootRollupPublicInputs, Proof]> {
     // Check that the length of the array of txs is a power of two
     // See https://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
@@ -157,71 +169,154 @@ export class SoloBlockBuilder implements BlockBuilder {
       throw new Error(`Length of txs for the block should be a power of two and at least two (got ${txs.length})`);
     }
 
+    // BASE PARITY CIRCUIT (run in parallel)
+    let baseParityInputs: BaseParityInputs[] = [];
+    let elapsedBaseParityOutputsPromise: Promise<[number, RootParityInput[]]>;
+    {
+      const newModelL1ToL2MessagesTuple = padArrayEnd(
+        newModelL1ToL2Messages,
+        Fr.ZERO,
+        NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+      );
+      baseParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, (_, i) =>
+        BaseParityInputs.fromSlice(newModelL1ToL2MessagesTuple, i),
+      );
+
+      const baseParityOutputs: Promise<RootParityInput>[] = [];
+      for (const inputs of baseParityInputs) {
+        baseParityOutputs.push(this.baseParityCircuit(inputs));
+      }
+      elapsedBaseParityOutputsPromise = elapsed(() => Promise.all(baseParityOutputs));
+    }
+
     // padArrayEnd throws if the array is already full. Otherwise it pads till we reach the required size
     const newL1ToL2MessagesTuple = padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
 
-    // Perform all tree insertions and retrieve snapshots for all base rollups
+    // BASE ROLLUP CIRCUIT (run in parallel)
+    let elapsedBaseRollupOutputsPromise: Promise<[number, [BaseOrMergeRollupPublicInputs, Proof][]]>;
     const baseRollupInputs: BaseRollupInputs[] = [];
-    const treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>[] = [];
-    for (const tx of txs) {
-      const input = await this.buildBaseRollupInput(tx, globalVariables);
-      baseRollupInputs.push(input);
-      const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(
-        async (id: MerkleTreeId) => {
-          return { key: id, value: await this.getTreeSnapshot(id) };
-        },
-      );
-      const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
-        (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
-      );
-      treeSnapshots.push(snapshots);
-    }
+    {
+      // Perform all tree insertions and retrieve snapshots for all base rollups
+      const treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>[] = [];
+      for (const tx of txs) {
+        const input = await this.buildBaseRollupInput(tx, globalVariables);
+        baseRollupInputs.push(input);
+        const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(
+          async (id: MerkleTreeId) => {
+            return { key: id, value: await this.getTreeSnapshot(id) };
+          },
+        );
+        const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
+          (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
+        );
+        treeSnapshots.push(snapshots);
+      }
 
-    // Run the base rollup circuits for the txs in parallel
-    const baseRollupOutputs: Promise<[BaseOrMergeRollupPublicInputs, Proof]>[] = [];
-    for (let i = 0; i < txs.length; i++) {
-      baseRollupOutputs.push(this.baseRollupCircuit(txs[i], baseRollupInputs[i], treeSnapshots[i]));
-    }
+      // Run the base rollup circuits for the txs in parallel
+      const baseRollupOutputs: Promise<[BaseOrMergeRollupPublicInputs, Proof]>[] = [];
+      for (let i = 0; i < txs.length; i++) {
+        baseRollupOutputs.push(this.baseRollupCircuit(txs[i], baseRollupInputs[i], treeSnapshots[i]));
+      }
 
-    // Run merge rollups in layers until we have only two outputs
-    // All merge circuits for each layer are simulated in parallel
-    const [duration, mergeInputs] = await elapsed(() => Promise.all(baseRollupOutputs));
-    for (let i = 0; i < mergeInputs.length; i++) {
-      this.debug(`Simulated base rollup circuit`, {
-        eventName: 'circuit-simulation',
-        circuitName: 'base-rollup',
-        duration: duration / mergeInputs.length,
-        inputSize: baseRollupInputs[i].toBuffer().length,
-        outputSize: mergeInputs[i][0].toBuffer().length,
-      } satisfies CircuitSimulationStats);
+      elapsedBaseRollupOutputsPromise = elapsed(() => Promise.all(baseRollupOutputs));
     }
-    let mergeRollupInputs: [BaseOrMergeRollupPublicInputs, Proof][] = mergeInputs;
-    while (mergeRollupInputs.length > 2) {
-      const mergeInputStructs: MergeRollupInputs[] = [];
-      for (const pair of chunk(mergeRollupInputs, 2)) {
-        const [r1, r2] = pair;
-        mergeInputStructs.push(this.createMergeRollupInputs(r1, r2));
+
+    // ROOT PARITY CIRCUIT
+    let elapsedRootParityOutputPromise: Promise<[number, RootParityInput]>;
+    let rootParityInputs: RootParityInputs;
+    {
+      // First we await the base parity outputs
+      const [duration, baseParityOutputs] = await elapsedBaseParityOutputsPromise;
+
+      // We emit stats for base parity circuits
+      for (let i = 0; i < baseParityOutputs.length; i++) {
+        this.debug(`Simulated base parity circuit`, {
+          eventName: 'circuit-simulation',
+          circuitName: 'base-parity',
+          duration: duration / baseParityOutputs.length,
+          inputSize: baseParityInputs[i].toBuffer().length,
+          outputSize: baseParityOutputs[i].toBuffer().length,
+        } satisfies CircuitSimulationStats);
       }
 
-      const [duration, mergeOutputs] = await elapsed(() =>
-        Promise.all(mergeInputStructs.map(async input => await this.mergeRollupCircuit(input))),
+      rootParityInputs = new RootParityInputs(
+        baseParityOutputs as Tuple<RootParityInput, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
       );
+      elapsedRootParityOutputPromise = elapsed(() => this.rootParityCircuit(rootParityInputs));
+    }
+
+    // MERGE ROLLUP CIRCUIT (each layer run in parallel)
+    let mergeOutputLeft: [BaseOrMergeRollupPublicInputs, Proof];
+    let mergeOutputRight: [BaseOrMergeRollupPublicInputs, Proof];
+    {
+      // Run merge rollups in layers until we have only two outputs
+      const [duration, mergeInputs] = await elapsedBaseRollupOutputsPromise;
 
-      for (let i = 0; i < mergeOutputs.length; i++) {
-        this.debug(`Simulated merge rollup circuit`, {
+      // We emit stats for base rollup circuits
+      for (let i = 0; i < mergeInputs.length; i++) {
+        this.debug(`Simulated base rollup circuit`, {
           eventName: 'circuit-simulation',
-          circuitName: 'merge-rollup',
-          duration: duration / mergeOutputs.length,
-          inputSize: mergeInputStructs[i].toBuffer().length,
-          outputSize: mergeOutputs[i][0].toBuffer().length,
+          circuitName: 'base-rollup',
+          duration: duration / mergeInputs.length,
+          inputSize: baseRollupInputs[i].toBuffer().length,
+          outputSize: mergeInputs[i][0].toBuffer().length,
         } satisfies CircuitSimulationStats);
       }
-      mergeRollupInputs = mergeOutputs;
+
+      let mergeRollupInputs: [BaseOrMergeRollupPublicInputs, Proof][] = mergeInputs;
+      while (mergeRollupInputs.length > 2) {
+        const mergeInputStructs: MergeRollupInputs[] = [];
+        for (const pair of chunk(mergeRollupInputs, 2)) {
+          const [r1, r2] = pair;
+          mergeInputStructs.push(this.createMergeRollupInputs(r1, r2));
+        }
+
+        const [duration, mergeOutputs] = await elapsed(() =>
+          Promise.all(mergeInputStructs.map(async input => await this.mergeRollupCircuit(input))),
+        );
+
+        // We emit stats for merge rollup circuits
+        for (let i = 0; i < mergeOutputs.length; i++) {
+          this.debug(`Simulated merge rollup circuit`, {
+            eventName: 'circuit-simulation',
+            circuitName: 'merge-rollup',
+            duration: duration / mergeOutputs.length,
+            inputSize: mergeInputStructs[i].toBuffer().length,
+            outputSize: mergeOutputs[i][0].toBuffer().length,
+          } satisfies CircuitSimulationStats);
+        }
+        mergeRollupInputs = mergeOutputs;
+      }
+
+      // Run the root rollup with the last two merge rollups (or base, if no merge layers)
+      [mergeOutputLeft, mergeOutputRight] = mergeRollupInputs;
     }
 
-    // Run the root rollup with the last two merge rollups (or base, if no merge layers)
-    const [mergeOutputLeft, mergeOutputRight] = mergeRollupInputs;
-    return this.rootRollupCircuit(mergeOutputLeft, mergeOutputRight, newL1ToL2MessagesTuple);
+    // Finally, we emit stats for root parity circuit
+    const [duration, rootParityOutput] = await elapsedRootParityOutputPromise;
+    this.debug(`Simulated root parity circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'root-parity',
+      duration: duration,
+      inputSize: rootParityInputs.toBuffer().length,
+      outputSize: rootParityOutput.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+
+    return this.rootRollupCircuit(mergeOutputLeft, mergeOutputRight, rootParityOutput, newL1ToL2MessagesTuple);
+  }
+
+  protected async baseParityCircuit(inputs: BaseParityInputs): Promise<RootParityInput> {
+    this.debug(`Running base parity circuit`);
+    const parityPublicInputs = await this.simulator.baseParityCircuit(inputs);
+    const proof = await this.prover.getBaseParityProof(inputs, parityPublicInputs);
+    return new RootParityInput(proof, parityPublicInputs);
+  }
+
+  protected async rootParityCircuit(inputs: RootParityInputs): Promise<RootParityInput> {
+    this.debug(`Running root parity circuit`);
+    const parityPublicInputs = await this.simulator.rootParityCircuit(inputs);
+    const proof = await this.prover.getRootParityProof(inputs, parityPublicInputs);
+    return new RootParityInput(proof, parityPublicInputs);
   }
 
   protected async baseRollupCircuit(
@@ -269,10 +364,11 @@ export class SoloBlockBuilder implements BlockBuilder {
   protected async rootRollupCircuit(
     left: [BaseOrMergeRollupPublicInputs, Proof],
     right: [BaseOrMergeRollupPublicInputs, Proof],
+    l1ToL2Roots: RootParityInput,
     newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
   ): Promise<[RootRollupPublicInputs, Proof]> {
     this.debug(`Running root rollup circuit`);
-    const rootInput = await this.getRootRollupInput(...left, ...right, newL1ToL2Messages);
+    const rootInput = await this.getRootRollupInput(...left, ...right, l1ToL2Roots, newL1ToL2Messages);
 
     // Update the local trees to include the new l1 to l2 messages
     await this.db.appendLeaves(
@@ -365,6 +461,7 @@ export class SoloBlockBuilder implements BlockBuilder {
     rollupProofLeft: Proof,
     rollupOutputRight: BaseOrMergeRollupPublicInputs,
     rollupProofRight: Proof,
+    l1ToL2Roots: RootParityInput,
     newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
   ) {
     const vk = this.getVerificationKey(rollupOutputLeft.rollupType);
@@ -406,6 +503,7 @@ export class SoloBlockBuilder implements BlockBuilder {
 
     return RootRollupInputs.from({
       previousRollupData,
+      l1ToL2Roots,
       newL1ToL2Messages,
       newL1ToL2MessageTreeRootSiblingPath,
       startL1ToL2MessageTreeSnapshot,

package/src/prover/empty.ts

@@ -2,11 +2,14 @@
 import {
   AggregationObject,
   BaseOrMergeRollupPublicInputs,
+  BaseParityInputs,
   BaseRollupInputs,
   MergeRollupInputs,
+  ParityPublicInputs,
   Proof,
   PublicCircuitPublicInputs,
   PublicKernelCircuitPublicInputs,
+  RootParityInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
@@ -22,6 +25,26 @@ const EMPTY_PROOF_SIZE = 42;
  * Prover implementation that returns empty proofs and overrides aggregation objects.
  */
 export class EmptyRollupProver implements RollupProver {
+  /**
+   * Creates an empty proof for the given input.
+   * @param inputs - Inputs to the circuit.
+   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
+   */
+  async getBaseParityProof(inputs: BaseParityInputs, publicInputs: ParityPublicInputs): Promise<Proof> {
+    publicInputs.aggregationObject = AggregationObject.makeFake();
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+
+  /**
+   * Creates an empty proof for the given input.
+   * @param inputs - Inputs to the circuit.
+   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
+   */
+  async getRootParityProof(inputs: RootParityInputs, publicInputs: ParityPublicInputs): Promise<Proof> {
+    publicInputs.aggregationObject = AggregationObject.makeFake();
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+
   /**
    * Creates an empty proof for the given input.
    * @param _input - Input to the circuit.

package/src/prover/index.ts

@@ -1,18 +1,35 @@
 import {
   BaseOrMergeRollupPublicInputs,
+  BaseParityInputs,
   BaseRollupInputs,
   MergeRollupInputs,
+  ParityPublicInputs,
   Proof,
   PublicCircuitPublicInputs,
   PublicKernelCircuitPublicInputs,
+  RootParityInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
 
 /**
- * Generates proofs for the base, merge, and root rollup circuits.
+ * Generates proofs for parity and rollup circuits.
  */
 export interface RollupProver {
+  /**
+   * Creates a proof for the given input.
+   * @param input - Input to the circuit.
+   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
+   */
+  getBaseParityProof(inputs: BaseParityInputs, publicInputs: ParityPublicInputs): Promise<Proof>;
+
+  /**
+   * Creates a proof for the given input.
+   * @param input - Input to the circuit.
+   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
+   */
+  getRootParityProof(inputs: RootParityInputs, publicInputs: ParityPublicInputs): Promise<Proof>;
+
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.

package/src/sequencer/abstract_phase_manager.ts

@@ -59,7 +59,7 @@ import { getVerificationKeys } from '../mocks/verification_keys.js';
 import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { HintsBuilder } from './hints_builder.js';
-import { FailedTx } from './processed_tx.js';
+import { lastSideEffectCounter } from './utils.js';
 
 export enum PublicKernelPhase {
   SETUP = 'setup',
@@ -114,7 +114,6 @@ export abstract class AbstractPhaseManager {
      */
     revertReason: SimulationError | undefined;
   }>;
-  abstract rollback(tx: Tx, err: unknown): Promise<FailedTx>;
 
   public static extractEnqueuedPublicCallsByPhase(
     publicInputs: PrivateKernelTailCircuitPublicInputs,
@@ -154,6 +153,14 @@ export abstract class AbstractPhaseManager {
         [PublicKernelPhase.TEARDOWN]: [],
         [PublicKernelPhase.TAIL]: [],
       };
+    } else if (firstRevertibleCallIndex === -1) {
+      // there's no app logic, split the functions between setup (many) and teardown (just one function call)
+      return {
+        [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, -1),
+        [PublicKernelPhase.APP_LOGIC]: [],
+        [PublicKernelPhase.TEARDOWN]: [publicCallsStack[publicCallsStack.length - 1]],
+        [PublicKernelPhase.TAIL]: [],
+      };
     } else {
       return {
         [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex - 1),
@@ -202,16 +209,27 @@ export abstract class AbstractPhaseManager {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
 
+        const sideEffectCounter = lastSideEffectCounter(tx) + 1;
         // NOTE: temporary glue to incorporate avm execution calls
         const simulator = (execution: PublicExecution, globalVariables: GlobalVariables) =>
           env.AVM_ENABLED
-            ? this.publicExecutor.simulateAvm(execution, globalVariables)
-            : this.publicExecutor.simulate(execution, globalVariables);
+            ? this.publicExecutor.simulateAvm(execution, globalVariables, sideEffectCounter)
+            : this.publicExecutor.simulate(execution, globalVariables, sideEffectCounter);
 
         const result = isExecutionRequest ? await simulator(current, this.globalVariables) : current;
 
-        newUnencryptedFunctionLogs.push(result.unencryptedLogs);
         const functionSelector = result.execution.functionData.selector.toString();
+        if (result.reverted && !PhaseIsRevertible[this.phase]) {
+          this.log.debug(
+            `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
+              result.revertReason
+            }`,
+          );
+          throw result.revertReason;
+        }
+
+        newUnencryptedFunctionLogs.push(result.unencryptedLogs);
+
         this.log.debug(
           `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}`,
         );
@@ -220,14 +238,23 @@ export abstract class AbstractPhaseManager {
 
         [kernelOutput, kernelProof] = await this.runKernelCircuit(kernelOutput, kernelProof, callData);
 
-        if (kernelOutput.reverted && this.phase === PublicKernelPhase.APP_LOGIC) {
+        // sanity check. Note we can't expect them to just be equal, because e.g.
+        // if the simulator reverts in app logic, it "resets" and result.reverted will be false when we run teardown,
+        // but the kernel carries the reverted flag forward. But if the simulator reverts, so should the kernel.
+        if (result.reverted && !kernelOutput.reverted) {
+          throw new Error(
+            `Public kernel circuit did not revert on ${result.execution.contractAddress.toString()}:${functionSelector}, but simulator did.`,
+          );
+        }
+
+        // We know the phase is revertible due to the above check.
+        // So safely return the revert reason and the kernel output (which has had its revertible side effects dropped)
+        if (result.reverted) {
           this.log.debug(
             `Reverting on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
               result.revertReason
             }`,
           );
-          // halt immediately if the public kernel circuit has reverted.
-          // return no logs, as they should not go on-chain.
           return [kernelOutput, kernelProof, [], result.revertReason];
         }
 
@@ -333,6 +360,8 @@ export abstract class AbstractPhaseManager {
       newNoteHashes: padArrayEnd(result.newNoteHashes, SideEffect.empty(), MAX_NEW_NOTE_HASHES_PER_CALL),
       newNullifiers: padArrayEnd(result.newNullifiers, SideEffectLinkedToNoteHash.empty(), MAX_NEW_NULLIFIERS_PER_CALL),
       newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, L2ToL1Message.empty(), MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
+      startSideEffectCounter: result.startSideEffectCounter,
+      endSideEffectCounter: result.endSideEffectCounter,
       returnValues: padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH),
       nullifierReadRequests: padArrayEnd(
         result.nullifierReadRequests,

package/src/sequencer/app_logic_phase_manager.ts

@@ -7,7 +7,6 @@ import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
-import { FailedTx } from './processed_tx.js';
 
 /**
  * The phase manager responsible for performing the fee preparation phase.
@@ -39,27 +38,22 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     this.log(`Processing tx ${tx.getTxHash()}`);
     await this.publicContractsDB.addNewContracts(tx);
     const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
+        // if we throw for any reason other than simulation, we need to rollback and drop the TX
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
 
     if (revertReason) {
-      await this.rollback(tx, revertReason);
+      await this.publicContractsDB.removeNewContracts(tx);
+      await this.publicStateDB.rollbackToCheckpoint();
     } else {
       tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
-      await this.publicStateDB.commit();
+      await this.publicStateDB.checkpoint();
     }
 
     return { publicKernelOutput, publicKernelProof, revertReason };
   }
-
-  async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
-    this.log.warn(`Rolling back changes from ${tx.getTxHash()}`);
-    // remove contracts on failure
-    await this.publicContractsDB.removeNewContracts(tx);
-    // rollback any state updates from this failed transaction
-    await this.publicStateDB.rollback();
-    return {
-      tx,
-      error: err instanceof Error ? err : new Error('Unknown error'),
-    };
-  }
 }

package/src/sequencer/sequencer.ts

@@ -202,6 +202,8 @@ export class Sequencer {
 
       await assertBlockHeight();
 
+      const newModelL1ToL2Messages = await this.l1ToL2MessageSource.getNewL1ToL2Messages(BigInt(newBlockNumber));
+
       // Get l1 to l2 messages from the contract
       this.log('Requesting L1 to L2 messages from contract');
       const l1ToL2Messages = await this.getPendingL1ToL2EntryKeys();
@@ -214,7 +216,7 @@ export class Sequencer {
 
       const emptyTx = processor.makeEmptyProcessedTx();
       const [rollupCircuitsDuration, block] = await elapsed(() =>
-        this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables),
+        this.buildBlock(processedValidTxs, newModelL1ToL2Messages, l1ToL2Messages, emptyTx, newGlobalVariables),
       );
 
       this.log(`Assembled block ${block.number}`, {
@@ -312,6 +314,7 @@ export class Sequencer {
   /**
    * Pads the set of txs to a power of two and assembles a block by calling the block builder.
    * @param txs - Processed txs to include in the next block.
+   * @param newModelL1ToL2Messages - L1 to L2 messages emitted by the new inbox.
    * @param newL1ToL2Messages - L1 to L2 messages to be part of the block.
    * @param emptyTx - Empty tx to repeat at the end of the block to pad to a power of two.
    * @param globalVariables - Global variables to use in the block.
@@ -319,7 +322,8 @@ export class Sequencer {
    */
   protected async buildBlock(
     txs: ProcessedTx[],
-    newL1ToL2Messages: Fr[],
+    newModelL1ToL2Messages: Fr[], // TODO(#4492): Rename this when purging the old inbox
+    newL1ToL2Messages: Fr[], // TODO(#4492): Nuke this when purging the old inbox
     emptyTx: ProcessedTx,
     globalVariables: GlobalVariables,
   ) {
@@ -330,7 +334,12 @@ export class Sequencer {
     const allTxs = [...txs, ...times(emptyTxCount, () => emptyTx)];
     this.log(`Building block ${globalVariables.blockNumber}`);
 
-    const [block] = await this.blockBuilder.buildL2Block(globalVariables, allTxs, newL1ToL2Messages);
+    const [block] = await this.blockBuilder.buildL2Block(
+      globalVariables,
+      allTxs,
+      newModelL1ToL2Messages,
+      newL1ToL2Messages,
+    );
     return block;
   }
 

package/src/sequencer/setup_phase_manager.ts

@@ -7,7 +7,6 @@ import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
-import { FailedTx } from './processed_tx.js';
 
 /**
  * The phase manager responsible for performing the fee preparation phase.
@@ -34,21 +33,15 @@ export class SetupPhaseManager extends AbstractPhaseManager {
   ) {
     this.log(`Processing tx ${tx.getTxHash()}`);
     const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
+        // the abstract phase manager throws if simulation gives error in a non-revertible phase
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
-
-    // commit the state updates from this transaction
-    await this.publicStateDB.commit();
-
+    await this.publicStateDB.checkpoint();
     return { publicKernelOutput, publicKernelProof, revertReason };
   }
-
-  async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
-    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
-    await this.publicStateDB.rollback();
-    return {
-      tx,
-      error: err instanceof Error ? err : new Error('Unknown error'),
-    };
-  }
 }

package/src/sequencer/tail_phase_manager.ts

@@ -7,7 +7,6 @@ import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
-import { FailedTx } from './processed_tx.js';
 
 export class TailPhaseManager extends AbstractPhaseManager {
   constructor(
@@ -26,10 +25,15 @@ export class TailPhaseManager extends AbstractPhaseManager {
 
   async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
     this.log(`Processing tx ${tx.getTxHash()}`);
-    this.log(`Executing tail circuit for tx ${tx.getTxHash()}`);
     const [publicKernelOutput, publicKernelProof] = await this.runKernelCircuit(
       previousPublicKernelOutput,
       previousPublicKernelProof,
+    ).catch(
+      // the abstract phase manager throws if simulation gives error in non-revertible phase
+      async err => {
+        await this.publicStateDB.rollbackToCommit();
+        throw err;
+      },
     );
 
     // commit the state updates from this transaction
@@ -37,13 +41,4 @@ export class TailPhaseManager extends AbstractPhaseManager {
 
     return { publicKernelOutput, publicKernelProof, revertReason: undefined };
   }
-
-  async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
-    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
-    await this.publicStateDB.rollback();
-    return {
-      tx,
-      error: err instanceof Error ? err : new Error('Unknown error'),
-    };
-  }
 }