@aztec/sequencer-client 0.32.0 → 0.33.0

package/src/sequencer/public_processor.ts

@@ -1,27 +1,29 @@
 import {
-  FailedTx,
-  ProcessedTx,
-  SimulationError,
+  type BlockProver,
+  type FailedTx,
+  type ProcessedTx,
+  type SimulationError,
   Tx,
-  getPreviousOutputAndProof,
   makeEmptyProcessedTx,
   makeProcessedTx,
   toTxEffect,
   validateProcessedTx,
 } from '@aztec/circuit-types';
-import { TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
-import { GlobalVariables, Header } from '@aztec/circuits.js';
+import { type TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
+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, PublicStateDB, SimulationProvider } from '@aztec/simulator';
-import { ContractDataSource } from '@aztec/types/contracts';
-import { MerkleTreeOperations } from '@aztec/world-state';
+import { PublicExecutor, type PublicStateDB, type SimulationProvider } from '@aztec/simulator';
+import { type ContractDataSource } from '@aztec/types/contracts';
+import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
 import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
-import { 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,20 +1,20 @@
-import { L1ToL2MessageSource, L2Block, L2BlockSource, ProcessedTx, Tx } from '@aztec/circuit-types';
-import { BlockProver, PROVING_STATUS } from '@aztec/circuit-types/interfaces';
-import { L2BlockBuiltStats } from '@aztec/circuit-types/stats';
-import { AztecAddress, EthAddress, GlobalVariables } from '@aztec/circuits.js';
+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 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { Timer, elapsed } from '@aztec/foundation/timer';
-import { P2P } from '@aztec/p2p';
-import { WorldStateStatus, WorldStateSynchronizer } from '@aztec/world-state';
+import { type P2P } from '@aztec/p2p';
+import { type WorldStateStatus, type WorldStateSynchronizer } from '@aztec/world-state';
 
-import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { L1Publisher } from '../publisher/l1-publisher.js';
-import { SequencerConfig } from './config.js';
-import { PublicProcessorFactory } from './public_processor.js';
-import { TxValidator } from './tx_validator.js';
-import { TxValidatorFactory } from './tx_validator_factory.js';
+import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
+import { type L1Publisher } from '../publisher/l1-publisher.js';
+import { type SequencerConfig } from './config.js';
+import { type PublicProcessorFactory } from './public_processor.js';
+import { type TxValidator } from './tx_validator.js';
+import { type TxValidatorFactory } from './tx_validator_factory.js';
 
 /**
  * Sequencer client
@@ -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

@@ -1,10 +1,15 @@
-import { Tx } from '@aztec/circuit-types';
-import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
-import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
-import { MerkleTreeOperations } from '@aztec/world-state';
+import { type Tx } from '@aztec/circuit-types';
+import {
+  type GlobalVariables,
+  type Header,
+  type Proof,
+  type PublicKernelCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
+import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
+import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { type ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 
 /**
@@ -40,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,24 @@
-import { Tx } from '@aztec/circuit-types';
-import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
-import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
-import { MerkleTreeOperations } from '@aztec/world-state';
+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';
 
-import { PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
+import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { type ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 
 export class TailPhaseManager extends AbstractPhaseManager {
@@ -23,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(
@@ -37,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

@@ -1,10 +1,15 @@
-import { Tx } from '@aztec/circuit-types';
-import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
-import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
-import { MerkleTreeOperations } from '@aztec/world-state';
+import { type Tx } from '@aztec/circuit-types';
+import {
+  type GlobalVariables,
+  type Header,
+  type Proof,
+  type PublicKernelCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
+import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
+import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { type ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 
 /**
@@ -40,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

@@ -1,9 +1,15 @@
-import { ProcessedTx, Tx } from '@aztec/circuit-types';
-import { AztecAddress, EthAddress, Fr, GlobalVariables, PublicCallRequest } from '@aztec/circuits.js';
+import { type ProcessedTx, Tx } from '@aztec/circuit-types';
+import {
+  type AztecAddress,
+  type EthAddress,
+  Fr,
+  type GlobalVariables,
+  type PublicCallRequest,
+} from '@aztec/circuits.js';
 import { pedersenHash } from '@aztec/foundation/crypto';
-import { Logger, createDebugLogger } from '@aztec/foundation/log';
+import { type Logger, createDebugLogger } from '@aztec/foundation/log';
 import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
-import { ContractDataSource } from '@aztec/types/contracts';
+import { type ContractDataSource } from '@aztec/types/contracts';
 
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 
@@ -132,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);
@@ -166,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;
     }
 
@@ -194,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`);
@@ -205,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/tx_validator_factory.ts

@@ -1,6 +1,6 @@
-import { AztecAddress, EthAddress, Fr, GlobalVariables } from '@aztec/circuits.js';
-import { ContractDataSource } from '@aztec/types/contracts';
-import { MerkleTreeOperations } from '@aztec/world-state';
+import { type AztecAddress, type EthAddress, type Fr, type GlobalVariables } from '@aztec/circuits.js';
+import { type ContractDataSource } from '@aztec/types/contracts';
+import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
 import { TxValidator } from './tx_validator.js';

package/src/sequencer/utils.ts

@@ -1,4 +1,4 @@
-import { Tx } from '@aztec/circuit-types';
+import { type Tx } from '@aztec/circuit-types';
 import { CallRequest } from '@aztec/circuits.js';
 
 /**
@@ -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,7 +1,8 @@
 import {
-  PublicKernelCircuitPrivateInputs,
-  PublicKernelCircuitPublicInputs,
-  PublicKernelTailCircuitPrivateInputs,
+  type KernelCircuitPublicInputs,
+  type PublicKernelCircuitPrivateInputs,
+  type PublicKernelCircuitPublicInputs,
+  type PublicKernelTailCircuitPrivateInputs,
 } from '@aztec/circuits.js';
 
 /**
@@ -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>;
 }