@aztec/validator-client 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/validator.ts

@@ -1,337 +1,856 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { type Blob, getBlobsPerL1Block } from '@aztec/blob-lib';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { Buffer32 } from '@aztec/foundation/buffer';
-import type { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  EpochNumber,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { TimeoutError } from '@aztec/foundation/error';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { type LogData, type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { sleep } from '@aztec/foundation/sleep';
-import { DateProvider, type Timer } from '@aztec/foundation/timer';
-import type { P2P } from '@aztec/p2p';
-import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
-import type { L2Block } from '@aztec/stdlib/block';
-import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
-import type { BlockHeader, GlobalVariables, Tx, TxHash } from '@aztec/stdlib/tx';
-import { type TelemetryClient, WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
-
-import type { ValidatorClientConfig } from './config.js';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { KeystoreManager } from '@aztec/node-keystore';
+import type { P2P, PeerId } from '@aztec/p2p';
+import { AuthRequest, AuthResponse, BlockProposalValidator, ReqRespSubProtocol } from '@aztec/p2p';
+import { OffenseType, WANT_TO_SLASH_EVENT, type Watcher, type WatcherEmitter } from '@aztec/slasher';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CommitteeAttestationsAndSigners, L2Block, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import type {
+  CreateCheckpointProposalLastBlockData,
+  ITxProvider,
+  Validator,
+  ValidatorClientFullConfig,
+  WorldStateSynchronizer,
+} from '@aztec/stdlib/interfaces/server';
+import { type L1ToL2MessageSource, accumulateCheckpointOutHashes } from '@aztec/stdlib/messaging';
+import type {
+  BlockProposal,
+  BlockProposalOptions,
+  CheckpointAttestation,
+  CheckpointProposalCore,
+  CheckpointProposalOptions,
+} from '@aztec/stdlib/p2p';
+import { CheckpointProposal } from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
+import type { BlockHeader, CheckpointGlobalVariables, Tx } from '@aztec/stdlib/tx';
+import { AttestationTimeoutError } from '@aztec/stdlib/validators';
+import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
+import { createHASigner } from '@aztec/validator-ha-signer/factory';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
+
+import { EventEmitter } from 'events';
+import type { TypedDataDefinition } from 'viem';
+
+import { BlockProposalHandler, type BlockProposalValidationFailureReason } from './block_proposal_handler.js';
+import type { FullNodeCheckpointsBuilder } from './checkpoint_builder.js';
 import { ValidationService } from './duties/validation_service.js';
-import {
-  AttestationTimeoutError,
-  BlockBuilderNotProvidedError,
-  InvalidValidatorPrivateKeyError,
-  ReExFailedTxsError,
-  ReExStateMismatchError,
-  ReExTimeoutError,
-  TransactionsNotAvailableError,
-} from './errors/validator.error.js';
-import type { ValidatorKeyStore } from './key_store/interface.js';
-import { LocalKeyStore } from './key_store/local_key_store.js';
+import { HAKeyStore } from './key_store/ha_key_store.js';
+import type { ExtendedValidatorKeyStore } from './key_store/interface.js';
+import { NodeKeystoreAdapter } from './key_store/node_keystore_adapter.js';
 import { ValidatorMetrics } from './metrics.js';
 
-/**
- * Callback function for building a block
- *
- * We reuse the sequencer's block building functionality for re-execution
- */
-type BlockBuilderCallback = (
-  txs: Iterable<Tx> | AsyncIterableIterator<Tx>,
-  globalVariables: GlobalVariables,
-  opts?: { validateOnly?: boolean },
-) => Promise<{
-  block: L2Block;
-  publicProcessorDuration: number;
-  numTxs: number;
-  numFailedTxs: number;
-  blockBuildingTimer: Timer;
-}>;
-
-export interface Validator {
-  start(): Promise<void>;
-  registerBlockProposalHandler(): void;
-  registerBlockBuilder(blockBuilder: BlockBuilderCallback): void;
-
-  // Block validation responsibilities
-  createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal | undefined>;
-  attestToProposal(proposal: BlockProposal): void;
-
-  broadcastBlockProposal(proposal: BlockProposal): void;
-  collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
-}
+// We maintain a set of proposers who have proposed invalid blocks.
+// Just cap the set to avoid unbounded growth.
+const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
+
+// What errors from the block proposal handler result in slashing
+const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT: BlockProposalValidationFailureReason[] = [
+  'state_mismatch',
+  'failed_txs',
+];
 
 /**
  * Validator Client
  */
-export class ValidatorClient extends WithTracer implements Validator {
+export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter) implements Validator, Watcher {
+  public readonly tracer: Tracer;
   private validationService: ValidationService;
   private metrics: ValidatorMetrics;
+  private log: Logger;
+
+  // Whether it has already registered handlers on the p2p client
+  private hasRegisteredHandlers = false;
 
   // Used to check if we are sending the same proposal twice
   private previousProposal?: BlockProposal;
 
-  // Callback registered to: sequencer.buildBlock
-  private blockBuilder?: BlockBuilderCallback = undefined;
-
+  private lastEpochForCommitteeUpdateLoop: EpochNumber | undefined;
   private epochCacheUpdateLoop: RunningPromise;
 
-  private blockProposalValidator: BlockProposalValidator;
+  private proposersOfInvalidBlocks: Set<string> = new Set();
 
-  constructor(
-    private keyStore: ValidatorKeyStore,
+  protected constructor(
+    private keyStore: ExtendedValidatorKeyStore,
     private epochCache: EpochCache,
     private p2pClient: P2P,
-    private config: ValidatorClientConfig,
+    private blockProposalHandler: BlockProposalHandler,
+    private blockSource: L2BlockSource,
+    private checkpointsBuilder: FullNodeCheckpointsBuilder,
+    private worldState: WorldStateSynchronizer,
+    private l1ToL2MessageSource: L1ToL2MessageSource,
+    private config: ValidatorClientFullConfig,
+    private blobClient: BlobClientInterface,
     private dateProvider: DateProvider = new DateProvider(),
     telemetry: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('validator'),
+    log = createLogger('validator'),
   ) {
-    // Instantiate tracer
-    super(telemetry, 'Validator');
+    super();
+
+    // Create child logger with fisherman prefix if in fisherman mode
+    this.log = config.fishermanMode ? log.createChild('[FISHERMAN]') : log;
+
+    this.tracer = telemetry.getTracer('Validator');
     this.metrics = new ValidatorMetrics(telemetry);
 
-    this.validationService = new ValidationService(keyStore);
+    this.validationService = new ValidationService(keyStore, this.log.createChild('validation-service'));
 
-    this.blockProposalValidator = new BlockProposalValidator(epochCache);
+    // Refresh epoch cache every second to trigger alert if participation in committee changes
+    this.epochCacheUpdateLoop = new RunningPromise(this.handleEpochCommitteeUpdate.bind(this), this.log, 1000);
 
-    // Refresh epoch cache every second to trigger commiteeChanged event
-    this.epochCacheUpdateLoop = new RunningPromise(
-      () =>
-        this.epochCache
-          .getCommittee()
-          .then(() => {})
-          .catch(err => log.error('Error updating validator committee', err)),
-      log,
-      1000,
-    );
+    const myAddresses = this.getValidatorAddresses();
+    this.log.verbose(`Initialized validator with addresses: ${myAddresses.map(a => a.toString()).join(', ')}`);
+  }
 
-    // Listen to commiteeChanged event to alert operator when their validator has entered the committee
-    this.epochCache.on('committeeChanged', (newCommittee, epochNumber) => {
-      const me = this.keyStore.getAddress();
-      if (newCommittee.some(addr => addr.equals(me))) {
-        this.log.info(`Validator ${me.toString()} is on the validator committee for epoch ${epochNumber}`);
-      } else {
-        this.log.verbose(`Validator ${me.toString()} not on the validator committee for epoch ${epochNumber}`);
+  public static validateKeyStoreConfiguration(keyStoreManager: KeystoreManager, logger?: Logger) {
+    const validatorKeyStore = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager);
+    const validatorAddresses = validatorKeyStore.getAddresses();
+    // Verify that we can retrieve all required data from the key store
+    for (const address of validatorAddresses) {
+      // Functions throw if required data is not available
+      let coinbase: EthAddress;
+      let feeRecipient: AztecAddress;
+      try {
+        coinbase = validatorKeyStore.getCoinbaseAddress(address);
+        feeRecipient = validatorKeyStore.getFeeRecipient(address);
+      } catch (error) {
+        throw new Error(`Failed to retrieve required data for validator address ${address}, error: ${error}`);
       }
-    });
 
-    this.log.verbose(`Initialized validator with address ${this.keyStore.getAddress().toString()}`);
+      const publisherAddresses = validatorKeyStore.getPublisherAddresses(address);
+      if (!publisherAddresses.length) {
+        throw new Error(`No publisher addresses found for validator address ${address}`);
+      }
+      logger?.debug(
+        `Validator ${address.toString()} configured with coinbase ${coinbase.toString()}, feeRecipient ${feeRecipient.toString()} and publishers ${publisherAddresses.map(x => x.toString()).join()}`,
+      );
+    }
+  }
+
+  private async handleEpochCommitteeUpdate() {
+    try {
+      const { committee, epoch } = await this.epochCache.getCommittee('next');
+      if (!committee) {
+        this.log.trace(`No committee found for slot`);
+        return;
+      }
+      if (epoch !== this.lastEpochForCommitteeUpdateLoop) {
+        const me = this.getValidatorAddresses();
+        const committeeSet = new Set(committee.map(v => v.toString()));
+        const inCommittee = me.filter(a => committeeSet.has(a.toString()));
+        if (inCommittee.length > 0) {
+          this.log.info(
+            `Validators ${inCommittee.map(a => a.toString()).join(',')} are on the validator committee for epoch ${epoch}`,
+          );
+        } else {
+          this.log.verbose(
+            `Validators ${me.map(a => a.toString()).join(', ')} are not on the validator committee for epoch ${epoch}`,
+          );
+        }
+        this.lastEpochForCommitteeUpdateLoop = epoch;
+      }
+    } catch (err) {
+      this.log.error(`Error updating epoch committee`, err);
+    }
   }
 
-  static new(
-    config: ValidatorClientConfig,
+  static async new(
+    config: ValidatorClientFullConfig,
+    checkpointsBuilder: FullNodeCheckpointsBuilder,
+    worldState: WorldStateSynchronizer,
     epochCache: EpochCache,
     p2pClient: P2P,
+    blockSource: L2BlockSource & L2BlockSink,
+    l1ToL2MessageSource: L1ToL2MessageSource,
+    txProvider: ITxProvider,
+    keyStoreManager: KeystoreManager,
+    blobClient: BlobClientInterface,
     dateProvider: DateProvider = new DateProvider(),
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {
-    if (!config.validatorPrivateKey) {
-      throw new InvalidValidatorPrivateKeyError();
+    const metrics = new ValidatorMetrics(telemetry);
+    const blockProposalValidator = new BlockProposalValidator(epochCache, {
+      txsPermitted: !config.disableTransactions,
+    });
+    const blockProposalHandler = new BlockProposalHandler(
+      checkpointsBuilder,
+      worldState,
+      blockSource,
+      l1ToL2MessageSource,
+      txProvider,
+      blockProposalValidator,
+      epochCache,
+      config,
+      metrics,
+      dateProvider,
+      telemetry,
+    );
+
+    let validatorKeyStore: ExtendedValidatorKeyStore = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager);
+    if (config.haSigningEnabled) {
+      // If maxStuckDutiesAgeMs is not explicitly set, compute it from Aztec slot duration
+      const haConfig = {
+        ...config,
+        maxStuckDutiesAgeMs: config.maxStuckDutiesAgeMs ?? epochCache.getL1Constants().slotDuration * 2 * 1000,
+      };
+      const { signer } = await createHASigner(haConfig);
+      validatorKeyStore = new HAKeyStore(validatorKeyStore, signer);
     }
 
-    const privateKey = validatePrivateKey(config.validatorPrivateKey);
-    const localKeyStore = new LocalKeyStore(privateKey);
+    const validator = new ValidatorClient(
+      validatorKeyStore,
+      epochCache,
+      p2pClient,
+      blockProposalHandler,
+      blockSource,
+      checkpointsBuilder,
+      worldState,
+      l1ToL2MessageSource,
+      config,
+      blobClient,
+      dateProvider,
+      telemetry,
+    );
 
-    const validator = new ValidatorClient(localKeyStore, epochCache, p2pClient, config, dateProvider, telemetry);
-    validator.registerBlockProposalHandler();
     return validator;
   }
 
+  public getValidatorAddresses() {
+    return this.keyStore
+      .getAddresses()
+      .filter(addr => !this.config.disabledValidators.some(disabled => disabled.equals(addr)));
+  }
+
+  public getBlockProposalHandler() {
+    return this.blockProposalHandler;
+  }
+
+  public signWithAddress(addr: EthAddress, msg: TypedDataDefinition, context: SigningContext) {
+    return this.keyStore.signTypedDataWithAddress(addr, msg, context);
+  }
+
+  public getCoinbaseForAttestor(attestor: EthAddress): EthAddress {
+    return this.keyStore.getCoinbaseAddress(attestor);
+  }
+
+  public getFeeRecipientForAttestor(attestor: EthAddress): AztecAddress {
+    return this.keyStore.getFeeRecipient(attestor);
+  }
+
+  public getConfig(): ValidatorClientFullConfig {
+    return this.config;
+  }
+
+  public updateConfig(config: Partial<ValidatorClientFullConfig>) {
+    this.config = { ...this.config, ...config };
+  }
+
   public async start() {
-    // Sync the committee from the smart contract
-    // https://github.com/AztecProtocol/aztec-packages/issues/7962
+    if (this.epochCacheUpdateLoop.isRunning()) {
+      this.log.warn(`Validator client already started`);
+      return;
+    }
 
-    const me = this.keyStore.getAddress();
-    const inCommittee = await this.epochCache.isInCommittee(me);
-    if (inCommittee) {
-      this.log.info(`Started validator with address ${me.toString()} in current validator committee`);
-    } else {
-      this.log.info(`Started validator with address ${me.toString()}`);
+    await this.keyStore.start();
+
+    await this.registerHandlers();
+
+    const myAddresses = this.getValidatorAddresses();
+    const inCommittee = await this.epochCache.filterInCommittee('now', myAddresses);
+    this.log.info(`Started validator with addresses: ${myAddresses.map(a => a.toString()).join(', ')}`);
+    if (inCommittee.length > 0) {
+      this.log.info(`Addresses in current validator committee: ${inCommittee.map(a => a.toString()).join(', ')}`);
     }
     this.epochCacheUpdateLoop.start();
+
     return Promise.resolve();
   }
 
   public async stop() {
     await this.epochCacheUpdateLoop.stop();
+    await this.keyStore.stop();
   }
 
-  public registerBlockProposalHandler() {
-    const handler = (block: BlockProposal): Promise<BlockAttestation | undefined> => {
-      return this.attestToProposal(block);
-    };
-    this.p2pClient.registerBlockProposalHandler(handler);
+  /** Register handlers on the p2p client */
+  public async registerHandlers() {
+    if (!this.hasRegisteredHandlers) {
+      this.hasRegisteredHandlers = true;
+      this.log.debug(`Registering validator handlers for p2p client`);
+
+      // Block proposal handler - validates but does NOT attest (validators only attest to checkpoints)
+      const blockHandler = (block: BlockProposal, proposalSender: PeerId): Promise<boolean> =>
+        this.validateBlockProposal(block, proposalSender);
+      this.p2pClient.registerBlockProposalHandler(blockHandler);
+
+      // Checkpoint proposal handler - validates and creates attestations
+      // The checkpoint is received as CheckpointProposalCore since the lastBlock is extracted
+      // and processed separately via the block handler above.
+      const checkpointHandler = (
+        checkpoint: CheckpointProposalCore,
+        proposalSender: PeerId,
+      ): Promise<CheckpointAttestation[] | undefined> => this.attestToCheckpointProposal(checkpoint, proposalSender);
+      this.p2pClient.registerCheckpointProposalHandler(checkpointHandler);
+
+      const myAddresses = this.getValidatorAddresses();
+      this.p2pClient.registerThisValidatorAddresses(myAddresses);
+
+      await this.p2pClient.addReqRespSubProtocol(ReqRespSubProtocol.AUTH, this.handleAuthRequest.bind(this));
+    }
   }
 
   /**
-   * Register a callback function for building a block
-   *
-   * We reuse the sequencer's block building functionality for re-execution
+   * Validate a block proposal from a peer.
+   * Note: Validators do NOT attest to individual blocks - attestations are only for checkpoint proposals.
+   * @returns true if the proposal is valid, false otherwise
    */
-  public registerBlockBuilder(blockBuilder: BlockBuilderCallback) {
-    this.blockBuilder = blockBuilder;
+  async validateBlockProposal(proposal: BlockProposal, proposalSender: PeerId): Promise<boolean> {
+    const slotNumber = proposal.slotNumber;
+
+    // Note: During escape hatch, we still want to "validate" proposals for observability,
+    // but we intentionally reject them and disable slashing invalid block and attestation flow.
+    const escapeHatchOpen = await this.epochCache.isEscapeHatchOpenAtSlot(slotNumber);
+
+    const proposer = proposal.getSender();
+
+    // Reject proposals with invalid signatures
+    if (!proposer) {
+      this.log.warn(`Received block proposal with invalid signature for slot ${slotNumber}`);
+      return false;
+    }
+
+    // Check if we're in the committee (for metrics purposes)
+    const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
+    const partOfCommittee = inCommittee.length > 0;
+
+    const proposalInfo = { ...proposal.toBlockInfo(), proposer: proposer.toString() };
+    this.log.info(`Received block proposal for slot ${slotNumber}`, {
+      ...proposalInfo,
+      txHashes: proposal.txHashes.map(t => t.toString()),
+      fishermanMode: this.config.fishermanMode || false,
+    });
+
+    // Reexecute txs if we are part of the committee, or if slashing is enabled, or if we are configured to always reexecute.
+    // In fisherman mode, we always reexecute to validate proposals.
+    const { validatorReexecute, slashBroadcastedInvalidBlockPenalty, alwaysReexecuteBlockProposals, fishermanMode } =
+      this.config;
+    const shouldReexecute =
+      fishermanMode ||
+      (slashBroadcastedInvalidBlockPenalty > 0n && validatorReexecute) ||
+      (partOfCommittee && validatorReexecute) ||
+      alwaysReexecuteBlockProposals ||
+      this.blobClient.canUpload();
+
+    const validationResult = await this.blockProposalHandler.handleBlockProposal(
+      proposal,
+      proposalSender,
+      !!shouldReexecute && !escapeHatchOpen,
+    );
+
+    if (!validationResult.isValid) {
+      this.log.warn(`Block proposal validation failed: ${validationResult.reason}`, proposalInfo);
+
+      const reason = validationResult.reason || 'unknown';
+      // Classify failure reason: bad proposal vs node issue
+      const badProposalReasons: BlockProposalValidationFailureReason[] = [
+        'invalid_proposal',
+        'state_mismatch',
+        'failed_txs',
+        'in_hash_mismatch',
+        'parent_block_wrong_slot',
+      ];
+
+      if (badProposalReasons.includes(reason as BlockProposalValidationFailureReason)) {
+        this.metrics.incFailedAttestationsBadProposal(1, reason, partOfCommittee);
+      } else {
+        // Node issues so we can't validate
+        this.metrics.incFailedAttestationsNodeIssue(1, reason, partOfCommittee);
+      }
+
+      // Slash invalid block proposals (can happen even when not in committee)
+      if (
+        !escapeHatchOpen &&
+        validationResult.reason &&
+        SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT.includes(validationResult.reason) &&
+        slashBroadcastedInvalidBlockPenalty > 0n
+      ) {
+        this.log.warn(`Slashing proposer for invalid block proposal`, proposalInfo);
+        this.slashInvalidBlock(proposal);
+      }
+      return false;
+    }
+
+    this.log.info(`Validated block proposal for slot ${slotNumber}`, {
+      ...proposalInfo,
+      inCommittee: partOfCommittee,
+      fishermanMode: this.config.fishermanMode || false,
+      escapeHatchOpen,
+    });
+
+    if (escapeHatchOpen) {
+      this.log.warn(`Escape hatch open for slot ${slotNumber}, rejecting block proposal`, proposalInfo);
+      return false;
+    }
+
+    return true;
   }
 
-  async attestToProposal(proposal: BlockProposal): Promise<BlockAttestation | undefined> {
-    const slotNumber = proposal.slotNumber.toNumber();
+  /**
+   * Validate and attest to a checkpoint proposal from a peer.
+   * The proposal is received as CheckpointProposalCore (without lastBlock) since
+   * the lastBlock is extracted and processed separately via the block handler.
+   * @returns Checkpoint attestations if valid, undefined otherwise
+   */
+  async attestToCheckpointProposal(
+    proposal: CheckpointProposalCore,
+    _proposalSender: PeerId,
+  ): Promise<CheckpointAttestation[] | undefined> {
+    const slotNumber = proposal.slotNumber;
+    const proposer = proposal.getSender();
+
+    // If escape hatch is open for this slot's epoch, do not attest.
+    if (await this.epochCache.isEscapeHatchOpenAtSlot(slotNumber)) {
+      this.log.warn(`Escape hatch open for slot ${slotNumber}, skipping checkpoint attestation handling`);
+      return undefined;
+    }
+
+    // Reject proposals with invalid signatures
+    if (!proposer) {
+      this.log.warn(`Received checkpoint proposal with invalid signature for slot ${slotNumber}`);
+      return undefined;
+    }
+
+    // Check that I have any address in current committee before attesting
+    const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
+    const partOfCommittee = inCommittee.length > 0;
+
     const proposalInfo = {
       slotNumber,
-      blockNumber: proposal.payload.header.globalVariables.blockNumber.toNumber(),
-      archive: proposal.payload.archive.toString(),
-      txCount: proposal.payload.txHashes.length,
-      txHashes: proposal.payload.txHashes.map(txHash => txHash.toString()),
+      archive: proposal.archive.toString(),
+      proposer: proposer.toString(),
+      txCount: proposal.txHashes.length,
     };
-    this.log.verbose(`Received request to attest for slot ${slotNumber}`);
+    this.log.info(`Received checkpoint proposal for slot ${slotNumber}`, {
+      ...proposalInfo,
+      txHashes: proposal.txHashes.map(t => t.toString()),
+      fishermanMode: this.config.fishermanMode || false,
+    });
 
-    // Check that I am in the committee
-    if (!(await this.epochCache.isInCommittee(this.keyStore.getAddress()))) {
-      this.log.verbose(`Not in the committee, skipping attestation`);
-      return undefined;
+    // Validate the checkpoint proposal before attesting (unless skipCheckpointProposalValidation is set)
+    if (this.config.skipCheckpointProposalValidation) {
+      this.log.warn(`Skipping checkpoint proposal validation for slot ${slotNumber}`, proposalInfo);
+    } else {
+      const validationResult = await this.validateCheckpointProposal(proposal, proposalInfo);
+      if (!validationResult.isValid) {
+        this.log.warn(`Checkpoint proposal validation failed: ${validationResult.reason}`, proposalInfo);
+        return undefined;
+      }
     }
 
-    // Check that the proposal is from the current proposer, or the next proposer.
-    const invalidProposal = await this.blockProposalValidator.validate(proposal);
-    if (invalidProposal) {
-      this.log.verbose(`Proposal is not valid, skipping attestation`);
+    // Upload blobs to filestore if we can (fire and forget)
+    if (this.blobClient.canUpload()) {
+      void this.uploadBlobsForCheckpoint(proposal, proposalInfo);
+    }
+
+    // Check that I have any address in current committee before attesting
+    // In fisherman mode, we still create attestations for validation even if not in committee
+    if (!partOfCommittee && !this.config.fishermanMode) {
+      this.log.verbose(`No validator in the current committee, skipping attestation`, proposalInfo);
       return undefined;
     }
 
-    // Check that all of the transactions in the proposal are available in the tx pool before attesting
-    this.log.verbose(`Processing attestation for slot ${slotNumber}`, proposalInfo);
-    try {
-      await this.ensureTransactionsAreAvailable(proposal);
+    // Provided all of the above checks pass, we can attest to the proposal
+    this.log.info(`${partOfCommittee ? 'Attesting to' : 'Validated'} checkpoint proposal for slot ${slotNumber}`, {
+      ...proposalInfo,
+      inCommittee: partOfCommittee,
+      fishermanMode: this.config.fishermanMode || false,
+    });
 
-      if (this.config.validatorReexecute) {
-        this.log.verbose(`Re-executing transactions in the proposal before attesting`);
-        await this.reExecuteTransactions(proposal);
-      }
-    } catch (error: any) {
-      // If the transactions are not available, then we should not attempt to attest
-      if (error instanceof TransactionsNotAvailableError) {
-        this.log.error(`Transactions not available, skipping attestation`, error, proposalInfo);
-      } else {
-        // This branch most commonly be hit if the transactions are available, but the re-execution fails
-        // Catch all error handler
-        this.log.error(`Failed to attest to proposal`, error, proposalInfo);
-      }
+    this.metrics.incSuccessfulAttestations(inCommittee.length);
+
+    // Determine which validators should attest
+    let attestors: EthAddress[];
+    if (partOfCommittee) {
+      attestors = inCommittee;
+    } else if (this.config.fishermanMode) {
+      // In fisherman mode, create attestations for validation purposes even if not in committee. These won't be broadcast.
+      attestors = this.getValidatorAddresses();
+    } else {
+      attestors = [];
+    }
+
+    // Only create attestations if we have attestors
+    if (attestors.length === 0) {
       return undefined;
     }
 
-    // Provided all of the above checks pass, we can attest to the proposal
-    this.log.info(`Attesting to proposal for slot ${slotNumber}`, proposalInfo);
+    if (this.config.fishermanMode) {
+      // bail out early and don't save attestations to the pool in fisherman mode
+      this.log.info(`Creating checkpoint attestations for slot ${slotNumber}`, {
+        ...proposalInfo,
+        attestors: attestors.map(a => a.toString()),
+      });
+      return undefined;
+    }
+
+    return this.createCheckpointAttestationsFromProposal(proposal, attestors);
+  }
 
-    // If the above function does not throw an error, then we can attest to the proposal
-    return this.validationService.attestToProposal(proposal);
+  private async createCheckpointAttestationsFromProposal(
+    proposal: CheckpointProposalCore,
+    attestors: EthAddress[] = [],
+  ): Promise<CheckpointAttestation[]> {
+    const attestations = await this.validationService.attestToCheckpointProposal(proposal, attestors);
+    await this.p2pClient.addCheckpointAttestations(attestations);
+    return attestations;
   }
 
   /**
-   * Re-execute the transactions in the proposal and check that the state updates match the header state
-   * @param proposal - The proposal to re-execute
+   * Validates a checkpoint proposal by building the full checkpoint and comparing it with the proposal.
+   * @returns Validation result with isValid flag and reason if invalid.
    */
-  async reExecuteTransactions(proposal: BlockProposal) {
-    const { header, txHashes } = proposal.payload;
-
-    const txs = (await Promise.all(txHashes.map(tx => this.p2pClient.getTxByHash(tx)))).filter(
-      tx => tx !== undefined,
-    ) as Tx[];
+  private async validateCheckpointProposal(
+    proposal: CheckpointProposalCore,
+    proposalInfo: LogData,
+  ): Promise<{ isValid: true } | { isValid: false; reason: string }> {
+    const slot = proposal.slotNumber;
+    const timeoutSeconds = 10; // TODO(palla/mbps): This should map to the timetable settings
+
+    // Wait for last block to sync by archive
+    let lastBlockHeader: BlockHeader | undefined;
+    try {
+      lastBlockHeader = await retryUntil(
+        async () => {
+          await this.blockSource.syncImmediate();
+          return this.blockSource.getBlockHeaderByArchive(proposal.archive);
+        },
+        `waiting for block with archive ${proposal.archive.toString()} for slot ${slot}`,
+        timeoutSeconds,
+        0.5,
+      );
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        this.log.warn(`Timed out waiting for block with archive matching checkpoint proposal`, proposalInfo);
+        return { isValid: false, reason: 'last_block_not_found' };
+      }
+      this.log.error(`Error fetching last block for checkpoint proposal`, err, proposalInfo);
+      return { isValid: false, reason: 'block_fetch_error' };
+    }
 
-    // If we cannot request all of the transactions, then we should fail
-    if (txs.length !== txHashes.length) {
-      throw new TransactionsNotAvailableError(txHashes);
+    if (!lastBlockHeader) {
+      this.log.warn(`Last block not found for checkpoint proposal`, proposalInfo);
+      return { isValid: false, reason: 'last_block_not_found' };
     }
 
-    // Assertion: This check will fail if re-execution is not enabled
-    if (this.blockBuilder === undefined) {
-      throw new BlockBuilderNotProvidedError();
+    // Get all full blocks for the slot and checkpoint
+    const blocks = await this.blockSource.getBlocksForSlot(slot);
+    if (blocks.length === 0) {
+      this.log.warn(`No blocks found for slot ${slot}`, proposalInfo);
+      return { isValid: false, reason: 'no_blocks_for_slot' };
     }
 
-    // Use the sequencer's block building logic to re-execute the transactions
-    const stopTimer = this.metrics.reExecutionTimer();
-    const { block, numFailedTxs } = await this.blockBuilder(txs, header.globalVariables, {
-      validateOnly: true,
+    this.log.debug(`Found ${blocks.length} blocks for slot ${slot}`, {
+      ...proposalInfo,
+      blockNumbers: blocks.map(b => b.number),
     });
-    stopTimer();
 
-    this.log.verbose(`Transaction re-execution complete`);
+    // Get checkpoint constants from first block
+    const firstBlock = blocks[0];
+    const constants = this.extractCheckpointConstants(firstBlock);
+    const checkpointNumber = firstBlock.checkpointNumber;
 
-    if (numFailedTxs > 0) {
-      await this.metrics.recordFailedReexecution(proposal);
-      throw new ReExFailedTxsError(numFailedTxs);
-    }
+    // Get L1-to-L2 messages for this checkpoint
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
 
-    if (block.body.txEffects.length !== txHashes.length) {
-      await this.metrics.recordFailedReexecution(proposal);
-      throw new ReExTimeoutError();
-    }
+    // Compute the previous checkpoint out hashes for the epoch.
+    // TODO: There can be a more efficient way to get the previous checkpoint out hashes without having to fetch the
+    // actual checkpoints and the blocks/txs in them.
+    const epoch = getEpochAtSlot(slot, this.epochCache.getL1Constants());
+    const previousCheckpoints = (await this.blockSource.getCheckpointsForEpoch(epoch))
+      .filter(b => b.number < checkpointNumber)
+      .sort((a, b) => a.number - b.number);
+    const previousCheckpointOutHashes = previousCheckpoints.map(c => c.getCheckpointOutHash());
+
+    // Fork world state at the block before the first block
+    const parentBlockNumber = BlockNumber(firstBlock.number - 1);
+    const fork = await this.worldState.fork(parentBlockNumber);
+
+    try {
+      // Create checkpoint builder with all existing blocks
+      const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(
+        checkpointNumber,
+        constants,
+        l1ToL2Messages,
+        previousCheckpointOutHashes,
+        fork,
+        blocks,
+        this.log.getBindings(),
+      );
+
+      // Complete the checkpoint to get computed values
+      const computedCheckpoint = await checkpointBuilder.completeCheckpoint();
+
+      // Compare checkpoint header with proposal
+      if (!computedCheckpoint.header.equals(proposal.checkpointHeader)) {
+        this.log.warn(`Checkpoint header mismatch`, {
+          ...proposalInfo,
+          computed: computedCheckpoint.header.toInspect(),
+          proposal: proposal.checkpointHeader.toInspect(),
+        });
+        return { isValid: false, reason: 'checkpoint_header_mismatch' };
+      }
 
-    // This function will throw an error if state updates do not match
-    if (!block.archive.root.equals(proposal.archive)) {
-      await this.metrics.recordFailedReexecution(proposal);
-      throw new ReExStateMismatchError();
+      // Compare archive root with proposal
+      if (!computedCheckpoint.archive.root.equals(proposal.archive)) {
+        this.log.warn(`Archive root mismatch`, {
+          ...proposalInfo,
+          computed: computedCheckpoint.archive.root.toString(),
+          proposal: proposal.archive.toString(),
+        });
+        return { isValid: false, reason: 'archive_mismatch' };
+      }
+
+      // Check that the accumulated epoch out hash matches the value in the proposal.
+      // The epoch out hash is the accumulated hash of all checkpoint out hashes in the epoch.
+      const checkpointOutHash = computedCheckpoint.getCheckpointOutHash();
+      const computedEpochOutHash = accumulateCheckpointOutHashes([...previousCheckpointOutHashes, checkpointOutHash]);
+      const proposalEpochOutHash = proposal.checkpointHeader.epochOutHash;
+      if (!computedEpochOutHash.equals(proposalEpochOutHash)) {
+        this.log.warn(`Epoch out hash mismatch`, {
+          proposalEpochOutHash: proposalEpochOutHash.toString(),
+          computedEpochOutHash: computedEpochOutHash.toString(),
+          checkpointOutHash: checkpointOutHash.toString(),
+          previousCheckpointOutHashes: previousCheckpointOutHashes.map(h => h.toString()),
+          ...proposalInfo,
+        });
+        return { isValid: false, reason: 'out_hash_mismatch' };
+      }
+
+      this.log.verbose(`Checkpoint proposal validation successful for slot ${slot}`, proposalInfo);
+      return { isValid: true };
+    } finally {
+      await fork.close();
     }
   }
 
   /**
-   * Ensure that all of the transactions in the proposal are available in the tx pool before attesting
-   *
-   * 1. Check if the local tx pool contains all of the transactions in the proposal
-   * 2. If any transactions are not in the local tx pool, request them from the network
-   * 3. If we cannot retrieve them from the network, throw an error
-   * @param proposal - The proposal to attest to
+   * Extract checkpoint global variables from a block.
    */
-  async ensureTransactionsAreAvailable(proposal: BlockProposal) {
-    const txHashes: TxHash[] = proposal.payload.txHashes;
-    const transactionStatuses = await Promise.all(txHashes.map(txHash => this.p2pClient.getTxStatus(txHash)));
+  private extractCheckpointConstants(block: L2Block): CheckpointGlobalVariables {
+    const gv = block.header.globalVariables;
+    return {
+      chainId: gv.chainId,
+      version: gv.version,
+      slotNumber: gv.slotNumber,
+      coinbase: gv.coinbase,
+      feeRecipient: gv.feeRecipient,
+      gasFees: gv.gasFees,
+    };
+  }
 
-    const missingTxs = txHashes.filter((_, index) => !['pending', 'mined'].includes(transactionStatuses[index] ?? ''));
+  /**
+   * Uploads blobs for a checkpoint to the filestore (fire and forget).
+   */
+  private async uploadBlobsForCheckpoint(proposal: CheckpointProposalCore, proposalInfo: LogData): Promise<void> {
+    try {
+      const lastBlockHeader = await this.blockSource.getBlockHeaderByArchive(proposal.archive);
+      if (!lastBlockHeader) {
+        this.log.warn(`Failed to get last block header for blob upload`, proposalInfo);
+        return;
+      }
 
-    if (missingTxs.length === 0) {
-      return; // All transactions are available
+      const blocks = await this.blockSource.getBlocksForSlot(proposal.slotNumber);
+      if (blocks.length === 0) {
+        this.log.warn(`No blocks found for blob upload`, proposalInfo);
+        return;
+      }
+
+      const blobFields = blocks.flatMap(b => b.toBlobFields());
+      const blobs: Blob[] = getBlobsPerL1Block(blobFields);
+      await this.blobClient.sendBlobsToFilestore(blobs);
+      this.log.debug(`Uploaded ${blobs.length} blobs to filestore for checkpoint at slot ${proposal.slotNumber}`, {
+        ...proposalInfo,
+        numBlobs: blobs.length,
+      });
+    } catch (err) {
+      this.log.warn(`Failed to upload blobs for checkpoint: ${err}`, proposalInfo);
     }
+  }
 
-    this.log.verbose(`Missing ${missingTxs.length} transactions in the tx pool, requesting from the network`);
+  private slashInvalidBlock(proposal: BlockProposal) {
+    const proposer = proposal.getSender();
 
-    const requestedTxs = await this.p2pClient.requestTxs(missingTxs);
-    if (requestedTxs.some(tx => tx === undefined)) {
-      throw new TransactionsNotAvailableError(missingTxs);
+    // Skip if signature is invalid (shouldn't happen since we validate earlier)
+    if (!proposer) {
+      this.log.warn(`Cannot slash proposal with invalid signature`);
+      return;
     }
-  }
 
-  async createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal | undefined> {
-    if (this.previousProposal?.slotNumber.equals(header.globalVariables.slotNumber)) {
-      this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
-      return Promise.resolve(undefined);
+    // Trim the set if it's too big.
+    if (this.proposersOfInvalidBlocks.size > MAX_PROPOSERS_OF_INVALID_BLOCKS) {
+      // remove oldest proposer. `values` is guaranteed to be in insertion order.
+      this.proposersOfInvalidBlocks.delete(this.proposersOfInvalidBlocks.values().next().value!);
     }
 
-    const newProposal = await this.validationService.createBlockProposal(header, archive, txs);
+    this.proposersOfInvalidBlocks.add(proposer.toString());
+
+    this.emit(WANT_TO_SLASH_EVENT, [
+      {
+        validator: proposer,
+        amount: this.config.slashBroadcastedInvalidBlockPenalty,
+        offenseType: OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL,
+        epochOrSlot: BigInt(proposal.slotNumber),
+      },
+    ]);
+  }
+
+  async createBlockProposal(
+    blockHeader: BlockHeader,
+    indexWithinCheckpoint: IndexWithinCheckpoint,
+    inHash: Fr,
+    archive: Fr,
+    txs: Tx[],
+    proposerAddress: EthAddress | undefined,
+    options: BlockProposalOptions = {},
+  ): Promise<BlockProposal> {
+    // TODO(palla/mbps): Prevent double proposals properly
+    // if (this.previousProposal?.slotNumber === blockHeader.globalVariables.slotNumber) {
+    //   this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
+    //   return Promise.resolve(undefined);
+    // }
+
+    this.log.info(
+      `Assembling block proposal for block ${blockHeader.globalVariables.blockNumber} slot ${blockHeader.globalVariables.slotNumber}`,
+    );
+    const newProposal = await this.validationService.createBlockProposal(
+      blockHeader,
+      indexWithinCheckpoint,
+      inHash,
+      archive,
+      txs,
+      proposerAddress,
+      {
+        ...options,
+        broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal,
+      },
+    );
     this.previousProposal = newProposal;
     return newProposal;
   }
 
-  broadcastBlockProposal(proposal: BlockProposal): void {
-    this.p2pClient.broadcastProposal(proposal);
+  async createCheckpointProposal(
+    checkpointHeader: CheckpointHeader,
+    archive: Fr,
+    lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
+    proposerAddress: EthAddress | undefined,
+    options: CheckpointProposalOptions = {},
+  ): Promise<CheckpointProposal> {
+    this.log.info(`Assembling checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
+    return await this.validationService.createCheckpointProposal(
+      checkpointHeader,
+      archive,
+      lastBlockInfo,
+      proposerAddress,
+      options,
+    );
+  }
+
+  async broadcastBlockProposal(proposal: BlockProposal): Promise<void> {
+    await this.p2pClient.broadcastProposal(proposal);
+  }
+
+  async signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+    slot: SlotNumber,
+    blockNumber: BlockNumber | CheckpointNumber,
+  ): Promise<Signature> {
+    return await this.validationService.signAttestationsAndSigners(attestationsAndSigners, proposer, slot, blockNumber);
   }
 
-  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962)
-  async collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]> {
-    // Wait and poll the p2pClient's attestation pool for this block until we have enough attestations
-    const slot = proposal.payload.header.globalVariables.slotNumber.toBigInt();
+  async collectOwnAttestations(proposal: CheckpointProposal): Promise<CheckpointAttestation[]> {
+    const slot = proposal.slotNumber;
+    const inCommittee = await this.epochCache.filterInCommittee(slot, this.getValidatorAddresses());
+    this.log.debug(`Collecting ${inCommittee.length} self-attestations for slot ${slot}`, { inCommittee });
+    const attestations = await this.createCheckpointAttestationsFromProposal(proposal, inCommittee);
+
+    // We broadcast our own attestations to our peers so, in case our block does not get mined on L1,
+    // other nodes can see that our validators did attest to this block proposal, and do not slash us
+    // due to inactivity for missed attestations.
+    void this.p2pClient.broadcastCheckpointAttestations(attestations).catch(err => {
+      this.log.error(`Failed to broadcast self-attestations for slot ${slot}`, err);
+    });
+    return attestations;
+  }
+
+  async collectAttestations(
+    proposal: CheckpointProposal,
+    required: number,
+    deadline: Date,
+  ): Promise<CheckpointAttestation[]> {
+    // Wait and poll the p2pClient's attestation pool for this checkpoint until we have enough attestations
+    const slot = proposal.slotNumber;
     this.log.debug(`Collecting ${required} attestations for slot ${slot} with deadline ${deadline.toISOString()}`);
 
     if (+deadline < this.dateProvider.now()) {
       this.log.error(
         `Deadline ${deadline.toISOString()} for collecting ${required} attestations for slot ${slot} is in the past`,
       );
-      throw new AttestationTimeoutError(required, slot);
+      throw new AttestationTimeoutError(0, required, slot);
     }
 
+    await this.collectOwnAttestations(proposal);
+
     const proposalId = proposal.archive.toString();
-    const myAttestation = await this.validationService.attestToProposal(proposal);
+    const myAddresses = this.getValidatorAddresses();
 
-    let attestations: BlockAttestation[] = [];
+    let attestations: CheckpointAttestation[] = [];
     while (true) {
-      const collectedAttestations = [myAttestation, ...(await this.p2pClient.getAttestationsForSlot(slot, proposalId))];
-      const oldSenders = await Promise.all(attestations.map(attestation => attestation.getSender()));
+      // Filter out attestations with a mismatching archive. This should NOT happen since we have verified
+      // the proposer signature (ie our own) before accepting the attestation into the pool via the p2p client.
+      const collectedAttestations = (await this.p2pClient.getCheckpointAttestationsForSlot(slot, proposalId)).filter(
+        attestation => {
+          if (!attestation.archive.equals(proposal.archive)) {
+            this.log.warn(
+              `Received attestation for slot ${slot} with mismatched archive from ${attestation.getSender()?.toString()}`,
+              { attestationArchive: attestation.archive.toString(), proposalArchive: proposal.archive.toString() },
+            );
+            return false;
+          }
+          return true;
+        },
+      );
+
+      // Log new attestations we collected
+      const oldSenders = attestations.map(attestation => attestation.getSender());
       for (const collected of collectedAttestations) {
-        const collectedSender = await collected.getSender();
-        if (!oldSenders.some(sender => sender.equals(collectedSender))) {
+        const collectedSender = collected.getSender();
+        // Skip attestations with invalid signatures
+        if (!collectedSender) {
+          this.log.warn(`Skipping attestation with invalid signature for slot ${slot}`);
+          continue;
+        }
+        if (
+          !myAddresses.some(address => address.equals(collectedSender)) &&
+          !oldSenders.some(sender => sender?.equals(collectedSender))
+        ) {
           this.log.debug(`Received attestation for slot ${slot} from ${collectedSender.toString()}`);
         }
       }
@@ -344,19 +863,36 @@ export class ValidatorClient extends WithTracer implements Validator {
 
       if (+deadline < this.dateProvider.now()) {
         this.log.error(`Timeout ${deadline.toISOString()} waiting for ${required} attestations for slot ${slot}`);
-        throw new AttestationTimeoutError(required, slot);
+        throw new AttestationTimeoutError(attestations.length, required, slot);
       }
 
-      this.log.debug(`Collected ${attestations.length} attestations so far`);
+      this.log.debug(`Collected ${attestations.length} of ${required} attestations so far`);
       await sleep(this.config.attestationPollingIntervalMs);
     }
   }
-}
 
-function validatePrivateKey(privateKey: string): Buffer32 {
-  try {
-    return Buffer32.fromString(privateKey);
-  } catch (error) {
-    throw new InvalidValidatorPrivateKeyError();
+  private async handleAuthRequest(peer: PeerId, msg: Buffer): Promise<Buffer> {
+    const authRequest = AuthRequest.fromBuffer(msg);
+    const statusMessage = await this.p2pClient.handleAuthRequestFromPeer(authRequest, peer).catch(_ => undefined);
+    if (statusMessage === undefined) {
+      return Buffer.alloc(0);
+    }
+
+    // Find a validator address that is in the set
+    const allRegisteredValidators = await this.epochCache.getRegisteredValidators();
+    const addressToUse = this.getValidatorAddresses().find(
+      address => allRegisteredValidators.find(v => v.equals(address)) !== undefined,
+    );
+    if (addressToUse === undefined) {
+      // We don't have a registered address
+      return Buffer.alloc(0);
+    }
+
+    const payloadToSign = authRequest.getPayloadToSign();
+    // AUTH_REQUEST doesn't require HA protection - multiple signatures are safe
+    const context: SigningContext = { dutyType: DutyType.AUTH_REQUEST };
+    const signature = await this.keyStore.signMessageWithAddress(addressToUse, payloadToSign, context);
+    const authResponse = new AuthResponse(statusMessage, signature);
+    return authResponse.toBuffer();
   }
 }