@aztec/p2p 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 
 /**
@@ -21,6 +22,15 @@ export interface AttestationPool {
    */
   getBlockProposal(id: string): Promise<BlockProposal | undefined>;
 
+  /**
+   * Check if a block proposal exists in the pool
+   *
+   * @param idOrProposal - The ID of the block proposal or the block proposal itself to check. The ID is proposal.payload.archive
+   *
+   * @return True if the block proposal exists, false otherwise.
+   */
+  hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean>;
+
   /**
    * AddAttestations
    *
@@ -42,7 +52,7 @@ export interface AttestationPool {
    *
    * @param slot - The oldest slot to keep.
    */
-  deleteAttestationsOlderThan(slot: bigint): Promise<void>;
+  deleteAttestationsOlderThan(slot: SlotNumber): Promise<void>;
 
   /**
    * Delete Attestations for slot
@@ -51,7 +61,7 @@ export interface AttestationPool {
    *
    * @param slot - The slot to delete.
    */
-  deleteAttestationsForSlot(slot: bigint): Promise<void>;
+  deleteAttestationsForSlot(slot: SlotNumber): Promise<void>;
 
   /**
    * Delete Attestations for slot and proposal
@@ -61,7 +71,7 @@ export interface AttestationPool {
    * @param slot - The slot to delete.
    * @param proposalId - The proposal to delete.
    */
-  deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void>;
+  deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void>;
 
   /**
    * Get all Attestations for all proposals for a given slot
@@ -71,7 +81,7 @@ export interface AttestationPool {
    * @param slot - The slot to query
    * @return BlockAttestations
    */
-  getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]>;
+  getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]>;
 
   /**
    * Get Attestations for slot and given proposal
@@ -82,7 +92,38 @@ export interface AttestationPool {
    * @param proposalId - The proposal to query
    * @return BlockAttestations
    */
-  getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
+  getAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<BlockAttestation[]>;
+
+  /**
+   * Check if a specific attestation exists in the pool
+   *
+   * @param attestation - The attestation to check
+   * @return True if the attestation exists, false otherwise
+   */
+  hasAttestation(attestation: BlockAttestation): Promise<boolean>;
+
+  /**
+   * Returns whether adding this proposal is permitted at current capacity:
+   * - True if the proposal already exists, allow overwrite to keep parity with tests.
+   * - True if the slot is below the proposal cap.
+   * - False if the slot is at/above cap and this would be a new unique proposal.
+   *
+   * @param block - The block proposal to check
+   * @returns True if the proposal can be added (or already exists), false otherwise.
+   */
+  canAddProposal(block: BlockProposal): Promise<boolean>;
+
+  /**
+   * Returns whether an attestation would be accepted for (slot, proposalId):
+   * - True if the attestation already exists for this sender.
+   * - True if the attestation cap for (slot, proposalId) has not been reached.
+   * - False if the cap is reached and this attestation would be a new unique entry.
+   *
+   * @param attestation - The attestation to check
+   * @param committeeSize - Committee size for the attestation's slot, implementation may add a small buffer
+   * @returns True if the attestation can be added, false otherwise.
+   */
+  canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean>;
 
   /** Returns whether the pool is empty. */
   isEmpty(): Promise<boolean>;

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -1,5 +1,6 @@
-import { Secp256k1Signer } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 import {
   BlockProposal as BlockProposalClass,
@@ -7,7 +8,7 @@ import {
   SignatureDomainSeparator,
   getHashedSignaturePayloadEthSignedMessage,
 } from '@aztec/stdlib/p2p';
-import { makeHeader } from '@aztec/stdlib/testing';
+import { makeL2BlockHeader } from '@aztec/stdlib/testing';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import { jest } from '@jest/globals';
@@ -41,16 +42,15 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   };
 
   const mockBlockProposal = (signer: Secp256k1Signer, slotNumber: number, archive: Fr = Fr.random()): BlockProposal => {
-    const blockNumber = 1;
-    const header = makeHeader(1, 2, slotNumber);
-    const payload = new ConsensusPayload(header.toPropose(), archive, header.state);
+    const header = makeL2BlockHeader(1, 2, slotNumber);
+    const payload = new ConsensusPayload(header.toCheckpointHeader(), archive);
 
     const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
     const signature = signer.sign(hash);
 
     const txHashes = [TxHash.random(), TxHash.random()]; // Mock tx hashes
 
-    return new BlockProposalClass(blockNumber, payload, signature, txHashes);
+    return new BlockProposalClass(payload, signature, txHashes);
   };
 
   // We compare buffers as the objects can have cached values attached to them which are not serialised
@@ -69,11 +69,19 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     await ap.addAttestations(attestations);
 
-    const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), archive.toString());
+    const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      archive.toString(),
+    );
     expect(retrievedAttestations.length).toBe(attestations.length);
     compareAttestations(retrievedAttestations, attestations);
 
-    const retrievedAttestationsForSlot = await ap.getAttestationsForSlot(BigInt(slotNumber));
+    // Check hasAttestation for added attestations
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
+
+    const retrievedAttestationsForSlot = await ap.getAttestationsForSlot(SlotNumber(slotNumber));
     expect(retrievedAttestationsForSlot.length).toBe(attestations.length);
     compareAttestations(retrievedAttestationsForSlot, attestations);
 
@@ -81,23 +89,29 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     const newAttestation = mockAttestation(signers[NUMBER_OF_SIGNERS_PER_TEST - 1], slotNumber, archive);
     await ap.addAttestations([newAttestation]);
     const retrievedAttestationsAfterAdd = await ap.getAttestationsForSlotAndProposal(
-      BigInt(slotNumber),
+      SlotNumber(slotNumber),
       archive.toString(),
     );
     expect(retrievedAttestationsAfterAdd.length).toBe(attestations.length + 1);
     compareAttestations(retrievedAttestationsAfterAdd, [...attestations, newAttestation]);
-    const retrievedAttestationsForSlotAfterAdd = await ap.getAttestationsForSlot(BigInt(slotNumber));
+    expect(await ap.hasAttestation(newAttestation)).toBe(true);
+    const retrievedAttestationsForSlotAfterAdd = await ap.getAttestationsForSlot(SlotNumber(slotNumber));
     expect(retrievedAttestationsForSlotAfterAdd.length).toBe(attestations.length + 1);
     compareAttestations(retrievedAttestationsForSlotAfterAdd, [...attestations, newAttestation]);
 
     // Delete by slot
-    await ap.deleteAttestationsForSlot(BigInt(slotNumber));
+    await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
 
     const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(
-      BigInt(slotNumber),
+      SlotNumber(slotNumber),
       archive.toString(),
     );
     expect(retreivedAttestationsAfterDelete.length).toBe(0);
+    // Check hasAttestation after deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(false);
+    }
+    expect(await ap.hasAttestation(newAttestation)).toBe(false);
   });
 
   it('should handle duplicate proposals in a slot', async () => {
@@ -114,14 +128,17 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     // Add them to store and check we end up with only one
     await ap.addAttestations(attestations);
 
-    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), archive.toString());
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      archive.toString(),
+    );
     expect(retreivedAttestations.length).toBe(1);
     expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
-    expect(retreivedAttestations[0].getSender().toString()).toEqual(signer.address.toString());
+    expect(retreivedAttestations[0].getSender()?.toString()).toEqual(signer.address.toString());
 
     // Try adding them on another operation and check they are still not duplicated
     await ap.addAttestations([attestations[0]]);
-    expect(await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), archive.toString())).toHaveLength(1);
+    expect(await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString())).toHaveLength(1);
   });
 
   it('should store attestations by differing slot', async () => {
@@ -134,7 +151,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       const slot = attestation.payload.header.slotNumber;
       const archive = attestation.archive.toString();
 
-      const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot.toBigInt(), archive);
+      const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot, archive);
       expect(retreivedAttestations.length).toBe(1);
       expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
       expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
@@ -152,7 +169,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       const slot = attestation.payload.header.slotNumber;
       const proposalId = attestation.archive.toString();
 
-      const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot.toBigInt(), proposalId);
+      const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot, proposalId);
       expect(retreivedAttestations.length).toBe(1);
       expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
       expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
@@ -167,14 +184,24 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     await ap.addAttestations(attestations);
 
-    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
+    // Check hasAttestation before deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
+
     await ap.deleteAttestations(attestations);
 
-    const gottenAfterDelete = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    const gottenAfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(gottenAfterDelete.length).toBe(0);
+
+    // Check hasAttestation after deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(false);
+    }
   });
 
   it('should blanket delete attestations per slot', async () => {
@@ -185,13 +212,16 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     await ap.addAttestations(attestations);
 
-    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
-    await ap.deleteAttestationsForSlot(BigInt(slotNumber));
+    await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
 
-    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      proposalId,
+    );
     expect(retreivedAttestationsAfterDelete.length).toBe(0);
   });
 
@@ -209,17 +239,20 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     await ap.addAttestations(attestations);
     await ap.addAttestations(attestations2);
 
-    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
-    await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    await ap.deleteAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
 
-    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      proposalId,
+    );
     expect(retreivedAttestationsAfterDelete.length).toBe(0);
 
     const retreivedAttestationsAfterDeleteForOtherProposal = await ap.getAttestationsForSlotAndProposal(
-      BigInt(slotNumber),
+      SlotNumber(slotNumber),
       proposalId2,
     );
     expect(retreivedAttestationsAfterDeleteForOtherProposal.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
@@ -235,22 +268,22 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     await ap.addAttestations(attestations);
 
-    const attestationsForSlot1 = await ap.getAttestationsForSlotAndProposal(BigInt(1), proposalId);
+    const attestationsForSlot1 = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
     expect(attestationsForSlot1.length).toBe(signers.length);
 
     const deleteAttestationsSpy = jest.spyOn(ap, 'deleteAttestationsForSlot');
 
-    await ap.deleteAttestationsOlderThan(BigInt(73));
+    await ap.deleteAttestationsOlderThan(SlotNumber(73));
 
-    const attestationsForSlot1AfterDelete = await ap.getAttestationsForSlotAndProposal(BigInt(1), proposalId);
+    const attestationsForSlot1AfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
     expect(attestationsForSlot1AfterDelete.length).toBe(0);
 
     expect(deleteAttestationsSpy).toHaveBeenCalledTimes(5);
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(1));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(2));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(3));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(69));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(72));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(1));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(2));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(3));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(69));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(72));
   });
 
   describe('BlockProposal in attestation pool', () => {
@@ -264,18 +297,21 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       const retrievedProposal = await ap.getBlockProposal(proposalId);
 
-      // This are cached values, so we need to call them to ensure they are not undefined
-      retrievedProposal!.payload.getSize();
-      retrievedProposal!.signature.getSize();
-
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal!).toEqual(proposal);
+
+      // Check hasBlockProposal with both id and object
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
+      expect(await ap.hasBlockProposal(proposal)).toBe(true);
     });
 
     it('should return undefined for non-existent block proposal', async () => {
       const nonExistentId = Fr.random().toString();
       const retrievedProposal = await ap.getBlockProposal(nonExistentId);
       expect(retrievedProposal).toBeUndefined();
+
+      // Check hasBlockProposal returns false for non-existent proposal
+      expect(await ap.hasBlockProposal(nonExistentId)).toBe(false);
     });
 
     it('should update block proposal if added twice with same id', async () => {
@@ -295,7 +331,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       expect(retrievedProposal).toBeDefined();
       // Should have the second proposal
       expect(retrievedProposal!.toBuffer()).toEqual(proposal2.toBuffer());
-      expect(retrievedProposal!.getSender().toString()).toBe(signers[1].address.toString());
+      expect(retrievedProposal!.getSender()?.toString()).toBe(signers[1].address.toString());
     });
 
     it('should handle block proposals with different slots and same archive', async () => {
@@ -311,7 +347,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       const retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal!.toBuffer()).toEqual(proposal2.toBuffer());
-      expect(retrievedProposal!.slotNumber.toBigInt()).toBe(BigInt(200));
+      expect(retrievedProposal!.slotNumber).toBe(SlotNumber(200));
     });
 
     it('should delete block proposal when deleting attestations for slot and proposal', async () => {
@@ -328,13 +364,15 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Verify proposal exists
       let retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
 
       // Delete attestations for slot and proposal
-      await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+      await ap.deleteAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
 
       // Proposal should be deleted
       retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeUndefined();
+      expect(await ap.hasBlockProposal(proposalId)).toBe(false);
     });
 
     it('should delete block proposal when deleting attestations for slot', async () => {
@@ -349,13 +387,15 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Verify proposal exists
       let retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
+      expect(await ap.hasBlockProposal(proposal)).toBe(true);
 
       // Delete attestations for slot
-      await ap.deleteAttestationsForSlot(BigInt(slotNumber));
+      await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
 
       // Proposal should be deleted
       retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeUndefined();
+      expect(await ap.hasBlockProposal(proposal)).toBe(false);
     });
 
     it('should be able to fetch both block proposal and attestations', async () => {
@@ -373,16 +413,17 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       // Retrieve both proposal and attestations
       const retrievedProposal = await ap.getBlockProposal(proposalId);
-      const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+      const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
 
       expect(retrievedProposal).toBeDefined();
-      // This are cached values, so we need to call them to ensure they are not undefined
-      retrievedProposal!.payload.getSize();
-      retrievedProposal!.signature.getSize();
-
       expect(retrievedProposal).toEqual(proposal);
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
 
       compareAttestations(retrievedAttestations, attestations);
+      // Check hasAttestation for all attestations
+      for (const attestation of attestations) {
+        expect(await ap.hasAttestation(attestation)).toBe(true);
+      }
     });
   });
 }

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -1,13 +1,18 @@
-import { Fr } from '@aztec/foundation/fields';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import { BlockAttestation, BlockProposal } 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';
 
+export const MAX_PROPOSALS_PER_SLOT = 5;
+export const ATTESTATION_CAP_BUFFER = 10;
+
 export class KvAttestationPool implements AttestationPool {
   private metrics: PoolInstrumentation<BlockAttestation>;
 
@@ -16,7 +21,7 @@ export class KvAttestationPool implements AttestationPool {
     /*  proposal.payload.archive  */ string,
     /* buffer representation of proposal */ Buffer
   >;
-  private proposalsForSlot: AztecAsyncMultiMap<string, string>;
+  private proposalsForSlot: AztecAsyncMultiMap<number, string>;
   private attestationsForProposal: AztecAsyncMultiMap<string, string>;
 
   constructor(
@@ -66,17 +71,29 @@ export class KvAttestationPool implements AttestationPool {
       for (const attestation of attestations) {
         const slotNumber = attestation.payload.header.slotNumber;
         const proposalId = attestation.archive;
-        const address = attestation.getSender().toString();
+        const sender = attestation.getSender();
+
+        // Skip attestations with invalid signatures
+        if (!sender) {
+          this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber}`, {
+            signature: attestation.signature.toString(),
+            slotNumber,
+            proposalId,
+          });
+          continue;
+        }
+
+        const address = sender.toString();
 
         await this.attestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
 
-        await this.proposalsForSlot.set(slotNumber.toString(), proposalId.toString());
+        await this.proposalsForSlot.set(slotNumber, proposalId.toString());
         await this.attestationsForProposal.set(
           this.getProposalKey(slotNumber, proposalId),
           this.getAttestationKey(slotNumber, proposalId, address),
         );
 
-        this.log.verbose(`Added attestation for slot ${slotNumber.toBigInt()} from ${address}`, {
+        this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`, {
           signature: attestation.signature.toString(),
           slotNumber,
           address,
@@ -86,9 +103,8 @@ export class KvAttestationPool implements AttestationPool {
     });
   }
 
-  public async getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
-    const slotFr = new Fr(slot);
-    const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slotFr.toString()));
+  public async getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]> {
+    const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slot));
     const attestations: BlockAttestation[] = [];
 
     for (const proposalId of proposalIds) {
@@ -98,7 +114,7 @@ export class KvAttestationPool implements AttestationPool {
     return attestations;
   }
 
-  public async getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+  public async getAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<BlockAttestation[]> {
     const attestationIds = await toArray(
       this.attestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
     );
@@ -120,21 +136,20 @@ export class KvAttestationPool implements AttestationPool {
     return attestations;
   }
 
-  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
-    const olderThan = await toArray(this.proposalsForSlot.keysAsync({ end: new Fr(oldestSlot).toString() }));
+  public async deleteAttestationsOlderThan(oldestSlot: SlotNumber): Promise<void> {
+    const olderThan = await toArray(this.proposalsForSlot.keysAsync({ end: oldestSlot }));
     for (const oldSlot of olderThan) {
-      await this.deleteAttestationsForSlot(BigInt(oldSlot));
+      await this.deleteAttestationsForSlot(SlotNumber(oldSlot));
     }
   }
 
-  public async deleteAttestationsForSlot(slot: bigint): Promise<void> {
-    const slotFr = new Fr(slot);
+  public async deleteAttestationsForSlot(slot: SlotNumber): Promise<void> {
     let numberOfAttestations = 0;
     await this.store.transactionAsync(async () => {
-      const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slotFr.toString()));
+      const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slot));
       for (const proposalId of proposalIds) {
         const attestations = await toArray(
-          this.attestationsForProposal.getValuesAsync(this.getProposalKey(slotFr, proposalId)),
+          this.attestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
         );
 
         numberOfAttestations += attestations.length;
@@ -143,17 +158,19 @@ export class KvAttestationPool implements AttestationPool {
         }
 
         await this.proposals.delete(proposalId);
-        await this.attestationsForProposal.delete(this.getProposalKey(slotFr, proposalId));
+        await this.attestationsForProposal.delete(this.getProposalKey(slot, proposalId));
       }
 
+      // Delete from proposalsForSlot
+      await this.proposalsForSlot.delete(slot);
+
       this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
     });
   }
 
-  public async deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+  public async deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void> {
     let numberOfAttestations = 0;
     await this.store.transactionAsync(async () => {
-      const slotString = new Fr(slot).toString();
       const attestations = await toArray(
         this.attestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
       );
@@ -164,8 +181,8 @@ export class KvAttestationPool implements AttestationPool {
       }
 
       await this.proposals.delete(proposalId);
-      await this.proposalsForSlot.deleteValue(slotString, proposalId);
-      await this.attestationsForProposal.delete(this.getProposalKey(slotString, proposalId));
+      await this.proposalsForSlot.deleteValue(slot, proposalId);
+      await this.attestationsForProposal.delete(this.getProposalKey(slot, proposalId));
 
       this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
     });
@@ -176,7 +193,15 @@ export class KvAttestationPool implements AttestationPool {
       for (const attestation of attestations) {
         const slotNumber = attestation.payload.header.slotNumber;
         const proposalId = attestation.archive;
-        const address = attestation.getSender().toString();
+        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;
+        }
+
+        const address = sender.toString();
         const key = this.getAttestationKey(slotNumber, proposalId, address);
 
         if (await this.attestations.hasAsync(key)) {
@@ -193,6 +218,22 @@ export class KvAttestationPool implements AttestationPool {
     });
   }
 
+  public async hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive;
+    const sender = attestation.getSender();
+
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return false;
+    }
+
+    const address = sender.toString();
+    const key = this.getAttestationKey(slotNumber, proposalId, address);
+
+    return await this.attestations.hasAsync(key);
+  }
+
   public async getBlockProposal(id: string): Promise<BlockProposal | undefined> {
     const buffer = await this.proposals.getAsync(id);
     try {
@@ -206,10 +247,52 @@ export class KvAttestationPool implements AttestationPool {
     return Promise.resolve(undefined);
   }
 
+  public async hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
+    return await this.proposals.hasAsync(id);
+  }
+
   public async addBlockProposal(blockProposal: BlockProposal): Promise<void> {
     await this.store.transactionAsync(async () => {
-      await this.proposalsForSlot.set(blockProposal.slotNumber.toString(), blockProposal.archive.toString());
-      await this.proposals.set(blockProposal.payload.archive.toString(), blockProposal.toBuffer());
+      const slotKey = blockProposal.slotNumber;
+      const proposalId = blockProposal.archive.toString();
+
+      if (!(await this.canAddProposal(blockProposal))) {
+        throw new ProposalSlotCapExceededError(
+          `Maximum proposals per slot reached: slot=${slotKey} cap=${MAX_PROPOSALS_PER_SLOT} proposal=${proposalId}`,
+        );
+      }
+
+      await this.proposalsForSlot.set(slotKey, proposalId);
+      // Always update the stored proposal buffer so re-adds overwrite with latest data
+      await this.proposals.set(proposalId, blockProposal.toBuffer());
     });
   }
+
+  public async hasReachedProposalCap(slot: SlotNumber): Promise<boolean> {
+    const uniqueProposalCount = await this.proposalsForSlot.getValueCountAsync(slot);
+    return uniqueProposalCount >= MAX_PROPOSALS_PER_SLOT;
+  }
+
+  public async hasReachedAttestationCap(slot: SlotNumber, proposalId: string, committeeSize: number): Promise<boolean> {
+    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
+    return (await this.attestationsForProposal.getValueCountAsync(this.getProposalKey(slot, proposalId))) >= limit;
+  }
+
+  public async canAddProposal(block: BlockProposal): Promise<boolean> {
+    return (
+      (await this.proposals.hasAsync(block.archive.toString())) || !(await this.hasReachedProposalCap(block.slotNumber))
+    );
+  }
+
+  public async canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean> {
+    return (
+      (await this.hasAttestation(attestation)) ||
+      !(await this.hasReachedAttestationCap(
+        attestation.payload.header.slotNumber,
+        attestation.archive.toString(),
+        committeeSize,
+      ))
+    );
+  }
 }