@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,14 +1,26 @@
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+
+export type TxPoolOptions = {
+  maxPendingTxCount?: number;
+  archivedTxLimit?: number;
+};
+
+export type TxPoolEvents = {
+  ['txs-added']: (args: { txs: Tx[]; source?: string }) => void | Promise<void>;
+};
 
 /**
  * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
  */
-export interface TxPool {
+export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
   /**
    * Adds a list of transactions to the pool. Duplicates are ignored.
    * @param txs - An array of txs to be added to the pool.
+   * @returns The number of txs added to the pool. Note if the transaction already exists, it will not be added again.
    */
-  addTxs(txs: Tx[]): Promise<void>;
+  addTxs(txs: Tx[], opts?: { source?: string }): Promise<number>;
 
   /**
    * Checks if a transaction exists in the pool and returns it.
@@ -17,6 +29,27 @@ export interface TxPool {
    */
   getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
 
+  /**
+   * Checks if transactions exist in the pool and returns them.
+   * @param txHashes - The hashes of the transactions
+   * @returns The transactions, if found, 'undefined' otherwise.
+   */
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+
+  /**
+   * Checks if transactions exist in the pool
+   * @param txHashes - The hashes of the transactions to check for
+   * @returns True or False for each tx hash
+   */
+  hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
+
+  /**
+   * Checks if a transaction exists in the pool
+   * @param txHash - The hash of the transaction to check for
+   * @returns True if the transaction exists, false otherwise
+   */
+  hasTx(txHash: TxHash): Promise<boolean>;
+
   /**
    * Checks if an archived transaction exists in the pool and returns it.
    * @param txHash - The hash of the transaction, used as an ID.
@@ -27,21 +60,23 @@ export interface TxPool {
   /**
    * Marks the set of txs as mined, as opposed to pending.
    * @param txHashes - Hashes of the txs to flag as mined.
+   * @param blockHeader - The header of the mined block.
    */
-  markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
+  markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void>;
 
   /**
    * Moves mined txs back to the pending set in the case of a reorg.
    * Note: txs not known by this peer will be ignored.
    * @param txHashes - Hashes of the txs to flag as pending.
+   * @param latestBlock - The block number the chain was pruned to.
    */
-  markMinedAsPending(txHashes: TxHash[]): Promise<void>;
+  markMinedAsPending(txHashes: TxHash[], latestBlock: BlockNumber): Promise<void>;
 
   /**
    * Deletes transactions from the pool. Tx hashes that are not present are ignored.
    * @param txHashes - An array of tx hashes to be removed from the tx pool.
    */
-  deleteTxs(txHashes: TxHash[]): Promise<void>;
+  deleteTxs(txHashes: TxHash[], opts?: { permanently?: boolean }): Promise<void>;
 
   /**
    * Gets all transactions currently in the tx pool.
@@ -61,16 +96,46 @@ export interface TxPool {
    */
   getPendingTxHashes(): Promise<TxHash[]>;
 
+  /** Returns the number of pending txs in the pool. */
+  getPendingTxCount(): Promise<number>;
+
   /**
    * Gets the hashes of mined transactions currently in the tx pool.
    * @returns An array of mined transaction hashes found in the tx pool.
    */
-  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
+  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: BlockNumber][]>;
 
   /**
-   * Returns whether the given tx hash is flagged as pending or mined.
+   * Returns whether the given tx hash is flagged as pending, mined, or deleted.
    * @param txHash - Hash of the tx to query.
-   * @returns Pending or mined depending on its status, or undefined if not found.
+   * @returns Pending, mined, or deleted depending on its status, or undefined if not found.
+   */
+  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
+
+  /**
+   * Configure the maximum size of the tx pool
+   * @param maxSizeBytes - The maximum size in bytes of the mempool. Set to undefined to disable it
+   */
+  updateConfig(config: TxPoolOptions): void;
+
+  /** Returns whether the pool is empty. */
+  isEmpty(): Promise<boolean>;
+
+  /**
+   * Marks transactions as non-evictible in the pool.
+   * @param txHashes - Hashes of the transactions to mark as non-evictible.
+   */
+  markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Clears collection of non-evictable transactions in the pool
+   */
+  clearNonEvictableTxs(): Promise<void>;
+
+  /**
+   * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
+   * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
+   * @returns The number of transactions permanently deleted.
    */
-  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
+  cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,7 +1,8 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { unfreeze } from '@aztec/foundation/types';
 import { GasFees } from '@aztec/stdlib/gas';
 import { mockTx } from '@aztec/stdlib/testing';
-import type { Tx } from '@aztec/stdlib/tx';
+import { BlockHeader, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
 
 import type { TxPool } from './tx_pool.js';
 
@@ -12,79 +13,123 @@ import type { TxPool } from './tx_pool.js';
 export function describeTxPool(getTxPool: () => TxPool) {
   let pool: TxPool;
 
+  const minedBlockHeader = BlockHeader.empty({
+    globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(1), timestamp: 0n }),
+  });
+
   beforeEach(() => {
     pool = getTxPool();
   });
 
-  it('Adds txs to the pool as pending', async () => {
-    const tx1 = await mockTx();
+  afterEach(() => {
+    pool.removeAllListeners('txs-added');
+  });
+
+  it('adds txs to the pool as pending', async () => {
+    const tx1 = await mockTx(1);
 
     await pool.addTxs([tx1]);
-    const poolTx = await pool.getTxByHash(await tx1.getTxHash());
-    expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]);
+    const poolTx = await pool.getTxByHash(tx1.getTxHash());
+    expect(poolTx!.getTxHash()).toEqual(tx1.getTxHash());
+    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('pending');
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]);
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Removes txs from the pool', async () => {
-    const tx1 = await mockTx();
+  it('emits txs-added event with new txs', async () => {
+    const tx1 = await mockTx(1); // existing and pending
+    const tx2 = await mockTx(2); // mined but not known
+    const tx3 = await mockTx(3); // brand new
 
     await pool.addTxs([tx1]);
-    await pool.deleteTxs([await tx1.getTxHash()]);
+    await pool.markAsMined([tx2.getTxHash()], minedBlockHeader);
+
+    let txsFromEvent: Tx[] | undefined = undefined;
+    pool.once('txs-added', ({ txs }) => {
+      txsFromEvent = txs;
+    });
 
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+    await pool.addTxs([tx1, tx2, tx3]);
+    expect(txsFromEvent).toBeDefined();
+    expect(txsFromEvent).toHaveLength(2);
+    const eventHashes = txsFromEvent!.map(tx => tx.getTxHash());
+    expect(eventHashes).toEqual(expect.arrayContaining([tx2.getTxHash(), tx3.getTxHash()]));
   });
 
-  it('Marks txs as mined', async () => {
+  it('removes txs from the pool', async () => {
+    const pendingTx = await mockTx(1);
+    const minedTx = await mockTx(2);
+
+    await pool.addTxs([pendingTx, minedTx]);
+    await pool.markAsMined([minedTx.getTxHash()], minedBlockHeader);
+
+    // Delete a pending tx - should be permanently deleted
+    await pool.deleteTxs([pendingTx.getTxHash()]);
+    await expect(pool.getTxByHash(pendingTx.getTxHash())).resolves.toBeUndefined();
+    await expect(pool.getTxStatus(pendingTx.getTxHash())).resolves.toBeUndefined();
+
+    // Delete a mined tx - should be soft-deleted (still in storage)
+    await pool.deleteTxs([minedTx.getTxHash()]);
+    await expect(pool.getTxByHash(minedTx.getTxHash())).resolves.toBeDefined();
+    await expect(pool.getTxStatus(minedTx.getTxHash())).resolves.toEqual('deleted');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+
+    await expect(pool.getPendingTxCount()).resolves.toEqual(0);
+  });
+
+  it('marks txs as mined', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
+    await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
-    await expect(pool.getMinedTxHashes()).resolves.toEqual([[await tx1.getTxHash(), 1]]);
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx2.getTxHash()]);
+    const retrievedTx = await pool.getTxByHash(tx1.getTxHash());
+    expect(retrievedTx?.getTxHash()).toEqual(tx1.getTxHash());
+    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('mined');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([[tx1.getTxHash(), 1]]);
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx2.getTxHash()]);
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Marks txs as pending after being mined', async () => {
+  it('marks txs as pending after being mined', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
+    await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await pool.markMinedAsPending([await tx1.getTxHash()]);
+    await pool.markMinedAsPending([tx1.getTxHash()], BlockNumber(1));
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
-    expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
+    expect(pending).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash()]));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(2);
   });
 
-  it('Only marks txs as pending if they are known', async () => {
+  it('only marks txs as pending if they are known', async () => {
     const tx1 = await mockTx(1);
     // simulate a situation where not all peers have all the txs
     const tx2 = await mockTx(2);
-    const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
+    const someTxHashThatThisPeerDidNotSee = tx2.getTxHash();
     await pool.addTxs([tx1]);
     // this peer knows that tx2 was mined, but it does not have the tx object
-    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
+    await pool.markAsMined([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], minedBlockHeader);
     expect(await pool.getMinedTxHashes()).toEqual(
       expect.arrayContaining([
-        [await tx1.getTxHash(), 1],
+        [tx1.getTxHash(), 1],
         [someTxHashThatThisPeerDidNotSee, 1],
       ]),
     );
 
     // reorg: both txs should now become available again
-    await pool.markMinedAsPending([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], BlockNumber(1));
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]); // tx2 is not in the pool
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]); // tx2 is not in the pool
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Returns all transactions in the pool', async () => {
+  it('returns all transactions in the pool', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
@@ -93,10 +138,12 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const poolTxs = await pool.getAllTxs();
     expect(poolTxs).toHaveLength(3);
-    expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
+    const poolHashes = poolTxs.map(tx => tx.getTxHash());
+    expect(poolHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash(), tx3.getTxHash()]));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
-  it('Returns all txHashes in the pool', async () => {
+  it('returns all txHashes in the pool', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
@@ -104,13 +151,58 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2, tx3]);
 
     const poolTxHashes = await pool.getAllTxHashes();
+    const expectedHashes = [tx1, tx2, tx3].map(tx => tx.getTxHash());
     expect(poolTxHashes).toHaveLength(3);
-    expect(poolTxHashes).toEqual(
-      expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash(), await tx3.getTxHash()]),
-    );
+    expect(poolTxHashes).toEqual(expect.arrayContaining(expectedHashes));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
-  it('Returns pending tx hashes sorted by priority', async () => {
+  it('returns txs by their hash', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const requestedTxs = await pool.getTxsByHash([tx1.getTxHash(), tx3.getTxHash()]);
+    expect(requestedTxs).toHaveLength(2);
+    const requestedHashes = requestedTxs.map(tx => tx!.getTxHash());
+    expect(requestedHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx3.getTxHash()]));
+  });
+
+  it('returns a large number of transactions by their hash', async () => {
+    const numTxs = 1_000;
+    const txs = await Promise.all(Array.from({ length: numTxs }, (_, i) => mockTx(i)));
+    const hashes = txs.map(tx => tx.getTxHash());
+    await pool.addTxs(txs);
+    const requestedTxs = await pool.getTxsByHash(hashes);
+    expect(requestedTxs).toHaveLength(numTxs);
+    const requestedHashes = requestedTxs.map(tx => tx!.getTxHash());
+    expect(requestedHashes).toEqual(expect.arrayContaining(hashes));
+  });
+
+  it('returns whether or not txs exist', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const tx4 = await mockTx(4);
+    const tx5 = await mockTx(5);
+
+    const availability = await pool.hasTxs([
+      tx1.getTxHash(),
+      tx2.getTxHash(),
+      tx3.getTxHash(),
+      tx4.getTxHash(),
+      tx5.getTxHash(),
+    ]);
+    expect(availability).toHaveLength(5);
+    expect(availability).toEqual(expect.arrayContaining([true, true, true, false, false]));
+  });
+
+  it('returns pending tx hashes sorted by priority', async () => {
     const withPriorityFee = (tx: Tx, fee: number) => {
       unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
       return tx;
@@ -125,6 +217,103 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const poolTxHashes = await pool.getPendingTxHashes();
     expect(poolTxHashes).toHaveLength(4);
-    expect(poolTxHashes).toEqual(await Promise.all([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash())));
+    expect(poolTxHashes).toEqual([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash()));
+  });
+
+  describe('soft-delete', () => {
+    it('soft-deletes mined txs and keeps them in storage', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
+      await pool.addTxs(txs);
+
+      // Mark first tx as mined
+      await pool.markAsMined([txs[0].getTxHash()], minedBlockHeader);
+
+      // Verify initial state
+      await expect(pool.getPendingTxCount()).resolves.toBe(2);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeDefined();
+
+      // Delete mined tx - should be soft-deleted
+      await pool.deleteTxs([txs[0].getTxHash()]);
+
+      // Delete pending tx - should be permanently deleted
+      await pool.deleteTxs([txs[1].getTxHash()]);
+
+      // Verify mined tx still exists in storage but has 'deleted' status
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+      await expect(pool.getTxStatus(txs[0].getTxHash())).resolves.toEqual('deleted');
+
+      // Verify pending tx is permanently deleted
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxStatus(txs[1].getTxHash())).resolves.toBeUndefined();
+
+      // Verify remaining pending count
+      await expect(pool.getPendingTxCount()).resolves.toBe(1);
+
+      // Verify pending hashes don't include deleted txs
+      const pendingHashes = await pool.getPendingTxHashes();
+      expect(pendingHashes).toHaveLength(1);
+      expect(pendingHashes.map(h => h.toString())).toContain(txs[2].getTxHash().toString());
+    });
+
+    it('cleans up old deleted mined transactions', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
+      await pool.addTxs(txs);
+
+      // Mark first two as mined in block 1
+      await pool.markAsMined([txs[0].getTxHash(), txs[1].getTxHash()], minedBlockHeader);
+
+      // Soft-delete mined transactions
+      await pool.deleteTxs([txs[0].getTxHash(), txs[1].getTxHash()]);
+
+      // Clean up deleted mined txs from block 1 and earlier
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
+
+      // Verify old transactions are permanently deleted
+      expect(deletedCount).toBe(2);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxByHash(txs[2].getTxHash())).resolves.toBeDefined();
+    });
+
+    it('does not clean up recent deleted mined transactions', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2)]);
+      await pool.addTxs(txs);
+
+      // Mark as mined in block 2
+      const laterBlockHeader = BlockHeader.empty({
+        globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(2), timestamp: 0n }),
+      });
+      await pool.markAsMined([txs[0].getTxHash()], laterBlockHeader);
+
+      // Soft-delete a mined transaction
+      await pool.deleteTxs([txs[0].getTxHash()]);
+
+      // Try to clean up with block 1 (before the mined block)
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
+
+      // Verify no transactions were cleaned up
+      expect(deletedCount).toBe(0);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+    });
+
+    it('restores deleted mined tx when it is mined again', async () => {
+      const tx = await mockTx(1);
+      await pool.addTxs([tx]);
+
+      // Mark as mined
+      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
+
+      // Soft-delete it
+      await pool.deleteTxs([tx.getTxHash()]);
+      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('deleted');
+
+      // Mark as mined again (e.g., after a reorg)
+      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
+
+      // Should be back to mined status
+      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('mined');
+      await expect(pool.getTxByHash(tx.getTxHash())).resolves.toBeDefined();
+    });
   });
 }

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,26 +1,72 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type CheckpointAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
-export class AttestationValidator implements P2PValidator<BlockAttestation> {
-  private epochCache: EpochCacheInterface;
+export class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
+    this.logger = createLogger('p2p:checkpoint-attestation-validator');
   }
 
-  async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
-    const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
+  async validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined> {
+    const slotNumber = message.payload.header.slotNumber;
 
-    const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
-    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+    try {
+      const { currentSlot, nextSlot } = await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
 
-    const attester = await message.getSender();
-    if (!(await this.epochCache.isInCommittee(attester))) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        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 checkpoint attestation for slot ${slotNumber}`);
+        return PeerErrorSeverity.LowToleranceError;
+      }
 
-    return undefined;
+      // Verify the attester is in the committee for this slot
+      if (!(await this.epochCache.isInCommittee(slotNumber, attester))) {
+        this.logger.warn(`Attester ${attester.toString()} is not in committee for slot ${slotNumber}`);
+        return PeerErrorSeverity.HighToleranceError;
+      }
+
+      // 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 = 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 checkpoint attestation for slot ${slotNumber}`);
+        return PeerErrorSeverity.LowToleranceError;
+      }
+      if (!proposer.equals(expectedProposer)) {
+        this.logger.warn(
+          `Proposer signature mismatch in checkpoint attestation. ` +
+            `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`,
+        );
+        return PeerErrorSeverity.HighToleranceError;
+      }
+
+      return undefined;
+    } 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 checkpoint attestation for slot ${slotNumber}`);
+        return PeerErrorSeverity.LowToleranceError;
+      }
+      throw e;
+    }
   }
 }

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -0,0 +1,88 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+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 { CheckpointAttestationValidator } from './attestation_validator.js';
+
+/**
+ * FishermanAttestationValidator extends the base AttestationValidator to add
+ * additional validation for fisherman nodes: verifying that attestations sign
+ * the same payload as the original proposal.
+ * Invalid attestations are rejected (not propagated), but peer penalization is
+ * handled by LibP2PService based on the fishermanMode config to ensure a better
+ * view of the network.
+ */
+export class FishermanAttestationValidator extends CheckpointAttestationValidator {
+  private invalidAttestationCounter;
+
+  constructor(
+    epochCache: EpochCacheInterface,
+    private attestationPool: AttestationPool,
+    telemetryClient: TelemetryClient,
+  ) {
+    super(epochCache);
+    this.logger = this.logger.createChild('[FISHERMAN]');
+
+    const meter = telemetryClient.getMeter('FishermanAttestationValidator');
+    this.invalidAttestationCounter = meter.createUpDownCounter(Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT);
+  }
+
+  override async validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined> {
+    // First run the standard validation
+    const baseValidationResult = await super.validate(message);
+    if (baseValidationResult !== undefined) {
+      // Track base validation failures (invalid signature, wrong committee, etc.)
+      this.invalidAttestationCounter.add(1, {
+        [Attributes.ERROR_TYPE]: 'base_validation_failed',
+      });
+      return baseValidationResult;
+    }
+
+    // fisherman validation: verify attestation payload matches proposal payload
+    const slotNumberBigInt = message.payload.header.slotNumber;
+    const attester = message.getSender();
+    const proposer = message.getProposer();
+
+    if (!attester || !proposer) {
+      return undefined;
+    }
+
+    const proposalId = message.archive.toString();
+    const proposal = await this.attestationPool.getCheckpointProposal(proposalId);
+
+    if (proposal) {
+      // Compare the attestation payload with the 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.`,
+          {
+            slot: slotNumberBigInt.toString(),
+            attester: attester.toString(),
+            proposer: proposer.toString(),
+            proposalArchive: proposal.archive.toString(),
+            attestationArchive: message.archive.toString(),
+            proposalHeader: proposal.checkpointHeader.hash().toString(),
+            attestationHeader: message.payload.header.hash().toString(),
+          },
+        );
+
+        // Track invalid attestation metric
+        this.invalidAttestationCounter.add(1, {
+          [Attributes.ERROR_TYPE]: 'payload_mismatch',
+        });
+
+        // Return error to reject the message, but LibP2PService won't penalize in fisherman mode
+        return PeerErrorSeverity.LowToleranceError;
+      }
+    } else {
+      // We might receive attestations before proposals in some cases
+      this.logger.debug(
+        `Received attestation for slot ${slotNumberBigInt} but proposal not found yet. ` + `Proposal ID: ${proposalId}`,
+      );
+    }
+
+    return undefined;
+  }
+}

package/src/msg_validators/attestation_validator/index.ts

@@ -1 +1,2 @@
 export * from './attestation_validator.js';
+export * from './fisherman_attestation_validator.js';

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';