@aztec/p2p 4.0.0-nightly.20260111 → 4.0.0-nightly.20260113

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,71 +1,120 @@
 import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
-import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposal,
+  CheckpointProposalCore,
+} from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
+import { ProposalSlotCapExceededError } from '../../errors/attestation-pool.error.js';
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import type { AttestationPool } from './attestation_pool.js';
 import { ATTESTATION_CAP_BUFFER, MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
 
 export class InMemoryAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<BlockAttestation>;
+  private metrics: PoolInstrumentation<CheckpointAttestation>;
 
+  private proposals: Map<string, BlockProposal>;
+
+  // Checkpoint attestations
   // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  private attestations: Map<
+  private checkpointAttestations: Map<
     /*slot=*/ SlotNumber,
-    Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>
+    Map</*proposalId*/ string, Map</*address=*/ string, CheckpointAttestation>>
   >;
-  private proposals: Map<string, BlockProposal>;
+  private checkpointProposals: Map<string, CheckpointProposalCore>;
 
   constructor(
     telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('p2p:attestation_pool'),
   ) {
-    this.attestations = new Map();
     this.proposals = new Map();
+    this.checkpointAttestations = new Map();
+    this.checkpointProposals = new Map();
     this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
   }
 
   private poolStats: PoolStatsCallback = () => {
     return Promise.resolve({
-      itemCount: this.attestations.size,
+      itemCount: this.checkpointAttestations.size,
     });
   };
 
   public isEmpty(): Promise<boolean> {
-    return Promise.resolve(this.attestations.size === 0);
+    return Promise.resolve(this.checkpointAttestations.size === 0 && this.proposals.size === 0);
   }
 
-  public getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]> {
-    return Promise.resolve(
-      Array.from(this.attestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
-        Array.from(proposalAttestationMap.values()),
-      ),
-    );
+  public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
+    // Strip signedTxs before storing to avoid holding full tx data in memory
+    this.proposals.set(blockProposal.archive.toString(), blockProposal.withoutSignedTxs());
+    return Promise.resolve();
   }
 
-  public getAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<BlockAttestation[]> {
-    const slotAttestationMap = this.attestations.get(slot);
-    if (slotAttestationMap) {
-      const proposalAttestationMap = slotAttestationMap.get(proposalId);
-      if (proposalAttestationMap) {
-        return Promise.resolve(Array.from(proposalAttestationMap.values()));
-      }
+  public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
+    return Promise.resolve(this.proposals.get(id));
+  }
+
+  public hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
+    return Promise.resolve(this.proposals.has(id));
+  }
+
+  public canAddProposal(_block: BlockProposal): Promise<boolean> {
+    // TODO(palla/mbps): See when to allow
+    return Promise.resolve(true);
+  }
+
+  // Checkpoint attestation methods
+
+  public async addCheckpointProposal(proposal: CheckpointProposal): Promise<void> {
+    if (!(await this.canAddCheckpointProposal(proposal))) {
+      throw new ProposalSlotCapExceededError(
+        `Maximum checkpoint proposals per slot reached: slot=${proposal.slotNumber} cap=${MAX_PROPOSALS_PER_SLOT} proposal=${proposal.archive.toString()}`,
+      );
     }
-    return Promise.resolve([]);
+
+    // Extract and validate the block proposal if present
+    const blockProposal = proposal.getBlockProposal();
+    if (blockProposal && !(await this.canAddProposal(blockProposal))) {
+      throw new ProposalSlotCapExceededError(
+        `Maximum block proposals per slot reached when extracting from checkpoint: slot=${proposal.slotNumber} proposal=${blockProposal.archive.toString()}`,
+      );
+    }
+
+    const slotProposalMapping = getCheckpointSlotOrDefault(this.checkpointAttestations, proposal.slotNumber);
+    slotProposalMapping.set(proposal.archive.toString(), new Map<string, CheckpointAttestation>());
+
+    // Store the checkpoint proposal as core (without lastBlock) to avoid duplication
+    this.checkpointProposals.set(proposal.archive.toString(), proposal.toCore());
+
+    // Store the extracted block proposal separately
+    if (blockProposal) {
+      this.proposals.set(blockProposal.archive.toString(), blockProposal.withoutSignedTxs());
+    }
+
+    return Promise.resolve();
+  }
+
+  public getCheckpointProposal(id: string): Promise<CheckpointProposalCore | undefined> {
+    return Promise.resolve(this.checkpointProposals.get(id));
+  }
+
+  public hasCheckpointProposal(idOrProposal: string | CheckpointProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
+    return Promise.resolve(this.checkpointProposals.has(id));
   }
 
-  public addAttestations(attestations: BlockAttestation[]): Promise<void> {
+  public addCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void> {
     for (const attestation of attestations) {
-      // Perf: order and group by slot before insertion
       const slotNumber = attestation.payload.header.slotNumber;
-
       const proposalId = attestation.archive.toString();
       const sender = attestation.getSender();
 
       // Skip attestations with invalid signatures
       if (!sender) {
-        this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber}`, {
+        this.log.warn(`Skipping checkpoint attestation with invalid signature for slot ${slotNumber}`, {
           signature: attestation.signature.toString(),
           slotNumber,
           proposalId,
@@ -73,11 +122,11 @@ export class InMemoryAttestationPool implements AttestationPool {
         continue;
       }
 
-      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber);
-      const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
+      const slotAttestationMap = getCheckpointSlotOrDefault(this.checkpointAttestations, slotNumber);
+      const proposalAttestationMap = getCheckpointProposalOrDefault(slotAttestationMap, proposalId);
       proposalAttestationMap.set(sender.toString(), attestation);
 
-      this.log.verbose(`Added attestation for slot ${slotNumber} from ${sender}`, {
+      this.log.verbose(`Added checkpoint attestation for slot ${slotNumber} from ${sender}`, {
         signature: attestation.signature.toString(),
         slotNumber,
         address: sender,
@@ -88,25 +137,32 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  #getNumberOfAttestationsInSlot(slot: SlotNumber): number {
-    let total = 0;
-    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
+  public getCheckpointAttestationsForSlot(slot: SlotNumber): Promise<CheckpointAttestation[]> {
+    return Promise.resolve(
+      Array.from(this.checkpointAttestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
+        Array.from(proposalAttestationMap.values()),
+      ),
+    );
+  }
 
+  public getCheckpointAttestationsForSlotAndProposal(
+    slot: SlotNumber,
+    proposalId: string,
+  ): Promise<CheckpointAttestation[]> {
+    const slotAttestationMap = this.checkpointAttestations.get(slot);
     if (slotAttestationMap) {
-      for (const proposalAttestationMap of slotAttestationMap.values() ?? []) {
-        total += proposalAttestationMap.size;
+      const proposalAttestationMap = slotAttestationMap.get(proposalId);
+      if (proposalAttestationMap) {
+        return Promise.resolve(Array.from(proposalAttestationMap.values()));
       }
     }
-    return total;
+    return Promise.resolve([]);
   }
 
-  public async deleteAttestationsOlderThan(oldestSlot: SlotNumber): Promise<void> {
+  public deleteCheckpointAttestationsOlderThan(oldestSlot: SlotNumber): Promise<void> {
     const olderThan = [];
 
-    // Entries are iterated in insertion order, so we can break as soon as we find a slot that is older than the oldestSlot.
-    // Note: this will only prune correctly if attestations are added in order of rising slot, it is important that we do not allow
-    // insertion of attestations that are old. #(https://github.com/AztecProtocol/aztec-packages/issues/10322)
-    const slots = this.attestations.keys();
+    const slots = this.checkpointAttestations.keys();
     for (const slot of slots) {
       if (slot < oldestSlot) {
         olderThan.push(slot);
@@ -116,70 +172,51 @@ export class InMemoryAttestationPool implements AttestationPool {
     }
 
     for (const oldSlot of olderThan) {
-      await this.deleteAttestationsForSlot(oldSlot);
+      const proposalIds = this.checkpointAttestations.get(oldSlot)?.keys();
+      proposalIds?.forEach(proposalId => this.checkpointProposals.delete(proposalId));
+      this.checkpointAttestations.delete(oldSlot);
     }
     return Promise.resolve();
   }
 
-  public deleteAttestationsForSlot(slot: SlotNumber): Promise<void> {
-    // We count the number of attestations we are removing
-    const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);
-    const proposalIdsToDelete = this.attestations.get(slot)?.keys();
-    let proposalIdsToDeleteCount = 0;
-    proposalIdsToDelete?.forEach(proposalId => {
-      this.proposals.delete(proposalId);
-      proposalIdsToDeleteCount++;
-    });
-
-    this.attestations.delete(slot);
-    this.log.verbose(
-      `Removed ${numberOfAttestations} attestations and ${proposalIdsToDeleteCount} proposals for slot ${slot}`,
-    );
-
-    return Promise.resolve();
+  public hasReachedCheckpointProposalCap(slot: SlotNumber): Promise<boolean> {
+    const slotAttestationMap = this.checkpointAttestations.get(slot);
+    const proposalCount = slotAttestationMap?.size ?? 0;
+    return Promise.resolve(proposalCount >= MAX_PROPOSALS_PER_SLOT);
   }
 
-  public deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void> {
-    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
-    if (slotAttestationMap) {
-      if (slotAttestationMap.has(proposalId)) {
-        const numberOfAttestations = slotAttestationMap.get(proposalId)?.size ?? 0;
-
-        slotAttestationMap.delete(proposalId);
-
-        this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
-      }
-    }
+  public hasReachedCheckpointAttestationCap(
+    slot: SlotNumber,
+    proposalId: string,
+    committeeSize: number,
+  ): Promise<boolean> {
+    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
+    const count = this.checkpointAttestations.get(slot)?.get(proposalId)?.size ?? 0;
+    return Promise.resolve(limit <= 0 || count >= limit);
+  }
 
-    this.proposals.delete(proposalId);
-    return Promise.resolve();
+  public async canAddCheckpointProposal(proposal: CheckpointProposal): Promise<boolean> {
+    return (
+      this.checkpointProposals.has(proposal.archive.toString()) ||
+      !(await this.hasReachedCheckpointProposalCap(proposal.slotNumber))
+    );
   }
 
-  public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      const slotNumber = attestation.payload.header.slotNumber;
-      const slotAttestationMap = this.attestations.get(slotNumber);
-      if (slotAttestationMap) {
-        const proposalId = attestation.archive.toString();
-        const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-        if (proposalAttestationMap) {
-          const sender = attestation.getSender();
-
-          // Skip attestations with invalid signatures
-          if (!sender) {
-            this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber}`);
-            continue;
-          }
-
-          proposalAttestationMap.delete(sender.toString());
-          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${sender}`);
-        }
-      }
-    }
-    return Promise.resolve();
+  public async canAddCheckpointAttestation(
+    attestation: CheckpointAttestation,
+    committeeSize: number,
+  ): Promise<boolean> {
+    const sender = attestation.getSender();
+    const slot = attestation.payload.header.slotNumber;
+    const pid = attestation.archive.toString();
+    return (
+      !!sender &&
+      ((this.checkpointAttestations.get(slot)?.get(pid)?.has(sender.toString()) ?? false) ||
+        !(await this.hasReachedCheckpointAttestationCap(slot, pid, committeeSize)))
+    );
   }
 
-  public hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+  public hasCheckpointAttestation(attestation: CheckpointAttestation): Promise<boolean> {
     const slotNumber = attestation.payload.header.slotNumber;
     const proposalId = attestation.archive.toString();
     const sender = attestation.getSender();
@@ -189,7 +226,7 @@ export class InMemoryAttestationPool implements AttestationPool {
       return Promise.resolve(false);
     }
 
-    const slotAttestationMap = this.attestations.get(slotNumber);
+    const slotAttestationMap = this.checkpointAttestations.get(slotNumber);
     if (!slotAttestationMap) {
       return Promise.resolve(false);
     }
@@ -201,87 +238,27 @@ export class InMemoryAttestationPool implements AttestationPool {
 
     return Promise.resolve(proposalAttestationMap.has(sender.toString()));
   }
-
-  public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
-    // We initialize slot-proposal mapping if it does not exist
-    // This is important to ensure we can delete this proposal if there were not attestations for it
-    const slotProposalMapping = getSlotOrDefault(this.attestations, blockProposal.slotNumber);
-    slotProposalMapping.set(blockProposal.payload.archive.toString(), new Map<string, BlockAttestation>());
-
-    this.proposals.set(blockProposal.payload.archive.toString(), blockProposal);
-    return Promise.resolve();
-  }
-
-  public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
-    return Promise.resolve(this.proposals.get(id));
-  }
-
-  public hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
-    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
-    return Promise.resolve(this.proposals.has(id));
-  }
-
-  public hasReachedProposalCap(slot: SlotNumber): Promise<boolean> {
-    const slotAttestationMap = this.attestations.get(slot);
-    const proposalCount = slotAttestationMap?.size ?? 0;
-    return Promise.resolve(proposalCount >= MAX_PROPOSALS_PER_SLOT);
-  }
-
-  public hasReachedAttestationCap(slot: SlotNumber, proposalId: string, committeeSize: number): Promise<boolean> {
-    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-    const count = this.attestations.get(slot)?.get(proposalId)?.size ?? 0;
-    return Promise.resolve(limit <= 0 || count >= limit);
-  }
-
-  public async canAddProposal(block: BlockProposal): Promise<boolean> {
-    return this.proposals.has(block.archive.toString()) || !(await this.hasReachedProposalCap(block.slotNumber));
-  }
-
-  public async canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean> {
-    const sender = attestation.getSender();
-    const slot = attestation.payload.header.slotNumber;
-    const pid = attestation.archive.toString();
-    return (
-      !!sender &&
-      ((this.attestations.get(slot)?.get(pid)?.has(sender.toString()) ?? false) ||
-        !(await this.hasReachedAttestationCap(slot, pid, committeeSize)))
-    );
-  }
 }
 
-/**
- * Get Slot or Default
- *
- * Fetch the slot mapping, if it does not exist, then create a mapping and return it
- * @param map - The map to fetch from
- * @param slot - The slot to fetch
- * @returns The slot mapping
- */
-function getSlotOrDefault(
+// Checkpoint attestation helper functions
+
+function getCheckpointSlotOrDefault(
   // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  map: Map<SlotNumber, Map<string, Map<string, BlockAttestation>>>,
+  map: Map<SlotNumber, Map<string, Map<string, CheckpointAttestation>>>,
   slot: SlotNumber,
-): Map<string, Map<string, BlockAttestation>> {
+): Map<string, Map<string, CheckpointAttestation>> {
   if (!map.has(slot)) {
-    map.set(slot, new Map<string, Map<string, BlockAttestation>>());
+    map.set(slot, new Map<string, Map<string, CheckpointAttestation>>());
   }
   return map.get(slot)!;
 }
 
-/**
- * Get Proposal or Default
- *
- * Fetch the proposal mapping, if it does not exist, then create a mapping and return it
- * @param map - The map to fetch from
- * @param proposalId - The proposal id to fetch
- * @returns The proposal mapping
- */
-function getProposalOrDefault(
-  map: Map<string, Map<string, BlockAttestation>>,
+function getCheckpointProposalOrDefault(
+  map: Map<string, Map<string, CheckpointAttestation>>,
   proposalId: string,
-): Map<string, BlockAttestation> {
+): Map<string, CheckpointAttestation> {
   if (!map.has(proposalId)) {
-    map.set(proposalId, new Map<string, BlockAttestation>());
+    map.set(proposalId, new Map<string, CheckpointAttestation>());
   }
   return map.get(proposalId)!;
 }

package/src/mem_pools/attestation_pool/mocks.ts

@@ -1,7 +1,7 @@
 import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import {
-  BlockAttestation,
+  CheckpointAttestation,
   ConsensusPayload,
   SignatureDomainSeparator,
   getHashedSignaturePayloadEthSignedMessage,
@@ -20,26 +20,30 @@ export const generateAccount = (): LocalAccount => {
   return privateKeyToAccount(privateKey);
 };
 
-/** Mock Attestation
+/** Mock Checkpoint Attestation
  *
- * @param signer A viem signer to create a signature
+ * @param signer A Secp256k1Signer to create a signature
  * @param slot The slot number the attestation is for
- * @returns A Block Attestation
+ * @param archive The archive root (defaults to random)
+ * @returns A Checkpoint Attestation
  */
-export const mockAttestation = (
+export const mockCheckpointAttestation = (
   signer: Secp256k1Signer,
   slot: number = 0,
   archive: Fr = Fr.random(),
-): BlockAttestation => {
+): CheckpointAttestation => {
   // Use arbitrary numbers for all other than slot
   const header = makeL2BlockHeader(1, 2, slot);
   const payload = new ConsensusPayload(header.toCheckpointHeader(), archive);
 
-  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
+    payload,
+    SignatureDomainSeparator.checkpointAttestation,
+  );
   const attestationSignature = signer.sign(attestationHash);
 
-  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointProposal);
   const proposerSignature = signer.sign(proposalHash);
 
-  return new BlockAttestation(payload, attestationSignature, proposerSignature);
+  return new CheckpointAttestation(payload, attestationSignature, proposerSignature);
 };

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,33 +1,34 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { type CheckpointAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
-export class AttestationValidator implements P2PValidator<BlockAttestation> {
+export class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
   protected epochCache: EpochCacheInterface;
   protected logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
-    this.logger = createLogger('p2p:attestation-validator');
+    this.logger = createLogger('p2p:checkpoint-attestation-validator');
   }
 
-  async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+  async validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined> {
     const slotNumber = message.payload.header.slotNumber;
 
     try {
-      const { currentProposer, nextProposer, currentSlot, nextSlot } =
-        await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
+      const { currentSlot, nextSlot } = await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
 
       if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
-        this.logger.warn(`Attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`);
+        this.logger.warn(
+          `Checkpoint attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`,
+        );
         return PeerErrorSeverity.HighToleranceError;
       }
 
       // Verify the signature is valid
       const attester = message.getSender();
       if (attester === undefined) {
-        this.logger.warn(`Invalid signature in attestation for slot ${slotNumber}`);
+        this.logger.warn(`Invalid signature in checkpoint attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
 
@@ -37,20 +38,22 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
         return PeerErrorSeverity.HighToleranceError;
       }
 
-      // Verify the proposer signature matches the expected proposer for this slot
+      // Verify the proposer signature matches the expected proposer for the attestation's slot
+      // We look up the proposer for the specific slot rather than using currentSlot/nextSlot
+      // since timing differences could cause mismatches
       const proposer = message.getProposer();
-      const expectedProposer = slotNumber === currentSlot ? currentProposer : nextProposer;
+      const expectedProposer = await this.epochCache.getProposerAttesterAddressInSlot(slotNumber);
       if (!expectedProposer) {
         this.logger.warn(`No proposer defined for slot ${slotNumber}`);
         return PeerErrorSeverity.HighToleranceError;
       }
       if (!proposer) {
-        this.logger.warn(`Invalid proposer signature in attestation for slot ${slotNumber}`);
+        this.logger.warn(`Invalid proposer signature in checkpoint attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
       if (!proposer.equals(expectedProposer)) {
         this.logger.warn(
-          `Proposer signature mismatch in attestation. ` +
+          `Proposer signature mismatch in checkpoint attestation. ` +
             `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`,
         );
         return PeerErrorSeverity.HighToleranceError;
@@ -60,7 +63,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
     } catch (e) {
       // People shouldn't be sending us attestations if the committee doesn't exist
       if (e instanceof NoCommitteeError) {
-        this.logger.warn(`No committee exists for attestation for slot ${slotNumber}`);
+        this.logger.warn(`No committee exists for checkpoint attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
       throw e;

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -1,9 +1,9 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { type CheckpointAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Attributes, Metrics, type TelemetryClient } from '@aztec/telemetry-client';
 
 import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
-import { AttestationValidator } from './attestation_validator.js';
+import { CheckpointAttestationValidator } from './attestation_validator.js';
 
 /**
  * FishermanAttestationValidator extends the base AttestationValidator to add
@@ -13,7 +13,7 @@ import { AttestationValidator } from './attestation_validator.js';
  * handled by LibP2PService based on the fishermanMode config to ensure a better
  * view of the network.
  */
-export class FishermanAttestationValidator extends AttestationValidator {
+export class FishermanAttestationValidator extends CheckpointAttestationValidator {
   private invalidAttestationCounter;
 
   constructor(
@@ -28,7 +28,7 @@ export class FishermanAttestationValidator extends AttestationValidator {
     this.invalidAttestationCounter = meter.createUpDownCounter(Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT);
   }
 
-  override async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+  override async validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined> {
     // First run the standard validation
     const baseValidationResult = await super.validate(message);
     if (baseValidationResult !== undefined) {
@@ -49,11 +49,11 @@ export class FishermanAttestationValidator extends AttestationValidator {
     }
 
     const proposalId = message.archive.toString();
-    const proposal = await this.attestationPool.getBlockProposal(proposalId);
+    const proposal = await this.attestationPool.getCheckpointProposal(proposalId);
 
     if (proposal) {
       // Compare the attestation payload with the proposal payload
-      if (!message.payload.equals(proposal.payload)) {
+      if (!message.payload.equals(proposal)) {
         this.logger.error(
           `Attestation payload mismatch for slot ${slotNumberBigInt}! ` +
             `Attester ${attester.toString()} signed different data than the proposal.`,
@@ -63,7 +63,7 @@ export class FishermanAttestationValidator extends AttestationValidator {
             proposer: proposer.toString(),
             proposalArchive: proposal.archive.toString(),
             attestationArchive: message.archive.toString(),
-            proposalHeader: proposal.payload.header.hash().toString(),
+            proposalHeader: proposal.checkpointHeader.hash().toString(),
             attestationHeader: message.payload.header.hash().toString(),
           },
         );

package/src/msg_validators/index.ts

@@ -1,3 +1,3 @@
 export * from './tx_validator/index.js';
-export * from './block_proposal_validator/index.js';
+export * from './proposal_validator/index.js';
 export * from './attestation_validator/index.js';

package/src/msg_validators/proposal_validator/block_proposal_validator.ts

@@ -0,0 +1,10 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { BlockProposal, P2PValidator } from '@aztec/stdlib/p2p';
+
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+
+export class BlockProposalValidator extends ProposalValidator<BlockProposal> implements P2PValidator<BlockProposal> {
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
+    super(epochCache, opts, 'p2p:block_proposal_validator');
+  }
+}

package/src/msg_validators/proposal_validator/checkpoint_proposal_validator.ts

@@ -0,0 +1,13 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { CheckpointProposal, P2PValidator } from '@aztec/stdlib/p2p';
+
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+
+export class CheckpointProposalValidator
+  extends ProposalValidator<CheckpointProposal>
+  implements P2PValidator<CheckpointProposal>
+{
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
+    super(epochCache, opts, 'p2p:checkpoint_proposal_validator');
+  }
+}

package/src/msg_validators/proposal_validator/index.ts

@@ -0,0 +1,3 @@
+export * from './block_proposal_validator.js';
+export * from './checkpoint_proposal_validator.js';
+export * from './proposal_validator.js';