@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5d02921e

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -19,13 +19,17 @@ export type TryAddResult = {
   added: boolean;
   /** Whether the exact item already existed */
   alreadyExists: boolean;
-  /** Total items for this position - used for duplicate detection */
-  totalForPosition: number;
+  /** Count of items for the position. Meaning varies by method:
+   *  - tryAddBlockProposal: proposals at (slot, indexWithinCheckpoint)
+   *  - tryAddCheckpointProposal: proposals at slot
+   *  - tryAddCheckpointAttestation: attestations by this signer for this slot */
+  count: number;
 };
 
-export const MAX_PROPOSALS_PER_SLOT = 5;
-export const MAX_PROPOSALS_PER_POSITION = 3;
-export const ATTESTATION_CAP_BUFFER = 10;
+export const MAX_CHECKPOINT_PROPOSALS_PER_SLOT = 2;
+export const MAX_BLOCK_PROPOSALS_PER_POSITION = 2;
+/** Maximum attestations a single signer can make per slot before being rejected. */
+export const MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER = 2;
 
 /** Public API interface for attestation pools. Used for typing mocks and test implementations. */
 export type AttestationPoolApi = Pick<
@@ -39,6 +43,7 @@ export type AttestationPoolApi = Pick<
   | 'deleteOlderThan'
   | 'getCheckpointAttestationsForSlot'
   | 'getCheckpointAttestationsForSlotAndProposal'
+  | 'hasBlockProposalsForSlot'
   | 'isEmpty'
 >;
 
@@ -69,6 +74,10 @@ export class AttestationPool {
   // Key: (slot << 10) | indexWithinCheckpoint, Value: archive string
   private blockProposalsForSlotAndIndex: AztecAsyncMultiMap<number, string>;
 
+  // Checkpoint attestations indexed by (slot, signer) for tracking attestations per (slot, signer) for duplicate detection
+  // Key: `${Fr(slot).toString()}-${signerAddress}` string (padded for lexicographic ordering), Value: `proposalId` strings
+  private checkpointAttestationsPerSlotAndSigner: AztecAsyncMultiMap<string, string>;
+
   constructor(
     private store: AztecAsyncKVStore,
     telemetry: TelemetryClient = getTelemetryClient(),
@@ -80,6 +89,7 @@ export class AttestationPool {
 
     // Initialize checkpoint attestations storage
     this.checkpointAttestations = store.openMap('checkpoint_attestations');
+    this.checkpointAttestationsPerSlotAndSigner = store.openMultiMap('checkpoint_attestations_per_slot_and_signer');
 
     // Initialize checkpoint proposal storage
     this.checkpointProposals = store.openMap('checkpoint_proposals');
@@ -133,6 +143,12 @@ export class AttestationPool {
     return { start: `${proposalKey}-`, end: `${proposalKey}-Z` };
   }
 
+  /** Creates a key for the per-signer-per-slot attestation index. Uses padded slot for lexicographic ordering. */
+  private getSlotSignerKey(slot: SlotNumber, signerAddress: string): string {
+    const slotStr = new Fr(slot).toString();
+    return `${slotStr}-${signerAddress}`;
+  }
+
   /** Number of bits reserved for indexWithinCheckpoint in position keys. */
   private static readonly INDEX_BITS = 10;
   /** Maximum indexWithinCheckpoint value (2^10 - 1 = 1023). */
@@ -166,21 +182,21 @@ export class AttestationPool {
       // Check if already exists
       const alreadyExists = await this.blockProposals.hasAsync(proposalId);
       if (alreadyExists) {
-        const totalForPosition = await this.getBlockProposalCountForPosition(
+        const count = await this.getBlockProposalCountForPosition(
           blockProposal.slotNumber,
           blockProposal.indexWithinCheckpoint,
         );
-        return { added: false, alreadyExists: true, totalForPosition };
+        return { added: false, alreadyExists: true, count };
       }
 
       // Get current count for position and check cap, do not add if exceeded
-      const totalForPosition = await this.getBlockProposalCountForPosition(
+      const count = await this.getBlockProposalCountForPosition(
         blockProposal.slotNumber,
         blockProposal.indexWithinCheckpoint,
       );
 
-      if (totalForPosition >= MAX_PROPOSALS_PER_POSITION) {
-        return { added: false, alreadyExists: false, totalForPosition };
+      if (count >= MAX_BLOCK_PROPOSALS_PER_POSITION) {
+        return { added: false, alreadyExists: false, count };
       }
 
       // Add the proposal
@@ -195,7 +211,7 @@ export class AttestationPool {
         },
       );
 
-      return { added: true, alreadyExists: false, totalForPosition: totalForPosition + 1 };
+      return { added: true, alreadyExists: false, count: count + 1 };
     });
   }
 
@@ -239,6 +255,13 @@ export class AttestationPool {
     return undefined;
   }
 
+  /** Checks if any block proposals exist for a given slot (at index 0). */
+  public async hasBlockProposalsForSlot(slot: SlotNumber): Promise<boolean> {
+    const positionKey = this.getBlockPositionKey(slot, 0);
+    const count = await this.blockProposalsForSlotAndIndex.getValueCountAsync(positionKey);
+    return count > 0;
+  }
+
   /**
    * Attempts to add a checkpoint proposal to the pool.
    *
@@ -255,20 +278,20 @@ export class AttestationPool {
    * @returns Result indicating whether the proposal was added and duplicate detection info
    */
   public async tryAddCheckpointProposal(proposal: CheckpointProposalCore): Promise<TryAddResult> {
-    return await this.store.transactionAsync(async () => {
+    const result = await this.store.transactionAsync(async () => {
       const proposalId = proposal.archive.toString();
 
       // Check if already exists
       const alreadyExists = await this.checkpointProposals.hasAsync(proposalId);
       if (alreadyExists) {
-        const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
-        return { added: false, alreadyExists: true, totalForPosition };
+        const count = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+        return { added: false, alreadyExists: true, count };
       }
 
       // Get current count for slot and check cap
-      const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
-      if (totalForPosition >= MAX_PROPOSALS_PER_SLOT) {
-        return { added: false, alreadyExists: false, totalForPosition };
+      const count = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+      if (count >= MAX_CHECKPOINT_PROPOSALS_PER_SLOT) {
+        return { added: false, alreadyExists: false, count };
       }
 
       // Add the proposal if cap not exceeded
@@ -279,8 +302,10 @@ export class AttestationPool {
         slotNumber: proposal.slotNumber,
       });
 
-      return { added: true, alreadyExists: false, totalForPosition: totalForPosition + 1 };
+      return { added: true, alreadyExists: false, count: count + 1 };
     });
+
+    return result;
   }
 
   /** Internal method - must be called within a transaction. */
@@ -322,7 +347,7 @@ export class AttestationPool {
     await this.store.transactionAsync(async () => {
       for (const attestation of attestations) {
         const slotNumber = attestation.payload.header.slotNumber;
-        const proposalId = attestation.archive;
+        const proposalId = attestation.archive.toString();
         const sender = attestation.getSender();
 
         // Skip attestations with invalid signatures
@@ -336,11 +361,10 @@ export class AttestationPool {
         }
 
         const address = sender.toString();
+        const ownKey = this.getAttestationKey(slotNumber, proposalId, address);
 
-        await this.checkpointAttestations.set(
-          this.getAttestationKey(slotNumber, proposalId, address),
-          attestation.toBuffer(),
-        );
+        await this.checkpointAttestations.set(ownKey, attestation.toBuffer());
+        this.metrics.trackMempoolItemAdded(ownKey);
 
         this.log.debug(`Added own checkpoint attestation for slot ${slotNumber} from ${address}`, {
           signature: attestation.signature.toString(),
@@ -406,9 +430,18 @@ export class AttestationPool {
       const attestationEndKey = new Fr(oldestSlot).toString();
       for await (const key of this.checkpointAttestations.keysAsync({ end: attestationEndKey })) {
         await this.checkpointAttestations.delete(key);
+        this.metrics.trackMempoolItemRemoved(key);
         numberOfAttestations++;
       }
 
+      // Clean up per-signer-per-slot index. Keys are formatted as `${Fr(slot).toString()}-${signerAddress}`.
+      // Since Fr pads to fixed-width hex, Fr(oldestSlot) is lexicographically greater than any key with
+      // a smaller slot (even with the signer suffix), so using it as the exclusive end bound is correct.
+      const slotSignerEndKey = new Fr(oldestSlot).toString();
+      for await (const key of this.checkpointAttestationsPerSlotAndSigner.keysAsync({ end: slotSignerEndKey })) {
+        await this.checkpointAttestationsPerSlotAndSigner.delete(key);
+      }
+
       // Delete checkpoint proposals for slots < oldestSlot, using checkpointProposalsForSlot as index
       for await (const slot of this.checkpointProposalsForSlot.keysAsync({ end: oldestSlot })) {
         const proposalIds = await toArray(this.checkpointProposalsForSlot.getValuesAsync(slot));
@@ -445,61 +478,82 @@ export class AttestationPool {
    *
    * This method performs validation and addition in a single call:
    * - Checks if the attestation already exists (returns alreadyExists: true if so)
-   * - Checks if the (slot, proposalId) has reached the attestation cap (returns added: false if so)
+   * - Checks if this signer has reached the per-signer attestation cap for this slot
    * - Adds the attestation if validation passes
    *
    * @param attestation - The checkpoint attestation to add
-   * @param committeeSize - Committee size for the attestation's slot
-   * @returns Result indicating whether the attestation was added and existence info
+   * @returns Result indicating whether the attestation was added, existence info, and count of
+   *          attestations by this signer for this slot (for equivocation detection)
    */
-  public async tryAddCheckpointAttestation(
-    attestation: CheckpointAttestation,
-    committeeSize: number,
-  ): Promise<TryAddResult> {
+  public async tryAddCheckpointAttestation(attestation: CheckpointAttestation): Promise<TryAddResult> {
     const slotNumber = attestation.payload.header.slotNumber;
     const proposalId = attestation.archive.toString();
     const sender = attestation.getSender();
 
     if (!sender) {
-      return { added: false, alreadyExists: false, totalForPosition: 0 };
+      return { added: false, alreadyExists: false, count: 0 };
     }
 
+    const signerAddress = sender.toString();
+
     return await this.store.transactionAsync(async () => {
-      const key = this.getAttestationKey(slotNumber, proposalId, sender.toString());
+      const key = this.getAttestationKey(slotNumber, proposalId, signerAddress);
       const alreadyExists = await this.checkpointAttestations.hasAsync(key);
 
+      // Get count of attestations by this signer for this slot (for duplicate detection)
+      const signerAttestationCount = await this.getSignerAttestationCountForSlot(slotNumber, signerAddress);
+
       if (alreadyExists) {
-        const total = await this.getAttestationCount(slotNumber, proposalId);
-        return { added: false, alreadyExists: true, totalForPosition: total };
+        return {
+          added: false,
+          alreadyExists: true,
+          count: signerAttestationCount,
+        };
       }
 
-      const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-      const currentCount = await this.getAttestationCount(slotNumber, proposalId);
-
-      if (currentCount >= limit) {
-        return { added: false, alreadyExists: false, totalForPosition: currentCount };
+      // Check if this signer has exceeded the per-signer cap for this slot
+      if (signerAttestationCount >= MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER) {
+        this.log.debug(`Rejecting attestation: signer ${signerAddress} exceeded per-slot cap for slot ${slotNumber}`, {
+          slotNumber,
+          signerAddress,
+          proposalId,
+          signerAttestationCount,
+        });
+        return {
+          added: false,
+          alreadyExists: false,
+          count: signerAttestationCount,
+        };
       }
 
+      // Add the attestation
       await this.checkpointAttestations.set(key, attestation.toBuffer());
+      this.metrics.trackMempoolItemAdded(key);
+
+      // Track this attestation in the per-signer-per-slot index for duplicate detection
+      const slotSignerKey = this.getSlotSignerKey(slotNumber, signerAddress);
+      await this.checkpointAttestationsPerSlotAndSigner.set(slotSignerKey, proposalId);
 
-      this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${sender.toString()}`, {
+      this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${signerAddress}`, {
         signature: attestation.signature.toString(),
         slotNumber,
-        address: sender.toString(),
+        address: signerAddress,
         proposalId,
       });
-      return { added: true, alreadyExists: false, totalForPosition: currentCount + 1 };
+
+      // Return the new count
+      return {
+        added: true,
+        alreadyExists: false,
+        count: signerAttestationCount + 1,
+      };
     });
   }
 
-  /** Gets the count of attestations for a given (slot, proposalId). */
-  private async getAttestationCount(slot: SlotNumber, proposalId: string): Promise<number> {
-    const range = this.getAttestationKeyRangeForProposal(slot, proposalId);
-    let count = 0;
-    for await (const _ of this.checkpointAttestations.keysAsync(range)) {
-      count++;
-    }
-    return count;
+  /** Gets the count of attestations by a specific signer for a given slot. */
+  private async getSignerAttestationCountForSlot(slot: SlotNumber, signerAddress: string): Promise<number> {
+    const slotSignerKey = this.getSlotSignerKey(slot, signerAddress);
+    return await this.checkpointAttestationsPerSlotAndSigner.getValueCountAsync(slotSignerKey);
   }
 }
 

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -10,7 +10,11 @@ import {
   makeCheckpointProposal,
 } from '@aztec/stdlib/testing';
 
-import { type AttestationPool, MAX_PROPOSALS_PER_POSITION, MAX_PROPOSALS_PER_SLOT } from './attestation_pool.js';
+import {
+  type AttestationPool,
+  MAX_BLOCK_PROPOSALS_PER_POSITION,
+  MAX_CHECKPOINT_PROPOSALS_PER_SLOT,
+} from './attestation_pool.js';
 import { mockCheckpointAttestation } from './mocks.js';
 
 const NUMBER_OF_SIGNERS_PER_TEST = 4;
@@ -191,7 +195,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(result.added).toBe(true);
       expect(result.alreadyExists).toBe(false);
-      expect(result.totalForPosition).toBe(1);
+      expect(result.count).toBe(1);
 
       const retrievedProposal = await ap.getBlockProposal(proposalId);
 
@@ -258,7 +262,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(result.added).toBe(true);
       expect(result.alreadyExists).toBe(false);
-      expect(result.totalForPosition).toBe(1);
+      expect(result.count).toBe(1);
 
       const retrievedProposal = await ap.getCheckpointProposal(proposalId);
 
@@ -324,12 +328,12 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     it('should return added=false when exceeding capacity', async () => {
       const slotNumber = 420;
 
-      // Add MAX_PROPOSALS_PER_SLOT proposals
-      for (let i = 0; i < MAX_PROPOSALS_PER_SLOT; i++) {
+      // Add MAX_CHECKPOINT_PROPOSALS_PER_SLOT proposals
+      for (let i = 0; i < MAX_CHECKPOINT_PROPOSALS_PER_SLOT; i++) {
         const proposal = await mockCheckpointProposalForPool(signers[i % NUMBER_OF_SIGNERS_PER_TEST], slotNumber);
         const result = await ap.tryAddCheckpointProposal(proposal);
         expect(result.added).toBe(true);
-        expect(result.totalForPosition).toBe(i + 1);
+        expect(result.count).toBe(i + 1);
       }
 
       // The next proposal should not be added
@@ -337,7 +341,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       const result = await ap.tryAddCheckpointProposal(extraProposal);
       expect(result.added).toBe(false);
       expect(result.alreadyExists).toBe(false);
-      expect(result.totalForPosition).toBe(MAX_PROPOSALS_PER_SLOT);
+      expect(result.count).toBe(MAX_CHECKPOINT_PROPOSALS_PER_SLOT);
     });
   });
 
@@ -358,13 +362,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     };
 
     describe('tryAddBlockProposal duplicate detection', () => {
-      it('should return totalForPosition=1 when pool is empty', async () => {
+      it('should return count=1 when pool is empty', async () => {
         const proposal = await mockBlockProposalWithIndex(signers[0], 100, 0);
         const result = await ap.tryAddBlockProposal(proposal);
 
         expect(result.added).toBe(true);
         expect(result.alreadyExists).toBe(false);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
       it('should return alreadyExists when same proposal exists', async () => {
@@ -375,17 +379,17 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result.added).toBe(false);
         expect(result.alreadyExists).toBe(true);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
-      it('should detect duplicate via totalForPosition when different proposal exists at same position', async () => {
+      it('should detect duplicate via count when different proposal exists at same position', async () => {
         const slotNumber = 100;
         const indexWithinCheckpoint = 2;
 
         // Add first proposal
         const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
         const result1 = await ap.tryAddBlockProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         // Add a different proposal at same position - this is a duplicate (equivocation)
         const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
@@ -393,8 +397,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result2.added).toBe(true);
         expect(result2.alreadyExists).toBe(false);
-        // totalForPosition >= 2 indicates duplicate detection
-        expect(result2.totalForPosition).toBe(2);
+        // count >= 2 indicates duplicate detection
+        expect(result2.count).toBe(2);
       });
 
       it('should not detect duplicate for different positions in same slot', async () => {
@@ -409,8 +413,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddBlockProposal(proposal2);
 
         expect(result.added).toBe(true);
-        // totalForPosition = 1 means no duplicate for this position
-        expect(result.totalForPosition).toBe(1);
+        // count = 1 means no duplicate for this position
+        expect(result.count).toBe(1);
       });
 
       it('should not detect duplicate for same position in different slots', async () => {
@@ -425,37 +429,37 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddBlockProposal(proposal2);
 
         expect(result.added).toBe(true);
-        // totalForPosition = 1 means no duplicate for this position
-        expect(result.totalForPosition).toBe(1);
+        // count = 1 means no duplicate for this position
+        expect(result.count).toBe(1);
       });
 
-      it('should track multiple duplicates correctly via totalForPosition', async () => {
+      it('should track multiple duplicates correctly via count', async () => {
         const slotNumber = 100;
         const indexWithinCheckpoint = 0;
 
         // Add multiple proposals for same position
         const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
         const result1 = await ap.tryAddBlockProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
         const result2 = await ap.tryAddBlockProposal(proposal2);
-        expect(result2.totalForPosition).toBe(2);
+        expect(result2.count).toBe(2);
 
-        // Add a third proposal for same position
+        // Third proposal for same position should be rejected (cap is 2)
         const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
         const result3 = await ap.tryAddBlockProposal(proposal3);
 
-        expect(result3.added).toBe(true);
-        expect(result3.totalForPosition).toBe(3);
+        expect(result3.added).toBe(false);
+        expect(result3.count).toBe(2);
       });
 
       it('should return added=false when exceeding capacity', async () => {
         const slotNumber = 100;
         const indexWithinCheckpoint = 0;
 
-        // Add MAX_PROPOSALS_PER_POSITION proposals
-        for (let i = 0; i < MAX_PROPOSALS_PER_POSITION; i++) {
+        // Add MAX_BLOCK_PROPOSALS_PER_POSITION proposals
+        for (let i = 0; i < MAX_BLOCK_PROPOSALS_PER_POSITION; i++) {
           const proposal = await mockBlockProposalWithIndex(
             signers[i % NUMBER_OF_SIGNERS_PER_TEST],
             slotNumber,
@@ -463,7 +467,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
           );
           const result = await ap.tryAddBlockProposal(proposal);
           expect(result.added).toBe(true);
-          expect(result.totalForPosition).toBe(i + 1);
+          expect(result.count).toBe(i + 1);
         }
 
         // The next proposal should not be added
@@ -471,7 +475,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddBlockProposal(extraProposal);
         expect(result.added).toBe(false);
         expect(result.alreadyExists).toBe(false);
-        expect(result.totalForPosition).toBe(MAX_PROPOSALS_PER_POSITION);
+        expect(result.count).toBe(MAX_BLOCK_PROPOSALS_PER_POSITION);
       });
 
       it('should clean up block position index when deleting old data', async () => {
@@ -482,18 +486,18 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
         await ap.tryAddBlockProposal(proposal1);
 
-        // Verify it's tracked (adding another should show totalForPosition = 2)
+        // Verify it's tracked (adding another should show count = 2)
         const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
         let result = await ap.tryAddBlockProposal(proposal2);
-        expect(result.totalForPosition).toBe(2);
+        expect(result.count).toBe(2);
 
         // Delete old data
         await ap.deleteOlderThan(SlotNumber(slotNumber + 1));
 
-        // Verify position index is cleaned up (totalForPosition should be 1 now)
+        // Verify position index is cleaned up (count should be 1 now)
         const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
         result = await ap.tryAddBlockProposal(proposal3);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
       it('should correctly delete block proposals at slot boundary', async () => {
@@ -514,16 +518,16 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         // Slot 99 proposals should have their index cleaned up
         const newProposal99 = await mockBlockProposalWithIndex(signers[0], 99, 0);
         const result99 = await ap.tryAddBlockProposal(newProposal99);
-        expect(result99.totalForPosition).toBe(1); // Index was cleaned up
+        expect(result99.count).toBe(1); // Index was cleaned up
 
         // Slot 100 and 101 should still be tracked
         const newProposal100 = await mockBlockProposalWithIndex(signers[1], 100, 0);
         const result100 = await ap.tryAddBlockProposal(newProposal100);
-        expect(result100.totalForPosition).toBe(2); // Still has the original
+        expect(result100.count).toBe(2); // Still has the original
 
         const newProposal101 = await mockBlockProposalWithIndex(signers[2], 101, 0);
         const result101 = await ap.tryAddBlockProposal(newProposal101);
-        expect(result101.totalForPosition).toBe(2); // Still has the original
+        expect(result101.count).toBe(2); // Still has the original
       });
 
       it('should delete all indices for a given slot', async () => {
@@ -544,15 +548,15 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         // All indices should be cleaned up
         const newProposal0 = await mockBlockProposalWithIndex(signers[0], slotNumber, 0);
         const result0 = await ap.tryAddBlockProposal(newProposal0);
-        expect(result0.totalForPosition).toBe(1);
+        expect(result0.count).toBe(1);
 
         const newProposal1 = await mockBlockProposalWithIndex(signers[1], slotNumber, 1);
         const result1 = await ap.tryAddBlockProposal(newProposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         const newProposal2 = await mockBlockProposalWithIndex(signers[2], slotNumber, 2);
         const result2 = await ap.tryAddBlockProposal(newProposal2);
-        expect(result2.totalForPosition).toBe(1);
+        expect(result2.count).toBe(1);
       });
 
       it('should delete block proposals from storage when deleting old data', async () => {
@@ -598,13 +602,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         return proposal.toCore();
       };
 
-      it('should return totalForPosition=1 when pool is empty', async () => {
+      it('should return count=1 when pool is empty', async () => {
         const proposal = await mockCheckpointProposalCoreForPool(signers[0], 100);
         const result = await ap.tryAddCheckpointProposal(proposal);
 
         expect(result.added).toBe(true);
         expect(result.alreadyExists).toBe(false);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
       it('should return alreadyExists when same proposal exists', async () => {
@@ -615,16 +619,16 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result.added).toBe(false);
         expect(result.alreadyExists).toBe(true);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
-      it('should detect duplicate via totalForPosition when different proposal exists for same slot', async () => {
+      it('should detect duplicate via count when different proposal exists for same slot', async () => {
         const slotNumber = 100;
 
         // Add first proposal
         const proposal1 = await mockCheckpointProposalCoreForPool(signers[0], slotNumber);
         const result1 = await ap.tryAddCheckpointProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         // Add a different proposal for same slot - this is a duplicate (equivocation)
         const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
@@ -632,8 +636,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result2.added).toBe(true);
         expect(result2.alreadyExists).toBe(false);
-        // totalForPosition >= 2 indicates duplicate detection
-        expect(result2.totalForPosition).toBe(2);
+        // count >= 2 indicates duplicate detection
+        expect(result2.count).toBe(2);
       });
 
       it('should not detect duplicate for different slots', async () => {
@@ -646,28 +650,28 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddCheckpointProposal(proposal2);
 
         expect(result.added).toBe(true);
-        // totalForPosition = 1 means no duplicate for this slot
-        expect(result.totalForPosition).toBe(1);
+        // count = 1 means no duplicate for this slot
+        expect(result.count).toBe(1);
       });
 
-      it('should track multiple duplicates correctly via totalForPosition', async () => {
+      it('should track multiple duplicates correctly via count', async () => {
         const slotNumber = 100;
 
         // Add multiple proposals for same slot
         const proposal1 = await mockCheckpointProposalCoreForPool(signers[0], slotNumber);
         const result1 = await ap.tryAddCheckpointProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
         const result2 = await ap.tryAddCheckpointProposal(proposal2);
-        expect(result2.totalForPosition).toBe(2);
+        expect(result2.count).toBe(2);
 
-        // Add a third proposal for same slot
+        // Third proposal for same slot should be rejected (cap is 2)
         const proposal3 = await mockCheckpointProposalCoreForPool(signers[2], slotNumber);
         const result3 = await ap.tryAddCheckpointProposal(proposal3);
 
-        expect(result3.added).toBe(true);
-        expect(result3.totalForPosition).toBe(3);
+        expect(result3.added).toBe(false);
+        expect(result3.count).toBe(2);
       });
 
       it('should not count attestations as proposals for duplicate detection', async () => {
@@ -684,8 +688,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result.added).toBe(true);
         expect(result.alreadyExists).toBe(false);
-        // totalForPosition should be 1, NOT 2 - attestations should not count as proposals
-        expect(result.totalForPosition).toBe(1);
+        // count should be 1, NOT 2 - attestations should not count as proposals
+        expect(result.count).toBe(1);
       });
 
       it('should not count attestations for different proposals as duplicates', async () => {
@@ -703,14 +707,14 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result1 = await ap.tryAddCheckpointProposal(proposal1);
 
         expect(result1.added).toBe(true);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         // Add the second checkpoint proposal - this IS a duplicate (different archive, same slot)
         const proposal2 = await mockCheckpointProposalCoreForPool(signers[3], slotNumber, archive2);
         const result2 = await ap.tryAddCheckpointProposal(proposal2);
 
         expect(result2.added).toBe(true);
-        expect(result2.totalForPosition).toBe(2);
+        expect(result2.count).toBe(2);
       });
     });
   });

package/src/mem_pools/attestation_pool/index.ts

@@ -3,7 +3,7 @@ export {
   type AttestationPoolApi,
   type TryAddResult,
   createTestAttestationPool,
-  MAX_PROPOSALS_PER_SLOT,
-  MAX_PROPOSALS_PER_POSITION,
-  ATTESTATION_CAP_BUFFER,
+  MAX_CHECKPOINT_PROPOSALS_PER_SLOT,
+  MAX_BLOCK_PROPOSALS_PER_POSITION,
+  MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER,
 } from './attestation_pool.js';