@aztec/validator-client 4.0.0-nightly.20260111 → 4.0.0-nightly.20260113

package/src/checkpoint_builder.ts

@@ -0,0 +1,267 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
+import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
+import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
+import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
+import {
+  GuardedMerkleTreeOperations,
+  PublicContractsDB,
+  PublicProcessor,
+  createPublicTxSimulatorForBlockBuilding,
+} from '@aztec/simulator/server';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import {
+  type FullNodeBlockBuilderConfig,
+  FullNodeBlockBuilderConfigKeys,
+  type MerkleTreeWriteOperations,
+  type PublicProcessorLimits,
+} from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { type CheckpointGlobalVariables, type FailedTx, GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { createValidatorForBlockBuilding } from './tx_validator/tx_validator_factory.js';
+
+const log = createLogger('checkpoint-builder');
+
+export interface BuildBlockInCheckpointResult {
+  block: L2BlockNew;
+  publicGas: Gas;
+  publicProcessorDuration: number;
+  numTxs: number;
+  failedTxs: FailedTx[];
+  blockBuildingTimer: Timer;
+  usedTxs: Tx[];
+}
+
+/**
+ * Builder for a single checkpoint. Handles building blocks within the checkpoint
+ * and completing it.
+ */
+export class CheckpointBuilder {
+  constructor(
+    private checkpointBuilder: LightweightCheckpointBuilder,
+    private fork: MerkleTreeWriteOperations,
+    private config: FullNodeBlockBuilderConfig,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient,
+  ) {}
+
+  getConstantData(): CheckpointGlobalVariables {
+    return this.checkpointBuilder.constants;
+  }
+
+  /**
+   * Builds a single block within this checkpoint.
+   */
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: PublicProcessorLimits & { expectedEndState?: StateReference },
+  ): Promise<BuildBlockInCheckpointResult> {
+    const blockBuildingTimer = new Timer();
+    const slot = this.checkpointBuilder.constants.slotNumber;
+
+    log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, { slot, blockNumber, ...opts });
+
+    const constants = this.checkpointBuilder.constants;
+    const globalVariables = GlobalVariables.from({
+      chainId: constants.chainId,
+      version: constants.version,
+      blockNumber,
+      slotNumber: constants.slotNumber,
+      timestamp,
+      coinbase: constants.coinbase,
+      feeRecipient: constants.feeRecipient,
+      gasFees: constants.gasFees,
+    });
+    const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, this.fork);
+
+    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(() =>
+      processor.process(pendingTxs, opts, validator),
+    );
+
+    // Add block to checkpoint
+    const block = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
+      expectedEndState: opts.expectedEndState,
+    });
+
+    // How much public gas was processed
+    const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
+
+    const res = {
+      block,
+      publicGas,
+      publicProcessorDuration,
+      numTxs: processedTxs.length,
+      failedTxs,
+      blockBuildingTimer,
+      usedTxs,
+    };
+    log.debug('Built block within checkpoint', res.block.header);
+    return res;
+  }
+
+  /** Completes the checkpoint and returns it. */
+  async completeCheckpoint(): Promise<Checkpoint> {
+    const checkpoint = await this.checkpointBuilder.completeCheckpoint();
+
+    log.verbose(`Completed checkpoint ${checkpoint.number}`, {
+      checkpointNumber: checkpoint.number,
+      numBlocks: checkpoint.blocks.length,
+      archiveRoot: checkpoint.archive.root.toString(),
+    });
+
+    return checkpoint;
+  }
+
+  /** Gets the checkpoint currently in progress. */
+  getCheckpoint(): Promise<Checkpoint> {
+    return this.checkpointBuilder.clone().completeCheckpoint();
+  }
+
+  protected async makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations) {
+    const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
+    const contractsDB = new PublicContractsDB(this.contractDataSource);
+    const guardedFork = new GuardedMerkleTreeOperations(fork);
+
+    const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(
+      guardedFork,
+      contractsDB,
+      globalVariables,
+      this.telemetryClient,
+    );
+
+    const processor = new PublicProcessor(
+      globalVariables,
+      guardedFork,
+      contractsDB,
+      publicTxSimulator,
+      this.dateProvider,
+      this.telemetryClient,
+      undefined,
+      this.config,
+    );
+
+    const validator = createValidatorForBlockBuilding(
+      fork,
+      this.contractDataSource,
+      globalVariables,
+      txPublicSetupAllowList,
+    );
+
+    return {
+      processor,
+      validator,
+    };
+  }
+}
+
+/**
+ * Factory for creating checkpoint builders.
+ */
+export class FullNodeCheckpointsBuilder {
+  constructor(
+    private config: FullNodeBlockBuilderConfig,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {}
+
+  public getConfig(): FullNodeBlockBuilderConfig {
+    return this.config;
+  }
+
+  public updateConfig(config: Partial<FullNodeBlockBuilderConfig>) {
+    this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
+  }
+
+  /**
+   * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
+   */
+  async startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    fork: MerkleTreeWriteOperations,
+  ): Promise<CheckpointBuilder> {
+    const stateReference = await fork.getStateReference();
+    const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    log.verbose(`Building new checkpoint ${checkpointNumber}`, {
+      checkpointNumber,
+      msgCount: l1ToL2Messages.length,
+      initialStateReference: stateReference.toInspect(),
+      initialArchiveRoot: bufferToHex(archiveTree.root),
+      constants,
+    });
+
+    const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      fork,
+    );
+
+    return new CheckpointBuilder(
+      lightweightBuilder,
+      fork,
+      this.config,
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+    );
+  }
+
+  /**
+   * Opens a checkpoint, either starting fresh or resuming from existing blocks.
+   */
+  async openCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    fork: MerkleTreeWriteOperations,
+    existingBlocks: L2BlockNew[] = [],
+  ): Promise<CheckpointBuilder> {
+    const stateReference = await fork.getStateReference();
+    const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    if (existingBlocks.length === 0) {
+      return this.startCheckpoint(checkpointNumber, constants, l1ToL2Messages, fork);
+    }
+
+    log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
+      checkpointNumber,
+      msgCount: l1ToL2Messages.length,
+      existingBlockCount: existingBlocks.length,
+      initialStateReference: stateReference.toInspect(),
+      initialArchiveRoot: bufferToHex(archiveTree.root),
+      constants,
+    });
+
+    const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      fork,
+      existingBlocks,
+    );
+
+    return new CheckpointBuilder(
+      lightweightBuilder,
+      fork,
+      this.config,
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+    );
+  }
+}

package/src/config.ts

@@ -70,6 +70,16 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
       'Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus.',
     ...booleanConfigHelper(false),
   },
+  // TODO(palla/mbps): Change default to false once checkpoint validation is stable
+  skipCheckpointProposalValidation: {
+    description: 'Skip checkpoint proposal validation and always attest (default: true)',
+    defaultValue: true,
+  },
+  // TODO(palla/mbps): Change default to false once block sync is stable
+  skipPushProposedBlocksToArchiver: {
+    description: 'Skip pushing re-executed blocks to archiver (default: true)',
+    defaultValue: true,
+  },
 };
 
 /**

package/src/duties/validation_service.ts

@@ -5,15 +5,19 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
 import { createLogger } from '@aztec/foundation/log';
 import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import type { CreateCheckpointProposalLastBlockData } from '@aztec/stdlib/interfaces/server';
 import {
-  BlockAttestation,
   BlockProposal,
   type BlockProposalOptions,
+  CheckpointAttestation,
+  CheckpointProposal,
+  type CheckpointProposalCore,
+  type CheckpointProposalOptions,
   ConsensusPayload,
   SignatureDomainSeparator,
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
-import type { Tx } from '@aztec/stdlib/tx';
+import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
 
 import type { ValidatorKeyStore } from '../key_store/interface.js';
 
@@ -26,63 +30,113 @@ export class ValidationService {
   /**
    * Create a block proposal with the given header, archive, and transactions
    *
-   * @param header - The block header
+   * @param blockHeader - The block header
+   * @param indexWithinCheckpoint - Index of this block within the checkpoint (0-indexed)
+   * @param inHash - Hash of L1 to L2 messages for this checkpoint
    * @param archive - The archive of the current block
    * @param txs - TxHash[] ordered list of transactions
    * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
    *
-   * @returns A block proposal signing the above information (not the current implementation!!!)
+   * @returns A block proposal signing the above information
    */
-  async createBlockProposal(
-    header: CheckpointHeader,
+  public createBlockProposal(
+    blockHeader: BlockHeader,
+    indexWithinCheckpoint: number,
+    inHash: Fr,
     archive: Fr,
     txs: Tx[],
     proposerAttesterAddress: EthAddress | undefined,
     options: BlockProposalOptions,
   ): Promise<BlockProposal> {
-    let payloadSigner: (payload: Buffer32) => Promise<Signature>;
-    if (proposerAttesterAddress !== undefined) {
-      payloadSigner = (payload: Buffer32) => this.keyStore.signMessageWithAddress(proposerAttesterAddress, payload);
-    } else {
-      // if there is no proposer attester address, just use the first signer
-      const signer = this.keyStore.getAddress(0);
-      payloadSigner = (payload: Buffer32) => this.keyStore.signMessageWithAddress(signer, payload);
-    }
-    // TODO: check if this is calculated earlier / can not be recomputed
-    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    const payloadSigner = this.getPayloadSigner(proposerAttesterAddress);
 
     // For testing: change the new archive to trigger state_mismatch validation failure
     if (options.broadcastInvalidBlockProposal) {
       archive = Fr.random();
-      this.log.warn(`Creating INVALID block proposal for slot ${header.slotNumber}`);
+      this.log.warn(`Creating INVALID block proposal for slot ${blockHeader.globalVariables.slotNumber}`);
     }
 
     return BlockProposal.createProposalFromSigner(
-      new ConsensusPayload(header, archive),
-      txHashes,
+      blockHeader,
+      indexWithinCheckpoint,
+      inHash,
+      archive,
+      txs.map(tx => tx.getTxHash()),
       options.publishFullTxs ? txs : undefined,
       payloadSigner,
     );
   }
 
   /**
-   * Attest with selection of validators to the given block proposal, constructed by the current sequencer
+   * Create a checkpoint proposal with the last block header and checkpoint header
+   *
+   * @param checkpointHeader - The checkpoint header containing aggregated data
+   * @param archive - The archive of the checkpoint
+   * @param lastBlockInfo - Info about the last block (header, index, txs) or undefined
+   * @param proposerAttesterAddress - The address of the proposer
+   * @param options - Checkpoint proposal options
+   *
+   * @returns A checkpoint proposal signing the above information
+   */
+  public createCheckpointProposal(
+    checkpointHeader: CheckpointHeader,
+    archive: Fr,
+    lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
+    proposerAttesterAddress: EthAddress | undefined,
+    options: CheckpointProposalOptions,
+  ): Promise<CheckpointProposal> {
+    const payloadSigner = this.getPayloadSigner(proposerAttesterAddress);
+
+    // For testing: change the archive to trigger state_mismatch validation failure
+    if (options.broadcastInvalidCheckpointProposal) {
+      archive = Fr.random();
+      this.log.warn(`Creating INVALID checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
+    }
+
+    // Last block to include in the proposal
+    const lastBlock = lastBlockInfo && {
+      blockHeader: lastBlockInfo.blockHeader,
+      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
+      txHashes: lastBlockInfo.txs.map(tx => tx.getTxHash()),
+      txs: options.publishFullTxs ? lastBlockInfo.txs : undefined,
+    };
+
+    return CheckpointProposal.createProposalFromSigner(checkpointHeader, archive, lastBlock, payloadSigner);
+  }
+
+  private getPayloadSigner(proposerAttesterAddress: EthAddress | undefined): (payload: Buffer32) => Promise<Signature> {
+    if (proposerAttesterAddress !== undefined) {
+      return (payload: Buffer32) => this.keyStore.signMessageWithAddress(proposerAttesterAddress, payload);
+    } else {
+      // if there is no proposer attester address, just use the first signer
+      const signer = this.keyStore.getAddress(0);
+      return (payload: Buffer32) => this.keyStore.signMessageWithAddress(signer, payload);
+    }
+  }
+
+  /**
+   * Attest with selection of validators to the given checkpoint proposal
    *
    * NOTE: This is just a blind signing.
    *       We assume that the proposal is valid and DA guarantees have been checked previously.
    *
-   * @param proposal - The proposal to attest to
+   * @param proposal - The checkpoint proposal (core version without lastBlock) to attest to
    * @param attestors - The validators to attest with
-   * @returns attestations
+   * @returns checkpoint attestations
    */
-  async attestToProposal(proposal: BlockProposal, attestors: EthAddress[]): Promise<BlockAttestation[]> {
+  async attestToCheckpointProposal(
+    proposal: CheckpointProposalCore,
+    attestors: EthAddress[],
+  ): Promise<CheckpointAttestation[]> {
+    // Create the attestation payload from the checkpoint proposal
+    const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive);
     const buf = Buffer32.fromBuffer(
-      keccak256(proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)),
+      keccak256(payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation)),
     );
     const signatures = await Promise.all(
       attestors.map(attestor => this.keyStore.signMessageWithAddress(attestor, buf)),
     );
-    return signatures.map(sig => new BlockAttestation(proposal.payload, sig, proposal.signature));
+    return signatures.map(sig => new CheckpointAttestation(payload, sig, proposal.signature));
   }
 
   async signAttestationsAndSigners(

package/src/factory.ts

@@ -3,20 +3,22 @@ import type { EpochCache } from '@aztec/epoch-cache';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { KeystoreManager } from '@aztec/node-keystore';
 import { BlockProposalValidator, type P2PClient } from '@aztec/p2p';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { IFullNodeBlockBuilder, ValidatorClientFullConfig } from '@aztec/stdlib/interfaces/server';
+import type { L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
 import { BlockProposalHandler } from './block_proposal_handler.js';
+import type { FullNodeCheckpointsBuilder } from './checkpoint_builder.js';
 import { ValidatorMetrics } from './metrics.js';
 import { ValidatorClient } from './validator.js';
 
 export function createBlockProposalHandler(
   config: ValidatorClientFullConfig,
   deps: {
-    blockBuilder: IFullNodeBlockBuilder;
-    blockSource: L2BlockSource;
+    checkpointsBuilder: FullNodeCheckpointsBuilder;
+    worldState: WorldStateSynchronizer;
+    blockSource: L2BlockSource & L2BlockSink;
     l1ToL2MessageSource: L1ToL2MessageSource;
     p2pClient: P2PClient;
     epochCache: EpochCache;
@@ -29,7 +31,8 @@ export function createBlockProposalHandler(
     txsPermitted: !config.disableTransactions,
   });
   return new BlockProposalHandler(
-    deps.blockBuilder,
+    deps.checkpointsBuilder,
+    deps.worldState,
     deps.blockSource,
     deps.l1ToL2MessageSource,
     deps.p2pClient.getTxProvider(),
@@ -44,9 +47,10 @@ export function createBlockProposalHandler(
 export function createValidatorClient(
   config: ValidatorClientFullConfig,
   deps: {
-    blockBuilder: IFullNodeBlockBuilder;
+    checkpointsBuilder: FullNodeCheckpointsBuilder;
+    worldState: WorldStateSynchronizer;
     p2pClient: P2PClient;
-    blockSource: L2BlockSource;
+    blockSource: L2BlockSource & L2BlockSink;
     l1ToL2MessageSource: L1ToL2MessageSource;
     telemetry: TelemetryClient;
     dateProvider: DateProvider;
@@ -62,7 +66,8 @@ export function createValidatorClient(
   const txProvider = deps.p2pClient.getTxProvider();
   return ValidatorClient.new(
     config,
-    deps.blockBuilder,
+    deps.checkpointsBuilder,
+    deps.worldState,
     deps.epochCache,
     deps.p2pClient,
     deps.blockSource,

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './block_proposal_handler.js';
+export * from './checkpoint_builder.js';
 export * from './config.js';
 export * from './factory.js';
 export * from './validator.js';
 export * from './key_store/index.js';
+export * from './tx_validator/index.js';

package/src/tx_validator/index.ts

@@ -0,0 +1,2 @@
+export * from './nullifier_cache.js';
+export * from './tx_validator_factory.js';

package/src/tx_validator/nullifier_cache.ts

@@ -0,0 +1,30 @@
+import type { NullifierSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+
+/**
+ * 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());
+    }
+  }
+}

package/src/tx_validator/tx_validator_factory.ts

@@ -0,0 +1,133 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import {
+  AggregateTxValidator,
+  ArchiveCache,
+  BlockHeaderTxValidator,
+  DataTxValidator,
+  DoubleSpendTxValidator,
+  GasTxValidator,
+  MetadataTxValidator,
+  PhasesTxValidator,
+  TimestampTxValidator,
+  TxPermittedValidator,
+  TxProofValidator,
+} from '@aztec/p2p';
+import { ProtocolContractAddress, protocolContractsHash } from '@aztec/protocol-contracts';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { GasFees } from '@aztec/stdlib/gas';
+import type {
+  AllowedElement,
+  ClientProtocolCircuitVerifier,
+  MerkleTreeReadOperations,
+  PublicProcessorValidator,
+} from '@aztec/stdlib/interfaces/server';
+import { DatabasePublicStateSource, type PublicStateSource } from '@aztec/stdlib/trees';
+import { GlobalVariables, type Tx, type TxValidator } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+import { NullifierCache } from './nullifier_cache.js';
+
+export function createValidatorForAcceptingTxs(
+  db: MerkleTreeReadOperations,
+  contractDataSource: ContractDataSource,
+  verifier: ClientProtocolCircuitVerifier | undefined,
+  {
+    l1ChainId,
+    rollupVersion,
+    setupAllowList,
+    gasFees,
+    skipFeeEnforcement,
+    timestamp,
+    blockNumber,
+    txsPermitted,
+  }: {
+    l1ChainId: number;
+    rollupVersion: number;
+    setupAllowList: AllowedElement[];
+    gasFees: GasFees;
+    skipFeeEnforcement?: boolean;
+    timestamp: UInt64;
+    blockNumber: BlockNumber;
+    txsPermitted: boolean;
+  },
+): TxValidator<Tx> {
+  const validators: TxValidator<Tx>[] = [
+    new TxPermittedValidator(txsPermitted),
+    new DataTxValidator(),
+    new MetadataTxValidator({
+      l1ChainId: new Fr(l1ChainId),
+      rollupVersion: new Fr(rollupVersion),
+      protocolContractsHash,
+      vkTreeRoot: getVKTreeRoot(),
+    }),
+    new TimestampTxValidator({
+      timestamp,
+      blockNumber,
+    }),
+    new DoubleSpendTxValidator(new NullifierCache(db)),
+    new PhasesTxValidator(contractDataSource, setupAllowList, timestamp),
+    new BlockHeaderTxValidator(new ArchiveCache(db)),
+  ];
+
+  if (!skipFeeEnforcement) {
+    validators.push(new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees));
+  }
+
+  if (verifier) {
+    validators.push(new TxProofValidator(verifier));
+  }
+
+  return new AggregateTxValidator(...validators);
+}
+
+export function createValidatorForBlockBuilding(
+  db: MerkleTreeReadOperations,
+  contractDataSource: ContractDataSource,
+  globalVariables: GlobalVariables,
+  setupAllowList: AllowedElement[],
+): PublicProcessorValidator {
+  const nullifierCache = new NullifierCache(db);
+  const archiveCache = new ArchiveCache(db);
+  const publicStateSource = new DatabasePublicStateSource(db);
+
+  return {
+    preprocessValidator: preprocessValidator(
+      nullifierCache,
+      archiveCache,
+      publicStateSource,
+      contractDataSource,
+      globalVariables,
+      setupAllowList,
+    ),
+    nullifierCache,
+  };
+}
+
+function preprocessValidator(
+  nullifierCache: NullifierCache,
+  archiveCache: ArchiveCache,
+  publicStateSource: PublicStateSource,
+  contractDataSource: ContractDataSource,
+  globalVariables: GlobalVariables,
+  setupAllowList: AllowedElement[],
+): TxValidator<Tx> {
+  // We don't include the TxProofValidator nor the DataTxValidator here because they are already checked by the time we get to block building.
+  return new AggregateTxValidator(
+    new MetadataTxValidator({
+      l1ChainId: globalVariables.chainId,
+      rollupVersion: globalVariables.version,
+      protocolContractsHash,
+      vkTreeRoot: getVKTreeRoot(),
+    }),
+    new TimestampTxValidator({
+      timestamp: globalVariables.timestamp,
+      blockNumber: globalVariables.blockNumber,
+    }),
+    new DoubleSpendTxValidator(nullifierCache),
+    new PhasesTxValidator(contractDataSource, setupAllowList, globalVariables.timestamp),
+    new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, globalVariables.gasFees),
+    new BlockHeaderTxValidator(archiveCache),
+  );
+}