@aztec/p2p 3.0.0-devnet.2 → 3.0.0-devnet.2-patch.1

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,14 +1,20 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 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 attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private attestations: Map<
+    /*slot=*/ SlotNumber,
+    Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>
+  >;
   private proposals: Map<string, BlockProposal>;
 
   constructor(
@@ -30,7 +36,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve(this.attestations.size === 0);
   }
 
-  public getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
+  public getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]> {
     return Promise.resolve(
       Array.from(this.attestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
         Array.from(proposalAttestationMap.values()),
@@ -38,7 +44,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     );
   }
 
-  public getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+  public getAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<BlockAttestation[]> {
     const slotAttestationMap = this.attestations.get(slot);
     if (slotAttestationMap) {
       const proposalAttestationMap = slotAttestationMap.get(proposalId);
@@ -59,7 +65,7 @@ export class InMemoryAttestationPool implements AttestationPool {
 
       // Skip attestations with invalid signatures
       if (!sender) {
-        this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber.toBigInt()}`, {
+        this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber}`, {
           signature: attestation.signature.toString(),
           slotNumber,
           proposalId,
@@ -67,11 +73,11 @@ export class InMemoryAttestationPool implements AttestationPool {
         continue;
       }
 
-      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
+      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber);
       const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
       proposalAttestationMap.set(sender.toString(), attestation);
 
-      this.log.verbose(`Added attestation for slot ${slotNumber.toBigInt()} from ${sender}`, {
+      this.log.verbose(`Added attestation for slot ${slotNumber} from ${sender}`, {
         signature: attestation.signature.toString(),
         slotNumber,
         address: sender,
@@ -82,7 +88,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  #getNumberOfAttestationsInSlot(slot: bigint): number {
+  #getNumberOfAttestationsInSlot(slot: SlotNumber): number {
     let total = 0;
     const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
 
@@ -94,7 +100,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return total;
   }
 
-  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+  public async deleteAttestationsOlderThan(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.
@@ -115,7 +121,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  public deleteAttestationsForSlot(slot: bigint): Promise<void> {
+  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();
@@ -133,7 +139,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  public deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+  public deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void> {
     const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
     if (slotAttestationMap) {
       if (slotAttestationMap.has(proposalId)) {
@@ -152,7 +158,7 @@ export class InMemoryAttestationPool implements AttestationPool {
   public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       const slotNumber = attestation.payload.header.slotNumber;
-      const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
+      const slotAttestationMap = this.attestations.get(slotNumber);
       if (slotAttestationMap) {
         const proposalId = attestation.archive.toString();
         const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
@@ -161,7 +167,7 @@ export class InMemoryAttestationPool implements AttestationPool {
 
           // Skip attestations with invalid signatures
           if (!sender) {
-            this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber.toBigInt()}`);
+            this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber}`);
             continue;
           }
 
@@ -173,10 +179,33 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
+  public hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive.toString();
+    const sender = attestation.getSender();
+
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return Promise.resolve(false);
+    }
+
+    const slotAttestationMap = this.attestations.get(slotNumber);
+    if (!slotAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    const proposalAttestationMap = slotAttestationMap.get(proposalId);
+    if (!proposalAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    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.toBigInt());
+    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);
@@ -186,6 +215,38 @@ export class InMemoryAttestationPool implements AttestationPool {
   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)))
+    );
+  }
 }
 
 /**
@@ -197,8 +258,9 @@ export class InMemoryAttestationPool implements AttestationPool {
  * @returns The slot mapping
  */
 function getSlotOrDefault(
-  map: Map<bigint, Map<string, Map<string, BlockAttestation>>>,
-  slot: bigint,
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  map: Map<SlotNumber, Map<string, Map<string, BlockAttestation>>>,
+  slot: SlotNumber,
 ): Map<string, Map<string, BlockAttestation>> {
   if (!map.has(slot)) {
     map.set(slot, new Map<string, Map<string, BlockAttestation>>());

package/src/mem_pools/attestation_pool/mocks.ts

@@ -1,5 +1,5 @@
-import type { Secp256k1Signer } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   BlockAttestation,
   ConsensusPayload,
@@ -33,7 +33,7 @@ export const mockAttestation = (
 ): BlockAttestation => {
   // Use arbitrary numbers for all other than slot
   const header = makeL2BlockHeader(1, 2, slot);
-  const payload = new ConsensusPayload(header.toCheckpointHeader(), archive, header.state);
+  const payload = new ConsensusPayload(header.toCheckpointHeader(), archive);
 
   const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
   const attestationSignature = signer.sign(attestationHash);

package/src/mem_pools/instrumentation.ts

@@ -10,6 +10,7 @@ import {
   type MetricsType,
   type ObservableGauge,
   type TelemetryClient,
+  type UpDownCounter,
 } from '@aztec/telemetry-client';
 
 export enum PoolName {
@@ -20,6 +21,7 @@ export enum PoolName {
 type MetricsLabels = {
   objectInMempool: MetricsType;
   objectSize: MetricsType;
+  itemsAdded: MetricsType;
 };
 
 /**
@@ -32,11 +34,13 @@ function getMetricsLabels(name: PoolName): MetricsLabels {
     return {
       objectInMempool: Metrics.MEMPOOL_TX_COUNT,
       objectSize: Metrics.MEMPOOL_TX_SIZE,
+      itemsAdded: Metrics.MEMPOOL_TX_ADDED_COUNT,
     };
   } else if (name === PoolName.ATTESTATION_POOL) {
     return {
       objectInMempool: Metrics.MEMPOOL_ATTESTATIONS_COUNT,
       objectSize: Metrics.MEMPOOL_ATTESTATIONS_SIZE,
+      itemsAdded: Metrics.MEMPOOL_ATTESTATIONS_ADDED_COUNT,
     };
   }
 
@@ -53,6 +57,7 @@ export type PoolStatsCallback = () => Promise<{
 export class PoolInstrumentation<PoolObject extends Gossipable> {
   /** The number of txs in the mempool */
   private objectsInMempool: ObservableGauge;
+  private addObjectCounter: UpDownCounter;
   /** Tracks tx size */
   private objectSize: Histogram;
 
@@ -89,6 +94,10 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
       dbStats,
     );
 
+    this.addObjectCounter = this.meter.createUpDownCounter(metricsLabels.itemsAdded, {
+      description: 'The number of transactions added to the mempool',
+    });
+
     this.meter.addBatchObservableCallback(this.observeStats, [this.objectsInMempool]);
   }
 
@@ -96,6 +105,10 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
     this.objectSize.record(poolObject.getSize());
   }
 
+  public incrementAddedObjects(count: number) {
+    this.addObjectCounter.add(count);
+  }
+
   private observeStats = async (observer: BatchObservableResult) => {
     const { itemCount } = await this.poolStats();
     if (typeof itemCount === 'number') {

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
@@ -6,7 +7,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSi
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
@@ -37,7 +38,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
   txPoolOverflowFactor: number = 1;
 
   /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */
-  #minedTxHashToBlock: AztecAsyncMap<string, number>;
+  #minedTxHashToBlock: AztecAsyncMap<string, BlockNumber>;
 
   /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */
   #pendingTxPriorityToHash: AztecAsyncMultiMap<string, string>;
@@ -49,10 +50,10 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
   #pendingTxHashToHeaderHash: AztecAsyncMap<string, string>;
 
   /** Map from tx hash to the block number it was originally mined in (for soft-deleted txs). */
-  #deletedMinedTxHashes: AztecAsyncMap<string, number>;
+  #deletedMinedTxHashes: AztecAsyncMap<string, BlockNumber>;
 
   /** MultiMap from block number to deleted mined tx hashes for efficient cleanup. */
-  #blockToDeletedMinedTxHash: AztecAsyncMultiMap<number, string>;
+  #blockToDeletedMinedTxHash: AztecAsyncMultiMap<BlockNumber, string>;
 
   /** The cumulative tx size in bytes that the pending txs in the pool take up. */
   #pendingTxSize: AztecAsyncSingleton<number>;
@@ -222,7 +223,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     return vals.map(TxHash.fromString);
   }
 
-  public async getMinedTxHashes(): Promise<[TxHash, number][]> {
+  public async getMinedTxHashes(): Promise<[TxHash, BlockNumber][]> {
     const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
     return vals.map(([txHash, blockNumber]) => [TxHash.fromString(txHash), blockNumber]);
   }
@@ -273,6 +274,11 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     return await Promise.all(txHashes.map(txHash => this.#txs.hasAsync(txHash.toString())));
   }
 
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   /**
    * Checks if an archived tx exists and returns it.
    * @param txHash - The tx hash.
@@ -436,10 +442,10 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
    * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
    * @returns The number of transactions permanently deleted.
    */
-  public async cleanupDeletedMinedTxs(blockNumber: number): Promise<number> {
+  public async cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number> {
     let deletedCount = 0;
     const txHashesToDelete: string[] = [];
-    const blocksToDelete: number[] = [];
+    const blocksToDelete: BlockNumber[] = [];
 
     await this.#store.transactionAsync(async () => {
       // Iterate through all entries and check block numbers
@@ -546,7 +552,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
           const archivedTx: Tx = new Tx(
             tx.txHash,
             tx.data,
-            ClientIvcProof.empty(),
+            ChonkProof.empty(),
             tx.contractClassLogFields,
             tx.publicFunctionCalldata,
           );

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
@@ -18,10 +19,11 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
    * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
    */
   private txs: Map<bigint, Tx>;
-  private minedTxs: Map<bigint, number>;
+  private minedTxs: Map<bigint, BlockNumber>;
   private pendingTxs: Set<bigint>;
-  private deletedMinedTxHashes: Map<bigint, number>;
-  private blockToDeletedMinedTxHash: Map<number, Set<bigint>>;
+  private deletedMinedTxHashes: Map<bigint, BlockNumber>;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private blockToDeletedMinedTxHash: Map<BlockNumber, Set<bigint>>;
 
   private metrics: PoolInstrumentation<Tx>;
 
@@ -108,7 +110,7 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
     });
   }
 
-  public getMinedTxHashes(): Promise<[TxHash, number][]> {
+  public getMinedTxHashes(): Promise<[TxHash, BlockNumber][]> {
     return Promise.resolve(
       Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]),
     );
@@ -151,6 +153,11 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
     return Promise.resolve(txHashes.map(txHash => this.txs.has(txHash.toBigInt())));
   }
 
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   public getArchivedTxByHash(): Promise<Tx | undefined> {
     return Promise.resolve(undefined);
   }
@@ -248,9 +255,9 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
    * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
    * @returns The number of transactions permanently deleted.
    */
-  public cleanupDeletedMinedTxs(blockNumber: number): Promise<number> {
+  public cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number> {
     let deletedCount = 0;
-    const blocksToDelete: number[] = [];
+    const blocksToDelete: BlockNumber[] = [];
 
     // Find all blocks up to the specified block number
     for (const [block, txHashes] of this.blockToDeletedMinedTxHash.entries()) {

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,3 +1,4 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -43,6 +44,13 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    */
   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.
@@ -95,7 +103,7 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    * 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, mined, or deleted.
@@ -124,5 +132,5 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
    * @returns The number of transactions permanently deleted.
    */
-  cleanupDeletedMinedTxs(blockNumber: number): Promise<number>;
+  cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,3 +1,4 @@
+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';
@@ -13,7 +14,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
   let pool: TxPool;
 
   const minedBlockHeader = BlockHeader.empty({
-    globalVariables: GlobalVariables.empty({ blockNumber: 1, timestamp: 0n }),
+    globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(1), timestamp: 0n }),
   });
 
   beforeEach(() => {
@@ -261,7 +262,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
       await pool.deleteTxs([txs[0].getTxHash(), txs[1].getTxHash()]);
 
       // Clean up deleted mined txs from block 1 and earlier
-      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
 
       // Verify old transactions are permanently deleted
       expect(deletedCount).toBe(2);
@@ -276,7 +277,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
       // Mark as mined in block 2
       const laterBlockHeader = BlockHeader.empty({
-        globalVariables: GlobalVariables.empty({ blockNumber: 2, timestamp: 0n }),
+        globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(2), timestamp: 0n }),
       });
       await pool.markAsMined([txs[0].getTxHash()], laterBlockHeader);
 
@@ -284,7 +285,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
       await pool.deleteTxs([txs[0].getTxHash()]);
 
       // Try to clean up with block 1 (before the mined block)
-      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
 
       // Verify no transactions were cleaned up
       expect(deletedCount).toBe(0);

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,11 +1,11 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { NoCommitteeError } from '@aztec/ethereum';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
 export class AttestationValidator implements P2PValidator<BlockAttestation> {
-  private epochCache: EpochCacheInterface;
-  private logger: Logger;
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
@@ -13,47 +13,45 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
   }
 
   async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
-    const slotNumberBigInt = message.payload.header.slotNumber.toBigInt();
+    const slotNumber = message.payload.header.slotNumber;
 
     try {
       const { currentProposer, nextProposer, currentSlot, nextSlot } =
         await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
 
-      if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-        this.logger.warn(
-          `Attestation slot ${slotNumberBigInt} is not current (${currentSlot}) or next (${nextSlot}) slot`,
-        );
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        this.logger.warn(`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 ${slotNumberBigInt}`);
+        this.logger.warn(`Invalid signature in attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
 
       // Verify the attester is in the committee for this slot
-      if (!(await this.epochCache.isInCommittee(slotNumberBigInt, attester))) {
-        this.logger.warn(`Attester ${attester.toString()} is not in committee for slot ${slotNumberBigInt}`);
+      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 this slot
       const proposer = message.getProposer();
-      const expectedProposer = slotNumberBigInt === currentSlot ? currentProposer : nextProposer;
+      const expectedProposer = slotNumber === currentSlot ? currentProposer : nextProposer;
       if (!expectedProposer) {
-        this.logger.warn(`No proposer defined for slot ${slotNumberBigInt}`);
+        this.logger.warn(`No proposer defined for slot ${slotNumber}`);
         return PeerErrorSeverity.HighToleranceError;
       }
       if (!proposer) {
-        this.logger.warn(`Invalid proposer signature in attestation for slot ${slotNumberBigInt}`);
+        this.logger.warn(`Invalid proposer signature in attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
       if (!proposer.equals(expectedProposer)) {
         this.logger.warn(
           `Proposer signature mismatch in attestation. ` +
-            `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumberBigInt}`,
+            `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`,
         );
         return PeerErrorSeverity.HighToleranceError;
       }
@@ -62,7 +60,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 ${slotNumberBigInt}`);
+        this.logger.warn(`No committee exists for attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
       throw e;

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -0,0 +1,91 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { Attributes, Metrics, type TelemetryClient, ValueType } from '@aztec/telemetry-client';
+
+import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
+import { AttestationValidator } 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 AttestationValidator {
+  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, {
+      description: 'The number of invalid attestations received',
+      valueType: ValueType.INT,
+    });
+  }
+
+  override async validate(message: BlockAttestation): 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.getBlockProposal(proposalId);
+
+    if (proposal) {
+      // Compare the attestation payload with the proposal payload
+      if (!message.payload.equals(proposal.payload)) {
+        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.payload.header.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';