@aztec/sequencer-client 0.32.1 → 0.33.0

package/src/sequencer/hints_builder.ts

@@ -2,18 +2,21 @@ import { MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
   MAX_NEW_NULLIFIERS_PER_TX,
-  type MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  type MAX_REVERTIBLE_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_DATA_READS_PER_TX,
   MembershipWitness,
   NULLIFIER_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+  type PublicDataRead,
+  PublicDataTreeLeafPreimage,
   type ReadRequestContext,
   type SideEffectLinkedToNoteHash,
   buildNullifierNonExistentReadRequestHints,
   buildNullifierReadRequestHints,
-  concatAccumulatedData,
+  mergeAccumulatedData,
 } from '@aztec/circuits.js';
+import { makeTuple } from '@aztec/foundation/array';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -22,22 +25,22 @@ export class HintsBuilder {
 
   getNullifierReadRequestHints(
     nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
     return buildNullifierReadRequestHints(
       this,
       nullifierReadRequests,
-      concatAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
+      mergeAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
     );
   }
 
   getNullifierNonExistentReadRequestHints(
     nullifierNonExistentReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
-    const pendingNullifiers = concatAccumulatedData(
+    const pendingNullifiers = mergeAccumulatedData(
       MAX_NEW_NULLIFIERS_PER_TX,
       nullifiersNonRevertible,
       nullifiersRevertible,
@@ -83,4 +86,34 @@ export class HintsBuilder {
 
     return { membershipWitness, leafPreimage };
   }
+
+  async getPublicDataReadsInfo(publicDataReads: PublicDataRead[]) {
+    const newPublicDataReadsWitnesses: Tuple<
+      MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
+      typeof MAX_PUBLIC_DATA_READS_PER_TX
+    > = makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT, 0n));
+
+    const newPublicDataReadsPreimages: Tuple<PublicDataTreeLeafPreimage, typeof MAX_PUBLIC_DATA_READS_PER_TX> =
+      makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => PublicDataTreeLeafPreimage.empty());
+
+    for (const i in publicDataReads) {
+      const leafSlot = publicDataReads[i].leafSlot.value;
+      const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+      if (!lowLeafResult) {
+        throw new Error(`Public data tree should have one initial leaf`);
+      }
+      const preimage = await this.db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+      const path = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+      newPublicDataReadsWitnesses[i] = new MembershipWitness(
+        PUBLIC_DATA_TREE_HEIGHT,
+        BigInt(lowLeafResult.index),
+        path.toTuple<typeof PUBLIC_DATA_TREE_HEIGHT>(),
+      );
+      newPublicDataReadsPreimages[i] = preimage! as PublicDataTreeLeafPreimage;
+    }
+    return {
+      newPublicDataReadsWitnesses,
+      newPublicDataReadsPreimages,
+    };
+  }
 }

package/src/sequencer/phase_manager_factory.ts

@@ -34,7 +34,8 @@ export class PhaseManagerFactory {
     publicContractsDB: ContractsDataSourcePublicDB,
     publicStateDB: PublicStateDB,
   ): AbstractPhaseManager | undefined {
-    if (tx.data.needsSetup) {
+    const data = tx.data.forPublic!;
+    if (data.needsSetup) {
       return new SetupPhaseManager(
         db,
         publicExecutor,
@@ -44,7 +45,7 @@ export class PhaseManagerFactory {
         publicContractsDB,
         publicStateDB,
       );
-    } else if (tx.data.needsAppLogic) {
+    } else if (data.needsAppLogic) {
       return new AppLogicPhaseManager(
         db,
         publicExecutor,
@@ -54,7 +55,7 @@ export class PhaseManagerFactory {
         publicContractsDB,
         publicStateDB,
       );
-    } else if (tx.data.needsTeardown) {
+    } else if (data.needsTeardown) {
       return new TeardownPhaseManager(
         db,
         publicExecutor,

package/src/sequencer/public_processor.ts

@@ -1,16 +1,17 @@
 import {
+  type BlockProver,
   type FailedTx,
   type ProcessedTx,
   type SimulationError,
   Tx,
-  getPreviousOutputAndProof,
   makeEmptyProcessedTx,
   makeProcessedTx,
   toTxEffect,
   validateProcessedTx,
 } from '@aztec/circuit-types';
 import { type TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
-import { type GlobalVariables, type Header } from '@aztec/circuits.js';
+import { type GlobalVariables, type Header, type KernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { type ProcessReturnValues } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { PublicExecutor, type PublicStateDB, type SimulationProvider } from '@aztec/simulator';
@@ -20,8 +21,9 @@ import { type MerkleTreeOperations } from '@aztec/world-state';
 import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
 import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
-import { type AbstractPhaseManager } from './abstract_phase_manager.js';
+import { type AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 import { PhaseManagerFactory } from './phase_manager_factory.js';
+import { type TxValidator } from './tx_validator.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
@@ -84,60 +86,45 @@ export class PublicProcessor {
    * @param txs - Txs to process.
    * @returns The list of processed txs with their circuit simulation outputs.
    */
-  public async process(txs: Tx[]): Promise<[ProcessedTx[], FailedTx[]]> {
+  public async process(
+    txs: Tx[],
+    maxTransactions = txs.length,
+    blockProver?: BlockProver,
+    txValidator?: TxValidator,
+  ): Promise<[ProcessedTx[], FailedTx[], ProcessReturnValues[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
     txs = txs.map(tx => Tx.clone(tx));
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
+    const returns: ProcessReturnValues[] = [];
 
     for (const tx of txs) {
-      let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
-        tx,
-        this.db,
-        this.publicExecutor,
-        this.publicKernel,
-        this.globalVariables,
-        this.historicalHeader,
-        this.publicContractsDB,
-        this.publicStateDB,
-      );
-      this.log(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
-      let { publicKernelPublicInput, previousProof: proof } = getPreviousOutputAndProof(tx, undefined, undefined);
-      let revertReason: SimulationError | undefined;
-      const timer = new Timer();
+      // only process up to the limit of the block
+      if (result.length >= maxTransactions) {
+        break;
+      }
       try {
-        while (phase) {
-          const output = await phase.handle(tx, publicKernelPublicInput, proof);
-          publicKernelPublicInput = output.publicKernelOutput;
-          proof = output.publicKernelProof;
-          revertReason ??= output.revertReason;
-          phase = PhaseManagerFactory.phaseFromOutput(
-            publicKernelPublicInput,
-            phase,
-            this.db,
-            this.publicExecutor,
-            this.publicKernel,
-            this.globalVariables,
-            this.historicalHeader,
-            this.publicContractsDB,
-            this.publicStateDB,
-          );
+        const [processedTx, returnValues] = !tx.hasPublicCalls()
+          ? [makeProcessedTx(tx, tx.data.toKernelCircuitPublicInputs(), tx.proof)]
+          : await this.processTxWithPublicCalls(tx);
+        validateProcessedTx(processedTx);
+        // Re-validate the transaction
+        if (txValidator) {
+          // Only accept processed transactions that are not double-spends,
+          // public functions emitting nullifiers would pass earlier check but fail here.
+          // Note that we're checking all nullifiers generated in the private execution twice,
+          // we could store the ones already checked and skip them here as an optimization.
+          const [_, invalid] = await txValidator.validateTxs([processedTx]);
+          if (invalid.length) {
+            throw new Error(`Transaction ${invalid[0].hash} invalid after processing public functions`);
+          }
         }
-
-        const processedTransaction = makeProcessedTx(tx, publicKernelPublicInput, proof, revertReason);
-        validateProcessedTx(processedTransaction);
-
-        result.push(processedTransaction);
-
-        this.log(`Processed public part of ${tx.data.endNonRevertibleData.newNullifiers[0].value}`, {
-          eventName: 'tx-sequencer-processing',
-          duration: timer.ms(),
-          effectsSize: toTxEffect(processedTransaction).toBuffer().length,
-          publicDataUpdateRequests:
-            processedTransaction.data.combinedData.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ??
-            0,
-          ...tx.getStats(),
-        } satisfies TxSequencerProcessingStats);
+        // if we were given a prover then send the transaction to it for proving
+        if (blockProver) {
+          await blockProver.addNewTx(processedTx);
+        }
+        result.push(processedTx);
+        returns.push(returnValues);
       } catch (err: any) {
         const errorMessage = err instanceof Error ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage}`);
@@ -146,10 +133,11 @@ export class PublicProcessor {
           tx,
           error: err instanceof Error ? err : new Error(errorMessage),
         });
+        returns.push([]);
       }
     }
 
-    return [result, failed];
+    return [result, failed, returns];
   }
 
   /**
@@ -158,6 +146,64 @@ export class PublicProcessor {
    */
   public makeEmptyProcessedTx(): ProcessedTx {
     const { chainId, version } = this.globalVariables;
-    return makeEmptyProcessedTx(this.historicalHeader, chainId, version);
+    return makeEmptyProcessedTx(this.historicalHeader.clone(), chainId, version);
+  }
+
+  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, ProcessReturnValues | undefined]> {
+    let returnValues: ProcessReturnValues = undefined;
+    let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
+      tx,
+      this.db,
+      this.publicExecutor,
+      this.publicKernel,
+      this.globalVariables,
+      this.historicalHeader,
+      this.publicContractsDB,
+      this.publicStateDB,
+    );
+    this.log(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
+    let proof = tx.proof;
+    let publicKernelPublicInput = tx.data.toPublicKernelCircuitPublicInputs();
+    let finalKernelOutput: KernelCircuitPublicInputs | undefined;
+    let revertReason: SimulationError | undefined;
+    const timer = new Timer();
+    while (phase) {
+      const output = await phase.handle(tx, publicKernelPublicInput, proof);
+      if (phase.phase === PublicKernelPhase.APP_LOGIC) {
+        returnValues = output.returnValues;
+      }
+      publicKernelPublicInput = output.publicKernelOutput;
+      finalKernelOutput = output.finalKernelOutput;
+      proof = output.publicKernelProof;
+      revertReason ??= output.revertReason;
+      phase = PhaseManagerFactory.phaseFromOutput(
+        publicKernelPublicInput,
+        phase,
+        this.db,
+        this.publicExecutor,
+        this.publicKernel,
+        this.globalVariables,
+        this.historicalHeader,
+        this.publicContractsDB,
+        this.publicStateDB,
+      );
+    }
+
+    if (!finalKernelOutput) {
+      throw new Error('Final public kernel was not executed.');
+    }
+
+    const processedTx = makeProcessedTx(tx, finalKernelOutput, proof, revertReason);
+
+    this.log(`Processed public part of ${tx.getTxHash()}`, {
+      eventName: 'tx-sequencer-processing',
+      duration: timer.ms(),
+      effectsSize: toTxEffect(processedTx).toBuffer().length,
+      publicDataUpdateRequests:
+        processedTx.data.end.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ?? 0,
+      ...tx.getStats(),
+    } satisfies TxSequencerProcessingStats);
+
+    return [processedTx, returnValues];
   }
 }

package/src/sequencer/sequencer.ts

@@ -1,7 +1,7 @@
 import { type L1ToL2MessageSource, type L2Block, type L2BlockSource, type ProcessedTx, Tx } from '@aztec/circuit-types';
 import { type BlockProver, PROVING_STATUS } from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
-import { AztecAddress, EthAddress, type GlobalVariables } from '@aztec/circuits.js';
+import { AztecAddress, EthAddress } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -193,57 +193,75 @@ export class Sequencer {
       this.log.info(`Building block ${newBlockNumber} with ${validTxs.length} transactions`);
       this.state = SequencerState.CREATING_BLOCK;
 
+      // Get l1 to l2 messages from the contract
+      this.log('Requesting L1 to L2 messages from contract');
+      const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
+      this.log(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
+
       // We create a fresh processor each time to reset any cached state (eg storage writes)
       const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
-      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs));
+
+      const emptyTx = processor.makeEmptyProcessedTx();
+
+      const blockBuildingTimer = new Timer();
+
+      // We must initialise the block to be a power of 2 in size
+      const numRealTxs = validTxs.length;
+      const pow2 = Math.log2(numRealTxs);
+      const totalTxs = 2 ** Math.ceil(pow2);
+      const blockSize = Math.max(2, totalTxs);
+      const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages, emptyTx);
+
+      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
+        processor.process(validTxs, blockSize, this.prover, txValidator),
+      );
       if (failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
         this.log(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
         await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
       }
 
-      // Only accept processed transactions that are not double-spends,
-      // public functions emitting nullifiers would pass earlier check but fail here.
-      // Note that we're checking all nullifiers generated in the private execution twice,
-      // we could store the ones already checked and skip them here as an optimization.
-      const processedValidTxs = await this.takeValidTxs(processedTxs, txValidator);
-
-      if (processedValidTxs.length === 0) {
+      if (processedTxs.length === 0) {
         this.log('No txs processed correctly to build block. Exiting');
+        this.prover.cancelBlock();
         return;
       }
 
       await assertBlockHeight();
 
-      // Get l1 to l2 messages from the contract
-      this.log('Requesting L1 to L2 messages from contract');
-      const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
-      this.log(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
+      // All real transactions have been added, set the block as full and complete the proving.
+      await this.prover.setBlockCompleted();
 
-      // Build the new block by running the rollup circuits
-      this.log(`Assembling block with txs ${processedValidTxs.map(tx => tx.hash).join(', ')}`);
+      // Here we are now waiting for the block to be proven.
+      // TODO(@PhilWindle) We should probably periodically check for things like another
+      // block being published before ours instead of just waiting on our block
+      const result = await blockTicket.provingPromise;
+      if (result.status === PROVING_STATUS.FAILURE) {
+        throw new Error(`Block proving failed, reason: ${result.reason}`);
+      }
 
       await assertBlockHeight();
 
-      const emptyTx = processor.makeEmptyProcessedTx();
-      const [rollupCircuitsDuration, block] = await elapsed(() =>
-        this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables),
-      );
+      // Block is proven, now finalise and publish!
+      const blockResult = await this.prover.finaliseBlock();
+      const block = blockResult.block;
+
+      await assertBlockHeight();
 
       this.log(`Assembled block ${block.number}`, {
         eventName: 'l2-block-built',
         duration: workTimer.ms(),
         publicProcessDuration: publicProcessorDuration,
-        rollupCircuitsDuration: rollupCircuitsDuration,
+        rollupCircuitsDuration: blockBuildingTimer.ms(),
         ...block.getStats(),
       } satisfies L2BlockBuiltStats);
 
-      await assertBlockHeight();
-
       await this.publishL2Block(block);
-      this.log.info(`Submitted rollup block ${block.number} with ${processedValidTxs.length} transactions`);
+      this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
     } catch (err) {
       this.log.error(`Rolling back world state DB due to error assembling block`, (err as any).stack);
+      // Cancel any further proving on the block
+      this.prover?.cancelBlock();
       await this.worldState.getLatest().rollback();
     }
   }
@@ -289,33 +307,6 @@ export class Sequencer {
     return min >= this.lastPublishedBlock;
   }
 
-  /**
-   * 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 l1ToL2Messages - 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.
-   * @returns The new block.
-   */
-  protected async buildBlock(
-    txs: ProcessedTx[],
-    l1ToL2Messages: Fr[],
-    emptyTx: ProcessedTx,
-    globalVariables: GlobalVariables,
-  ) {
-    const blockTicket = await this.prover.startNewBlock(txs.length, globalVariables, l1ToL2Messages, emptyTx);
-
-    for (const tx of txs) {
-      await this.prover.addNewTx(tx);
-    }
-
-    const result = await blockTicket.provingPromise;
-    if (result.status === PROVING_STATUS.FAILURE) {
-      throw new Error(`Block proving failed, reason: ${result.reason}`);
-    }
-    return result.block;
-  }
-
   get coinbase(): EthAddress {
     return this._coinbase;
   }

package/src/sequencer/setup_phase_manager.ts

@@ -45,6 +45,6 @@ export class SetupPhaseManager extends AbstractPhaseManager {
       );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
     await this.publicStateDB.checkpoint();
-    return { publicKernelOutput, publicKernelProof, revertReason };
+    return { publicKernelOutput, publicKernelProof, revertReason, returnValues: undefined };
   }
 }

package/src/sequencer/tail_phase_manager.ts

@@ -1,10 +1,19 @@
 import { type Tx } from '@aztec/circuit-types';
 import {
+  type Fr,
   type GlobalVariables,
   type Header,
+  type KernelCircuitPublicInputs,
+  MAX_NEW_NOTE_HASHES_PER_TX,
   type Proof,
   type PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
+  type SideEffect,
+  makeEmptyProof,
+  mergeAccumulatedData,
+  sortByCounter,
 } from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -28,7 +37,7 @@ export class TailPhaseManager extends AbstractPhaseManager {
 
   async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
     this.log(`Processing tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof] = await this.runKernelCircuit(
+    const [finalKernelOutput, publicKernelProof] = await this.runTailKernelCircuit(
       previousPublicKernelOutput,
       previousPublicKernelProof,
     ).catch(
@@ -42,6 +51,61 @@ export class TailPhaseManager extends AbstractPhaseManager {
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof, revertReason: undefined };
+    return {
+      publicKernelOutput: previousPublicKernelOutput,
+      finalKernelOutput,
+      publicKernelProof,
+      revertReason: undefined,
+      returnValues: undefined,
+    };
+  }
+
+  private async runTailKernelCircuit(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<[KernelCircuitPublicInputs, Proof]> {
+    const output = await this.simulate(previousOutput, previousProof);
+
+    // Temporary hack. Should sort them in the tail circuit.
+    const noteHashes = mergeAccumulatedData(
+      MAX_NEW_NOTE_HASHES_PER_TX,
+      previousOutput.endNonRevertibleData.newNoteHashes,
+      previousOutput.end.newNoteHashes,
+    );
+    output.end.newNoteHashes = this.sortNoteHashes<typeof MAX_NEW_NOTE_HASHES_PER_TX>(noteHashes);
+
+    return [output, makeEmptyProof()];
+  }
+
+  private async simulate(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<KernelCircuitPublicInputs> {
+    const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+
+    const { validationRequests, endNonRevertibleData, end } = previousOutput;
+    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
+      validationRequests.nullifierReadRequests,
+      endNonRevertibleData.newNullifiers,
+      end.newNullifiers,
+    );
+    const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
+      validationRequests.nullifierNonExistentReadRequests,
+      endNonRevertibleData.newNullifiers,
+      end.newNullifiers,
+    );
+    const inputs = new PublicKernelTailCircuitPrivateInputs(
+      previousKernel,
+      nullifierReadRequestHints,
+      nullifierNonExistentReadRequestHints,
+    );
+    return this.publicKernel.publicKernelCircuitTail(inputs);
+  }
+
+  private sortNoteHashes<N extends number>(noteHashes: Tuple<SideEffect, N>): Tuple<Fr, N> {
+    return sortByCounter(noteHashes.map(n => ({ ...n, counter: n.counter.toNumber() }))).map(n => n.value) as Tuple<
+      Fr,
+      N
+    >;
   }
 }

package/src/sequencer/teardown_phase_manager.ts

@@ -45,6 +45,6 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
       );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
     await this.publicStateDB.checkpoint();
-    return { publicKernelOutput, publicKernelProof, revertReason };
+    return { publicKernelOutput, publicKernelProof, revertReason, returnValues: undefined };
   }
 }

package/src/sequencer/tx_validator.ts

@@ -138,9 +138,7 @@ export class TxValidator {
    * @returns Whether this is a problematic double spend that the L1 contract would reject.
    */
   async #validateNullifiers(tx: Tx | ProcessedTx, thisBlockNullifiers: Set<bigint>): Promise<TxValidationStatus> {
-    const newNullifiers = [...tx.data.endNonRevertibleData.newNullifiers, ...tx.data.end.newNullifiers]
-      .filter(x => !x.isEmpty())
-      .map(x => x.value.toBigInt());
+    const newNullifiers = tx.data.getNonEmptyNullifiers().map(x => x.toBigInt());
 
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(newNullifiers);
@@ -172,7 +170,7 @@ export class TxValidator {
   }
 
   async #validateGasBalance(tx: Tx): Promise<TxValidationStatus> {
-    if (!tx.data.needsTeardown) {
+    if (!tx.data.forPublic || !tx.data.forPublic.needsTeardown) {
       return VALID_TX;
     }
 
@@ -200,7 +198,11 @@ export class TxValidator {
   }
 
   #validateMaxBlockNumber(tx: Tx | ProcessedTx): TxValidationStatus {
-    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+    const target =
+      tx instanceof Tx
+        ? tx.data.forRollup?.rollupValidationRequests || tx.data.forPublic!.validationRequests.forRollup
+        : tx.data.rollupValidationRequests;
+    const maxBlockNumber = target.maxBlockNumber;
 
     if (maxBlockNumber.isSome && maxBlockNumber.value < this.#globalVariables.blockNumber) {
       this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for low max block number`);
@@ -211,7 +213,7 @@ export class TxValidator {
   }
 
   async #validateFee(tx: Tx): Promise<TxValidationStatus> {
-    if (!tx.data.needsTeardown) {
+    if (!tx.data.forPublic || !tx.data.forPublic.needsTeardown) {
       // TODO check if fees are mandatory and reject this tx
       this.#log.debug(`Tx ${Tx.getHash(tx)} doesn't pay for gas`);
       return VALID_TX;

package/src/sequencer/utils.ts

@@ -7,13 +7,14 @@ import { CallRequest } from '@aztec/circuits.js';
  * @returns The highest side effect counter in the transaction so far
  */
 export function lastSideEffectCounter(tx: Tx): number {
+  const data = tx.data.forPublic!;
   const sideEffectCounters = [
-    ...tx.data.endNonRevertibleData.newNoteHashes,
-    ...tx.data.endNonRevertibleData.newNullifiers,
-    ...tx.data.endNonRevertibleData.publicCallStack,
-    ...tx.data.end.newNoteHashes,
-    ...tx.data.end.newNullifiers,
-    ...tx.data.end.publicCallStack,
+    ...data.endNonRevertibleData.newNoteHashes,
+    ...data.endNonRevertibleData.newNullifiers,
+    ...data.endNonRevertibleData.publicCallStack,
+    ...data.end.newNoteHashes,
+    ...data.end.newNullifiers,
+    ...data.end.publicCallStack,
   ];
 
   let max = 0;

package/src/simulator/index.ts

@@ -1,4 +1,5 @@
 import {
+  type KernelCircuitPublicInputs,
   type PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
   type PublicKernelTailCircuitPrivateInputs,
@@ -31,5 +32,5 @@ export interface PublicKernelCircuitSimulator {
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<KernelCircuitPublicInputs>;
 }

package/src/simulator/public_kernel.ts

@@ -1,5 +1,6 @@
 import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
+  type KernelCircuitPublicInputs,
   type PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
   type PublicKernelTailCircuitPrivateInputs,
@@ -120,7 +121,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
    */
   public async publicKernelCircuitTail(
     input: PublicKernelTailCircuitPrivateInputs,
-  ): Promise<PublicKernelCircuitPublicInputs> {
+  ): Promise<KernelCircuitPublicInputs> {
     const inputWitness = convertPublicTailInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
       this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTailArtifact),