@aztec/sequencer-client 0.69.0-devnet → 0.69.1-devnet

package/src/sequencer/sequencer.ts

@@ -4,11 +4,9 @@ import {
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
-  type ProcessedTx,
   SequencerConfigSchema,
   Tx,
   type TxHash,
-  type TxValidator,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
 import type { AllowedElement, Signature, WorldStateSynchronizerStatus } from '@aztec/circuit-types/interfaces';
@@ -17,10 +15,13 @@ import {
   AppendOnlyTreeSnapshot,
   BlockHeader,
   ContentCommitment,
+  type ContractDataSource,
   GENESIS_ARCHIVE_ROOT,
+  Gas,
   type GlobalVariables,
   StateReference,
 } from '@aztec/circuits.js';
+import { prettyLogViemErrorMsg } from '@aztec/ethereum';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { omit } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -37,9 +38,8 @@ import { type ValidatorClient } from '@aztec/validator-client';
 
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type L1Publisher, VoteType } from '../publisher/l1-publisher.js';
-import { prettyLogViemErrorMsg } from '../publisher/utils.js';
 import { type SlasherClient } from '../slasher/slasher_client.js';
-import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
+import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
 import { getDefaultAllowedSetupFunctions } from './allowed.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
@@ -47,12 +47,6 @@ import { SequencerState, orderAttestations } from './utils.js';
 
 export { SequencerState };
 
-export type ShouldProposeArgs = {
-  pendingTxsCount?: number;
-  validTxsCount?: number;
-  processedTxsCount?: number;
-};
-
 export class SequencerTooSlowError extends Error {
   constructor(
     public readonly currentState: SequencerState,
@@ -90,7 +84,8 @@ export class Sequencer {
   private state = SequencerState.STOPPED;
   private allowedInSetup: AllowedElement[] = getDefaultAllowedSetupFunctions();
   private maxBlockSizeInBytes: number = 1024 * 1024;
-  private processTxTime: number = 12;
+  private maxBlockGas: Gas = new Gas(10e9, 10e9);
+  protected processTxTime: number = 12;
   private metrics: SequencerMetrics;
   private isFlushing: boolean = false;
 
@@ -102,22 +97,22 @@ export class Sequencer {
   protected enforceTimeTable: boolean = false;
 
   constructor(
-    private publisher: L1Publisher,
-    private validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
-    private globalsBuilder: GlobalVariableBuilder,
-    private p2pClient: P2P,
-    private worldState: WorldStateSynchronizer,
-    private slasherClient: SlasherClient,
-    private blockBuilderFactory: BlockBuilderFactory,
-    private l2BlockSource: L2BlockSource,
-    private l1ToL2MessageSource: L1ToL2MessageSource,
-    private publicProcessorFactory: PublicProcessorFactory,
-    private txValidatorFactory: TxValidatorFactory,
+    protected publisher: L1Publisher,
+    protected validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
+    protected globalsBuilder: GlobalVariableBuilder,
+    protected p2pClient: P2P,
+    protected worldState: WorldStateSynchronizer,
+    protected slasherClient: SlasherClient,
+    protected blockBuilderFactory: BlockBuilderFactory,
+    protected l2BlockSource: L2BlockSource,
+    protected l1ToL2MessageSource: L1ToL2MessageSource,
+    protected publicProcessorFactory: PublicProcessorFactory,
+    protected contractDataSource: ContractDataSource,
     protected l1Constants: SequencerRollupConstants,
-    private dateProvider: DateProvider,
+    protected dateProvider: DateProvider,
     telemetry: TelemetryClient,
-    private config: SequencerConfig = {},
-    private log = createLogger('sequencer'),
+    protected config: SequencerConfig = {},
+    protected log = createLogger('sequencer'),
   ) {
     this.updateConfig(config);
     this.metrics = new SequencerMetrics(telemetry, () => this.state, 'Sequencer');
@@ -149,6 +144,12 @@ export class Sequencer {
     if (config.minTxsPerBlock !== undefined) {
       this.minTxsPerBLock = config.minTxsPerBlock;
     }
+    if (config.maxDABlockGas !== undefined) {
+      this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
+    }
+    if (config.maxL2BlockGas !== undefined) {
+      this.maxBlockGas = new Gas(this.maxBlockGas.daGas, config.maxL2BlockGas);
+    }
     if (config.coinbase) {
       this._coinbase = config.coinbase;
     }
@@ -179,7 +180,7 @@ export class Sequencer {
     // How late into the slot can we be to start working
     const initialTime = 2;
 
-    // How long it takes to validate the txs collected and get ready to start building
+    // How long it takes to get ready to start building
     const blockPrepareTime = 1;
 
     // How long it takes to for attestations to travel across the p2p layer.
@@ -218,9 +219,9 @@ export class Sequencer {
       [SequencerState.SYNCHRONIZING]: this.aztecSlotDuration,
       // We always want to allow the full slot to check if we are the proposer
       [SequencerState.PROPOSER_CHECK]: this.aztecSlotDuration,
-      // First transition towards building a block
-      [SequencerState.WAITING_FOR_TXS]: initialTime,
-      // We then validate the txs and prepare to start building the block
+      // How late we can start initializing a new block proposal
+      [SequencerState.INITIALIZING_PROPOSAL]: initialTime,
+      // When we start building a block
       [SequencerState.CREATING_BLOCK]: initialTime + blockPrepareTime,
       // We start collecting attestations after building the block
       [SequencerState.COLLECTING_ATTESTATIONS]: initialTime + blockPrepareTime + processTxsTime + blockValidationTime,
@@ -323,25 +324,27 @@ export class Sequencer {
     void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.GOVERNANCE);
     void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.SLASHING);
 
-    if (!this.shouldProposeBlock(historicalHeader, {})) {
+    // Check the pool has enough txs to build a block
+    const pendingTxCount = this.p2pClient.getPendingTxCount();
+    if (pendingTxCount < this.minTxsPerBLock && !this.isFlushing) {
+      this.log.verbose(`Not enough txs to propose block. Got ${pendingTxCount} min ${this.minTxsPerBLock}.`, {
+        slot,
+        blockNumber: newBlockNumber,
+      });
+      await this.claimEpochProofRightIfAvailable(slot);
       return;
     }
 
+    this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
       chainTipArchive: new Fr(chainTipArchive),
       blockNumber: newBlockNumber,
       slot,
     });
 
-    this.setState(SequencerState.WAITING_FOR_TXS, slot);
-
-    // Get txs to build the new block.
-    const pendingTxs = await this.p2pClient.getPendingTxs();
-
-    if (!this.shouldProposeBlock(historicalHeader, { pendingTxsCount: pendingTxs.length })) {
-      await this.claimEpochProofRightIfAvailable(slot);
-      return;
-    }
+    // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
+    // and also we may need to fetch more if we don't have enough valid txs.
+    const pendingTxs = this.p2pClient.iteratePendingTxs();
 
     // If I created a "partial" header here that should make our job much easier.
     const proposalHeader = new BlockHeader(
@@ -353,35 +356,12 @@ export class Sequencer {
       Fr.ZERO,
     );
 
-    // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here.
-    // TODO: We should validate only the number of txs we need to speed up this process.
-    const allValidTxs = await this.takeValidTxs(
-      pendingTxs,
-      this.txValidatorFactory.validatorForNewTxs(newGlobalVariables, this.allowedInSetup),
-    );
-
-    // TODO: We are taking the size of the tx from private-land, but we should be doing this after running
-    // public functions. Only reason why we do it here now is because the public processor and orchestrator
-    // are set up such that they require knowing the total number of txs in advance. Still, main reason for
-    // exceeding max block size in bytes is contract class registration, which happens in private-land. This
-    // may break if we start emitting lots of log data from public-land.
-    const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
-
-    this.log.verbose(
-      `Collected ${validTxs.length} txs out of ${allValidTxs.length} valid txs out of ${pendingTxs.length} total pending txs for block ${newBlockNumber}`,
-    );
-
-    // Bail if we don't have enough valid txs
-    if (!this.shouldProposeBlock(historicalHeader, { validTxsCount: validTxs.length })) {
-      await this.claimEpochProofRightIfAvailable(slot);
-      return;
-    }
-
     try {
+      // TODO(palla/txs) Is the note below still valid? We don't seem to be doing any rollback in there.
       // @note  It is very important that the following function will FAIL and not just return early
       //        if it have made any state changes. If not, we won't rollback the state, and you will
       //        be in for a world of pain.
-      await this.buildBlockAndAttemptToPublish(validTxs, proposalHeader, historicalHeader);
+      await this.buildBlockAndAttemptToPublish(pendingTxs, proposalHeader, historicalHeader);
     } catch (err) {
       this.log.error(`Error assembling block`, err, { blockNumber: newBlockNumber, slot });
     }
@@ -469,64 +449,20 @@ export class Sequencer {
     this.state = proposedState;
   }
 
-  shouldProposeBlock(historicalHeader: BlockHeader | undefined, args: ShouldProposeArgs): boolean {
-    if (this.isFlushing) {
-      this.log.verbose(`Flushing all pending txs in new block`);
-      return true;
-    }
-
-    // Compute time elapsed since the previous block
-    const lastBlockTime = historicalHeader?.globalVariables.timestamp.toNumber() || 0;
-    const currentTime = Math.floor(Date.now() / 1000);
-    const elapsedSinceLastBlock = currentTime - lastBlockTime;
-    this.log.debug(
-      `Last block mined at ${lastBlockTime} current time is ${currentTime} (elapsed ${elapsedSinceLastBlock})`,
-    );
-
-    // We need to have at least minTxsPerBLock txs.
-    if (args.pendingTxsCount !== undefined && args.pendingTxsCount < this.minTxsPerBLock) {
-      this.log.verbose(
-        `Not creating block because not enough txs in the pool (got ${args.pendingTxsCount} min ${this.minTxsPerBLock})`,
-      );
-      return false;
-    }
-
-    // Bail if we don't have enough valid txs
-    if (args.validTxsCount !== undefined && args.validTxsCount < this.minTxsPerBLock) {
-      this.log.verbose(
-        `Not creating block because not enough valid txs loaded from the pool (got ${args.validTxsCount} min ${this.minTxsPerBLock})`,
-      );
-      return false;
-    }
-
-    // TODO: This check should be processedTxs.length < this.minTxsPerBLock, so we don't publish a block with
-    // less txs than the minimum. But that'd cause the entire block to be aborted and retried. Instead, we should
-    // go back to the p2p pool and load more txs until we hit our minTxsPerBLock target. Only if there are no txs
-    // we should bail.
-    if (args.processedTxsCount === 0 && this.minTxsPerBLock > 0) {
-      this.log.verbose('No txs processed correctly to build block.');
-      return false;
-    }
-
-    return true;
-  }
-
   /**
    * Build a block
    *
    * Shared between the sequencer and the validator for re-execution
    *
-   * @param validTxs - The valid transactions to construct the block from
+   * @param pendingTxs - The pending transactions to construct the block from
    * @param newGlobalVariables - The global variables for the new block
    * @param historicalHeader - The historical header of the parent
-   * @param interrupt - The interrupt callback, used to validate the block for submission and check if we should propose the block
    * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
    */
   private async buildBlock(
-    validTxs: Tx[],
+    pendingTxs: Iterable<Tx>,
     newGlobalVariables: GlobalVariables,
     historicalHeader?: BlockHeader,
-    interrupt?: (processedTxs: ProcessedTx[]) => Promise<void>,
     opts: { validateOnly?: boolean } = {},
   ) {
     const blockNumber = newGlobalVariables.blockNumber.toBigInt();
@@ -534,19 +470,9 @@ export class Sequencer {
 
     this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
     const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
+    const msgCount = l1ToL2Messages.length;
 
-    this.log.verbose(
-      `Building block ${blockNumber} with ${validTxs.length} txs and ${l1ToL2Messages.length} messages`,
-      {
-        msgCount: l1ToL2Messages.length,
-        txCount: validTxs.length,
-        slot,
-        blockNumber,
-      },
-    );
-
-    const numRealTxs = validTxs.length;
-    const blockSize = Math.max(2, numRealTxs);
+    this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, { slot, blockNumber, msgCount });
 
     // Sync to the previous block at least
     await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
@@ -570,18 +496,30 @@ export class Sequencer {
       // We set the deadline for tx processing to the start of the CREATING_BLOCK phase, plus the expected time for tx processing.
       // Deadline is only set if enforceTimeTable is enabled.
       const processingEndTimeWithinSlot = this.timeTable[SequencerState.CREATING_BLOCK] + this.processTxTime;
-      const processingDeadline = this.enforceTimeTable
+      const deadline = this.enforceTimeTable
         ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000)
         : undefined;
-      this.log.verbose(`Processing ${validTxs.length} txs`, {
+      this.log.verbose(`Processing pending txs`, {
         slot,
         slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
         now: new Date(this.dateProvider.now()),
-        deadline: processingDeadline,
+        deadline,
       });
-      const processingTxValidator = this.txValidatorFactory.validatorForProcessedTxs(publicProcessorFork);
+
+      const validators = createValidatorsForBlockBuilding(
+        publicProcessorFork,
+        this.contractDataSource,
+        newGlobalVariables,
+        !!this.config.enforceFees,
+        this.allowedInSetup,
+      );
+
+      // REFACTOR: Public processor should just handle processing, one tx at a time. It should be responsibility
+      // of the sequencer to update world state and iterate over txs. We should refactor this along with unifying the
+      // publicProcessorFork and orchestratorFork, to avoid doing tree insertions twice when building the block.
+      const limits = { deadline, maxTransactions: this.maxTxsPerBlock, maxBlockSize: this.maxBlockSizeInBytes };
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(validTxs, blockSize, processingTxValidator, processingDeadline),
+        processor.process(pendingTxs, limits, validators),
       );
 
       if (failedTxs.length > 0) {
@@ -609,8 +547,6 @@ export class Sequencer {
       const duration = Number(end - start) / 1_000;
       this.metrics.recordBlockBuilderTreeInsertions(duration);
 
-      await interrupt?.(processedTxs);
-
       // All real transactions have been added, set the block as full and pad if needed
       const block = await blockBuilder.setBlockCompleted();
 
@@ -618,7 +554,7 @@ export class Sequencer {
         block,
         publicProcessorDuration,
         numMsgs: l1ToL2Messages.length,
-        numProcessedTxs: processedTxs.length,
+        numTxs: processedTxs.length,
         blockBuildingTimer,
       };
     } finally {
@@ -642,7 +578,7 @@ export class Sequencer {
    * @dev     MUST throw instead of exiting early to ensure that world-state
    *          is being rolled back if the block is dropped.
    *
-   * @param validTxs - The valid transactions to construct the block from
+   * @param pendingTxs - Iterable of pending transactions to construct the block from
    * @param proposalHeader - The partial header constructed for the proposal
    * @param historicalHeader - The historical header of the parent
    */
@@ -650,7 +586,7 @@ export class Sequencer {
     [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
   }))
   private async buildBlockAndAttemptToPublish(
-    validTxs: Tx[],
+    pendingTxs: Iterable<Tx>,
     proposalHeader: BlockHeader,
     historicalHeader: BlockHeader | undefined,
   ): Promise<void> {
@@ -660,40 +596,19 @@ export class Sequencer {
     const blockNumber = newGlobalVariables.blockNumber.toNumber();
     const slot = newGlobalVariables.slotNumber.toBigInt();
 
-    this.metrics.recordNewBlock(blockNumber, validTxs.length);
+    // this.metrics.recordNewBlock(blockNumber, validTxs.length);
     const workTimer = new Timer();
     this.setState(SequencerState.CREATING_BLOCK, slot);
 
-    /**
-     * BuildBlock is shared between the sequencer and the validator for re-execution
-     * We use the interrupt callback to validate the block for submission and check if we should propose the block
-     *
-     * If we fail, we throw an error in order to roll back
-     */
-    const interrupt = async (processedTxs: ProcessedTx[]) => {
-      await this.publisher.validateBlockForSubmission(proposalHeader);
-
-      if (
-        !this.shouldProposeBlock(historicalHeader, {
-          validTxsCount: validTxs.length,
-          processedTxsCount: processedTxs.length,
-        })
-      ) {
-        // TODO: Roll back changes to world state
-        throw new Error('Should not propose the block');
-      }
-    };
-
     // Start collecting proof quotes for the previous epoch if needed in the background
     const proofQuotePromise = this.createProofClaimForPreviousEpoch(slot);
 
     try {
-      const buildBlockRes = await this.buildBlock(validTxs, newGlobalVariables, historicalHeader, interrupt);
-      const { block, publicProcessorDuration, numProcessedTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
+      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables, historicalHeader);
+      const { block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
-
       await this.publisher.validateBlockForSubmission(block.header);
 
       const workDuration = workTimer.ms();
@@ -707,8 +622,8 @@ export class Sequencer {
       };
 
       const blockHash = block.hash();
-      const txHashes = validTxs.map(tx => tx.getTxHash());
-      this.log.info(`Built block ${block.number} with hash ${blockHash}`, {
+      const txHashes = block.body.txEffects.map(tx => tx.txHash);
+      this.log.info(`Built block ${block.number} for slot ${slot} with ${numTxs} txs`, {
         blockHash,
         globalVariables: block.header.globalVariables.toInspect(),
         txHashes,
@@ -734,14 +649,12 @@ export class Sequencer {
       await this.publishL2Block(block, attestations, txHashes, proofQuote);
       this.metrics.recordPublishedBlock(workDuration);
       this.log.info(
-        `Published rollup block ${
-          block.number
-        } with ${numProcessedTxs} transactions and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
+        `Published block ${block.number} with ${numTxs} txs and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
         {
           blockNumber: block.number,
           blockHash: blockHash,
           slot,
-          txCount: numProcessedTxs,
+          txCount: txHashes.length,
           msgCount: numMsgs,
           duration: Math.ceil(workDuration),
           submitter: this.publisher.getSenderAddress().toString(),
@@ -859,42 +772,18 @@ export class Sequencer {
     // Publishes new block to the network and awaits the tx to be mined
     this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
 
-    const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote);
+    // Time out tx at the end of the slot
+    const slot = block.header.globalVariables.slotNumber.toNumber();
+    const txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
+
+    const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote, {
+      txTimeoutAt,
+    });
     if (!publishedL2Block) {
       throw new Error(`Failed to publish block ${block.number}`);
     }
   }
 
-  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], validator: TxValidator<T>): Promise<T[]> {
-    const [valid, invalid] = await validator.validateTxs(txs);
-    if (invalid.length > 0) {
-      this.log.debug(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
-      await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
-    }
-
-    return valid.slice(0, this.maxTxsPerBlock);
-  }
-
-  protected takeTxsWithinMaxSize(txs: Tx[]): Tx[] {
-    const maxSize = this.maxBlockSizeInBytes;
-    let totalSize = 0;
-
-    const toReturn: Tx[] = [];
-    for (const tx of txs) {
-      const txSize = tx.getSize() - tx.clientIvcProof.clientIvcProofBuffer.length;
-      if (totalSize + txSize > maxSize) {
-        this.log.debug(
-          `Dropping tx ${tx.getTxHash()} with estimated size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`,
-        );
-        continue;
-      }
-      toReturn.push(tx);
-      totalSize += txSize;
-    }
-
-    return toReturn;
-  }
-
   @trackSpan(
     'Sequencer.claimEpochProofRightIfAvailable',
     slotNumber => ({ [Attributes.SLOT_NUMBER]: Number(slotNumber) }),

package/src/sequencer/utils.ts

@@ -19,9 +19,9 @@ export enum SequencerState {
    */
   PROPOSER_CHECK = 'PROPOSER_CHECK',
   /**
-   * Polling the P2P module for txs to include in a block. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
+   * Initializing the block proposal. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
    */
-  WAITING_FOR_TXS = 'WAITING_FOR_TXS',
+  INITIALIZING_PROPOSAL = 'INITIALIZING_PROPOSAL',
   /**
    * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
    */

package/src/test/index.ts

@@ -0,0 +1,23 @@
+import { type PublicProcessorFactory } from '@aztec/simulator';
+
+import { SequencerClient } from '../client/sequencer-client.js';
+import { type L1Publisher } from '../publisher/l1-publisher.js';
+import { Sequencer } from '../sequencer/sequencer.js';
+import { type SequencerState } from '../sequencer/utils.js';
+
+class TestSequencer_ extends Sequencer {
+  public override publicProcessorFactory!: PublicProcessorFactory;
+  public override timeTable!: Record<SequencerState, number>;
+  public override processTxTime!: number;
+  public override publisher!: L1Publisher;
+}
+
+export type TestSequencer = TestSequencer_;
+
+class TestSequencerClient_ extends SequencerClient {
+  public override sequencer!: TestSequencer;
+}
+
+export type TestSequencerClient = TestSequencerClient_;
+
+export * from './test-l1-publisher.js';

package/src/{publisher → test}/test-l1-publisher.ts

@@ -3,7 +3,7 @@ import { type Delayer, withDelayer } from '@aztec/ethereum/test';
 
 import { type Chain, type HttpTransport, type PrivateKeyAccount, type WalletClient } from 'viem';
 
-import { L1Publisher } from './l1-publisher.js';
+import { L1Publisher } from '../publisher/l1-publisher.js';
 
 export class TestL1Publisher extends L1Publisher {
   public delayer: Delayer | undefined;

package/src/tx_validator/archive_cache.ts

@@ -0,0 +1,27 @@
+import { MerkleTreeId, type MerkleTreeReadOperations } from '@aztec/circuit-types';
+import { type Fr } from '@aztec/circuits.js';
+import { type ArchiveSource } from '@aztec/p2p';
+
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class ArchiveCache implements ArchiveSource {
+  archives: Map<string, bigint>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.archives = new Map<string, bigint>();
+  }
+
+  public async getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]> {
+    const toCheckDb = archives.filter(n => !this.archives.has(n.toString()));
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
+    dbHits.forEach((x, index) => {
+      if (x !== undefined) {
+        this.archives.set(toCheckDb[index].toString(), x);
+      }
+    });
+
+    return archives.map(n => this.archives.get(n.toString()));
+  }
+}

package/src/tx_validator/gas_validator.ts

@@ -1,4 +1,4 @@
-import { type Tx, TxExecutionPhase, type TxValidator } from '@aztec/circuit-types';
+import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator';
@@ -27,25 +27,10 @@ export class GasTxValidator implements TxValidator<Tx> {
     this.#gasFees = gasFees;
   }
 
-  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[], skippedTxs: Tx[]]> {
-    const validTxs: Tx[] = [];
-    const invalidTxs: Tx[] = [];
-    const skippedTxs: Tx[] = [];
-
-    for (const tx of txs) {
-      if (this.#shouldSkip(tx)) {
-        skippedTxs.push(tx);
-      } else if (await this.#validateTxFee(tx)) {
-        validTxs.push(tx);
-      } else {
-        invalidTxs.push(tx);
-      }
+  validateTx(tx: Tx): Promise<TxValidationResult> {
+    if (this.#shouldSkip(tx)) {
+      return Promise.resolve({ result: 'skipped', reason: ['Insufficient fee per gas'] });
     }
-
-    return [validTxs, invalidTxs, skippedTxs];
-  }
-
-  validateTx(tx: Tx): Promise<boolean> {
     return this.#validateTxFee(tx);
   }
 
@@ -57,20 +42,22 @@ export class GasTxValidator implements TxValidator<Tx> {
     const notEnoughMaxFees =
       maxFeesPerGas.feePerDaGas.lt(this.#gasFees.feePerDaGas) ||
       maxFeesPerGas.feePerL2Gas.lt(this.#gasFees.feePerL2Gas);
+
     if (notEnoughMaxFees) {
       this.#log.warn(`Skipping transaction ${tx.getTxHash()} due to insufficient fee per gas`);
     }
     return notEnoughMaxFees;
   }
 
-  async #validateTxFee(tx: Tx): Promise<boolean> {
+  async #validateTxFee(tx: Tx): Promise<TxValidationResult> {
     const feePayer = tx.data.feePayer;
     // TODO(@spalladino) Eventually remove the is_zero condition as we should always charge fees to every tx
     if (feePayer.isZero()) {
       if (this.#enforceFees) {
         this.#log.warn(`Rejecting transaction ${tx.getTxHash()} due to missing fee payer`);
+        return { result: 'invalid', reason: ['Missing fee payer'] };
       } else {
-        return true;
+        return { result: 'valid' };
       }
     }
 
@@ -98,13 +85,13 @@ export class GasTxValidator implements TxValidator<Tx> {
 
     const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
     if (balance.lt(feeLimit)) {
-      this.#log.info(`Rejecting transaction due to not enough fee payer balance`, {
+      this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,
         balance: balance.toBigInt(),
         feeLimit: feeLimit.toBigInt(),
       });
-      return false;
+      return { result: 'invalid', reason: ['Insufficient fee payer balance'] };
     }
-    return true;
+    return { result: 'valid' };
   }
 }

package/src/tx_validator/nullifier_cache.ts

@@ -0,0 +1,29 @@
+import { MerkleTreeId, type MerkleTreeReadOperations } from '@aztec/circuit-types';
+import { type NullifierSource } from '@aztec/p2p';
+
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class NullifierCache implements NullifierSource {
+  nullifiers: Set<string>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.nullifiers = new Set();
+  }
+
+  public async nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]> {
+    const cacheResults = nullifiers.map(n => this.nullifiers.has(n.toString()));
+    const toCheckDb = nullifiers.filter((_n, index) => !cacheResults[index]);
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, toCheckDb);
+
+    let dbIndex = 0;
+    return nullifiers.map((_n, index) => cacheResults[index] || dbHits[dbIndex++] !== undefined);
+  }
+
+  public addNullifiers(nullifiers: Buffer[]) {
+    for (const nullifier of nullifiers) {
+      this.nullifiers.add(nullifier.toString());
+    }
+  }
+}