@aztec/p2p 0.0.1-commit.96bb3f7 → 0.0.1-commit.96dac018d

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.js

@@ -1,8 +1,9 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
+import { IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { makeBlockProposal, makeCheckpointProposal, makeL2BlockHeader } from '@aztec/stdlib/testing';
-import { MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeBlockHeader, makeBlockProposal, makeCheckpointHeader, makeCheckpointProposal } from '@aztec/stdlib/testing';
+import { 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;
 export function describeAttestationPool(getAttestationPool) {
@@ -19,7 +20,9 @@ export function describeAttestationPool(getAttestationPool) {
         return signers.map((signer)=>mockCheckpointAttestation(signer, slotNumber, archiveToUse));
     };
     const mockBlockProposalForPool = (signer, slotNumber, archive = Fr.random())=>{
-        const header = makeL2BlockHeader(1, 2, slotNumber);
+        const header = makeBlockHeader(1, {
+            slotNumber: SlotNumber(slotNumber)
+        });
         return makeBlockProposal({
             signer,
             blockHeader: header,
@@ -39,20 +42,16 @@ export function describeAttestationPool(getAttestationPool) {
             const slotNumber = 420;
             const archive = Fr.random();
             const attestations = signers.slice(0, -1).map((signer)=>mockCheckpointAttestation(signer, slotNumber, archive));
-            await ap.addCheckpointAttestations(attestations);
+            await ap.addOwnCheckpointAttestations(attestations);
             const retrievedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
             expect(retrievedAttestations.length).toBe(attestations.length);
             compareCheckpointAttestations(retrievedAttestations, attestations);
-            // Check hasCheckpointAttestation for added attestations
-            for (const attestation of attestations){
-                expect(await ap.hasCheckpointAttestation(attestation)).toBe(true);
-            }
             const retrievedAttestationsForSlot = await ap.getCheckpointAttestationsForSlot(SlotNumber(slotNumber));
             expect(retrievedAttestationsForSlot.length).toBe(attestations.length);
             compareCheckpointAttestations(retrievedAttestationsForSlot, attestations);
             // Add another one
             const newAttestation = mockCheckpointAttestation(signers[NUMBER_OF_SIGNERS_PER_TEST - 1], slotNumber, archive);
-            await ap.addCheckpointAttestations([
+            await ap.addOwnCheckpointAttestations([
                 newAttestation
             ]);
             const retrievedAttestationsAfterAdd = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
@@ -61,7 +60,6 @@ export function describeAttestationPool(getAttestationPool) {
                 ...attestations,
                 newAttestation
             ]);
-            expect(await ap.hasCheckpointAttestation(newAttestation)).toBe(true);
             const retrievedAttestationsForSlotAfterAdd = await ap.getCheckpointAttestationsForSlot(SlotNumber(slotNumber));
             expect(retrievedAttestationsForSlotAfterAdd.length).toBe(attestations.length + 1);
             compareCheckpointAttestations(retrievedAttestationsForSlotAfterAdd, [
@@ -69,32 +67,30 @@ export function describeAttestationPool(getAttestationPool) {
                 newAttestation
             ]);
             // Delete by slot
-            await ap.deleteCheckpointAttestationsOlderThan(SlotNumber(slotNumber + 1));
+            await ap.deleteOlderThan(SlotNumber(slotNumber + 1));
             const retreivedAttestationsAfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
             expect(retreivedAttestationsAfterDelete.length).toBe(0);
-            // Check hasCheckpointAttestation after deletion
-            for (const attestation of attestations){
-                expect(await ap.hasCheckpointAttestation(attestation)).toBe(false);
-            }
-            expect(await ap.hasCheckpointAttestation(newAttestation)).toBe(false);
         });
         it('should handle duplicate proposals in a slot', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
-            // Use the same signer for all attestations
+            const header = CheckpointHeader.random({
+                slotNumber: SlotNumber(slotNumber)
+            });
+            // Use the same signer and header for all attestations
             const attestations = [];
             const signer = signers[0];
             for(let i = 0; i < NUMBER_OF_SIGNERS_PER_TEST; i++){
-                attestations.push(mockCheckpointAttestation(signer, slotNumber, archive));
+                attestations.push(mockCheckpointAttestation(signer, slotNumber, archive, header));
             }
             // Add them to store and check we end up with only one
-            await ap.addCheckpointAttestations(attestations);
+            await ap.addOwnCheckpointAttestations(attestations);
             const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(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());
             // Try adding them on another operation and check they are still not duplicated
-            await ap.addCheckpointAttestations([
+            await ap.addOwnCheckpointAttestations([
                 attestations[0]
             ]);
             expect(await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString())).toHaveLength(1);
@@ -107,7 +103,7 @@ export function describeAttestationPool(getAttestationPool) {
                 4
             ];
             const attestations = signers.map((signer, i)=>mockCheckpointAttestation(signer, slotNumbers[i]));
-            await ap.addCheckpointAttestations(attestations);
+            await ap.addOwnCheckpointAttestations(attestations);
             for (const attestation of attestations){
                 const slot = attestation.payload.header.slotNumber;
                 const archive = attestation.archive.toString();
@@ -131,7 +127,7 @@ export function describeAttestationPool(getAttestationPool) {
                 Fr.random()
             ];
             const attestations = signers.map((signer, i)=>mockCheckpointAttestation(signer, slotNumbers[i], archives[i]));
-            await ap.addCheckpointAttestations(attestations);
+            await ap.addOwnCheckpointAttestations(attestations);
             for (const attestation of attestations){
                 const slot = attestation.payload.header.slotNumber;
                 const proposalId = attestation.archive.toString();
@@ -154,10 +150,10 @@ export function describeAttestationPool(getAttestationPool) {
             ];
             const attestations = (await Promise.all(slotNumbers.map((slotNumber)=>createCheckpointAttestationsForSlot(slotNumber)))).flat();
             const proposalId = attestations[0].archive.toString();
-            await ap.addCheckpointAttestations(attestations);
+            await ap.addOwnCheckpointAttestations(attestations);
             const attestationsForSlot1 = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
             expect(attestationsForSlot1.length).toBe(signers.length);
-            await ap.deleteCheckpointAttestationsOlderThan(SlotNumber(73));
+            await ap.deleteOlderThan(SlotNumber(73));
             const attestationsForSlot1AfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
             expect(attestationsForSlot1AfterDelete.length).toBe(0);
         });
@@ -168,107 +164,88 @@ export function describeAttestationPool(getAttestationPool) {
             const archive = Fr.random();
             const proposal = await mockBlockProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal.archive.toString();
-            await ap.addBlockProposal(proposal);
+            const result = await ap.tryAddBlockProposal(proposal);
+            expect(result.added).toBe(true);
+            expect(result.alreadyExists).toBe(false);
+            expect(result.count).toBe(1);
             const retrievedProposal = await ap.getBlockProposal(proposalId);
             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 ()=>{
+        it('should return alreadyExists when adding proposal with same id', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
             const proposal1 = await mockBlockProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal1.archive.toString();
-            await ap.addBlockProposal(proposal1);
+            const result1 = await ap.tryAddBlockProposal(proposal1);
+            expect(result1.added).toBe(true);
+            expect(result1.alreadyExists).toBe(false);
             // Create a new proposal with same archive but different signer
             const proposal2 = await mockBlockProposalForPool(signers[1], slotNumber, archive);
-            await ap.addBlockProposal(proposal2);
+            const result2 = await ap.tryAddBlockProposal(proposal2);
+            expect(result2.added).toBe(false);
+            expect(result2.alreadyExists).toBe(true);
+            // Should still have the first proposal
             const retrievedProposal = await ap.getBlockProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
-            // Should have the second proposal
-            expect(retrievedProposal.toBuffer()).toEqual(proposal2.toBuffer());
-            expect(retrievedProposal.getSender()?.toString()).toBe(signers[1].address.toString());
-        });
-        it('should handle block proposals with different slots and same archive', async ()=>{
-            const archive = Fr.random();
-            const proposal1 = await mockBlockProposalForPool(signers[0], 100, archive);
-            const proposal2 = await mockBlockProposalForPool(signers[1], 200, archive);
-            const proposalId = archive.toString();
-            await ap.addBlockProposal(proposal1);
-            await ap.addBlockProposal(proposal2);
-            // Should get the latest one added
-            const retrievedProposal = await ap.getBlockProposal(proposalId);
-            expect(retrievedProposal).toBeDefined();
-            expect(retrievedProposal.toBuffer()).toEqual(proposal2.toBuffer());
-            expect(retrievedProposal.slotNumber).toBe(SlotNumber(200));
+            expect(retrievedProposal.toBuffer()).toEqual(proposal1.toBuffer());
+            expect(retrievedProposal.getSender()?.toString()).toBe(signers[0].address.toString());
         });
     });
     describe('CheckpointProposal in attestation pool', ()=>{
-        const mockCheckpointProposalForPool = (signer, slotNumber, archive = Fr.random())=>{
-            const header = makeL2BlockHeader(1, 2, slotNumber);
-            return makeCheckpointProposal({
+        const mockCheckpointProposalForPool = async (signer, slotNumber, archive = Fr.random())=>{
+            const checkpointHeader = makeCheckpointHeader(1, {
+                slotNumber: SlotNumber(slotNumber)
+            });
+            const blockHeader = makeBlockHeader(1);
+            const proposal = await makeCheckpointProposal({
                 signer,
-                checkpointHeader: header.toCheckpointHeader(),
+                checkpointHeader,
                 archiveRoot: archive,
                 lastBlock: {
-                    blockHeader: header
+                    blockHeader
                 }
             });
+            // Return the core version since tryAddCheckpointProposal now takes CheckpointProposalCore
+            return proposal.toCore();
         };
-        it('should add and retrieve checkpoint proposal as core (without lastBlock)', async ()=>{
+        it('should add and retrieve checkpoint proposal', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
             const proposal = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal.archive.toString();
-            await ap.addCheckpointProposal(proposal);
+            const result = await ap.tryAddCheckpointProposal(proposal);
+            expect(result.added).toBe(true);
+            expect(result.alreadyExists).toBe(false);
+            expect(result.count).toBe(1);
             const retrievedProposal = await ap.getCheckpointProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
-            // Should return core version (without lastBlock)
-            expect(retrievedProposal.toBuffer()).toEqual(proposal.toCore().toBuffer());
-            // Check hasCheckpointProposal with both id and object
-            expect(await ap.hasCheckpointProposal(proposalId)).toBe(true);
-            expect(await ap.hasCheckpointProposal(proposal)).toBe(true);
+            expect(retrievedProposal.toBuffer()).toEqual(proposal.toBuffer());
         });
-        it('should extract and store block proposal when adding checkpoint proposal with lastBlock', async ()=>{
+        it('should handle checkpoint proposal without lastBlock (caller extracts and adds block separately)', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
-            const proposal = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
-            const proposalId = proposal.archive.toString();
-            // Verify the proposal has a lastBlock
-            const expectedBlockProposal = proposal.getBlockProposal();
-            expect(expectedBlockProposal).toBeDefined();
-            await ap.addCheckpointProposal(proposal);
-            // The block proposal should be stored separately and retrievable
-            const retrievedBlockProposal = await ap.getBlockProposal(proposalId);
-            expect(retrievedBlockProposal).toBeDefined();
-            expect(retrievedBlockProposal.archive.toString()).toBe(archive.toString());
-            expect(retrievedBlockProposal.blockHeader.toBuffer()).toEqual(expectedBlockProposal.blockHeader.toBuffer());
-        });
-        it('should not store block proposal when checkpoint proposal has no lastBlock', async ()=>{
-            const slotNumber = 420;
-            const archive = Fr.random();
-            const header = makeL2BlockHeader(1, 2, slotNumber);
+            const checkpointHeader = makeCheckpointHeader(1, {
+                slotNumber: SlotNumber(slotNumber)
+            });
             // Create a checkpoint proposal WITHOUT lastBlock
             const proposal = await makeCheckpointProposal({
                 signer: signers[0],
-                checkpointHeader: header.toCheckpointHeader(),
+                checkpointHeader,
                 archiveRoot: archive
             });
             const proposalId = proposal.archive.toString();
-            await ap.addCheckpointProposal(proposal);
+            // Add the checkpoint core - block extraction is now caller responsibility
+            await ap.tryAddCheckpointProposal(proposal.toCore());
             // The checkpoint proposal should be stored
             const retrievedCheckpointProposal = await ap.getCheckpointProposal(proposalId);
             expect(retrievedCheckpointProposal).toBeDefined();
-            // But no block proposal should be stored (archive key won't have a block proposal)
+            // No block proposal was extracted (it had none anyway)
             const retrievedBlockProposal = await ap.getBlockProposal(proposalId);
             expect(retrievedBlockProposal).toBeUndefined();
         });
@@ -276,34 +253,334 @@ export function describeAttestationPool(getAttestationPool) {
             const nonExistentId = Fr.random().toString();
             const retrievedProposal = await ap.getCheckpointProposal(nonExistentId);
             expect(retrievedProposal).toBeUndefined();
-            // Check hasCheckpointProposal returns false for non-existent proposal
-            expect(await ap.hasCheckpointProposal(nonExistentId)).toBe(false);
         });
-        it('should update checkpoint proposal if added twice with same id', async ()=>{
+        it('should return alreadyExists when adding proposal with same id', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
             const proposal1 = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal1.archive.toString();
-            await ap.addCheckpointProposal(proposal1);
+            const result1 = await ap.tryAddCheckpointProposal(proposal1);
+            expect(result1.added).toBe(true);
+            expect(result1.alreadyExists).toBe(false);
             // Create a new proposal with same archive but different signer
             const proposal2 = await mockCheckpointProposalForPool(signers[1], slotNumber, archive);
-            await ap.addCheckpointProposal(proposal2);
+            const result2 = await ap.tryAddCheckpointProposal(proposal2);
+            expect(result2.added).toBe(false);
+            expect(result2.alreadyExists).toBe(true);
+            // Should still have the first proposal
             const retrievedProposal = await ap.getCheckpointProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
-            // Should have the second proposal (as core)
-            expect(retrievedProposal.toBuffer()).toEqual(proposal2.toCore().toBuffer());
-            expect(retrievedProposal.getSender()?.toString()).toBe(signers[1].address.toString());
+            expect(retrievedProposal.toBuffer()).toEqual(proposal1.toBuffer());
+            expect(retrievedProposal.getSender()?.toString()).toBe(signers[0].address.toString());
         });
-        it('should throw ProposalSlotCapExceededError when exceeding capacity', async ()=>{
+        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);
-                await ap.addCheckpointProposal(proposal);
+                const result = await ap.tryAddCheckpointProposal(proposal);
+                expect(result.added).toBe(true);
+                expect(result.count).toBe(i + 1);
             }
-            // The next proposal should throw
+            // The next proposal should not be added
             const extraProposal = await mockCheckpointProposalForPool(signers[0], slotNumber);
-            await expect(ap.addCheckpointProposal(extraProposal)).rejects.toThrow('Maximum checkpoint proposals per slot');
+            const result = await ap.tryAddCheckpointProposal(extraProposal);
+            expect(result.added).toBe(false);
+            expect(result.alreadyExists).toBe(false);
+            expect(result.count).toBe(MAX_CHECKPOINT_PROPOSALS_PER_SLOT);
+        });
+    });
+    describe('Duplicate proposal detection', ()=>{
+        const mockBlockProposalWithIndex = (signer, slotNumber, indexWithinCheckpoint, archive = Fr.random())=>{
+            const header = makeBlockHeader(1, {
+                slotNumber: SlotNumber(slotNumber)
+            });
+            return makeBlockProposal({
+                signer,
+                blockHeader: header,
+                archiveRoot: archive,
+                indexWithinCheckpoint: IndexWithinCheckpoint(indexWithinCheckpoint)
+            });
+        };
+        describe('tryAddBlockProposal duplicate detection', ()=>{
+            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.count).toBe(1);
+            });
+            it('should return alreadyExists when same proposal exists', async ()=>{
+                const proposal = await mockBlockProposalWithIndex(signers[0], 100, 0);
+                await ap.tryAddBlockProposal(proposal);
+                const result = await ap.tryAddBlockProposal(proposal);
+                expect(result.added).toBe(false);
+                expect(result.alreadyExists).toBe(true);
+                expect(result.count).toBe(1);
+            });
+            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.count).toBe(1);
+                // Add a different proposal at same position - this is a duplicate (equivocation)
+                const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
+                const result2 = await ap.tryAddBlockProposal(proposal2);
+                expect(result2.added).toBe(true);
+                expect(result2.alreadyExists).toBe(false);
+                // count >= 2 indicates duplicate detection
+                expect(result2.count).toBe(2);
+            });
+            it('should not detect duplicate for different positions in same slot', async ()=>{
+                const slotNumber = 100;
+                // Add proposal at index 0
+                const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, 0);
+                await ap.tryAddBlockProposal(proposal1);
+                // Add proposal at index 1 (different position)
+                const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, 1);
+                const result = await ap.tryAddBlockProposal(proposal2);
+                expect(result.added).toBe(true);
+                // 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 ()=>{
+                const indexWithinCheckpoint = 0;
+                // Add proposal at slot 100
+                const proposal1 = await mockBlockProposalWithIndex(signers[0], 100, indexWithinCheckpoint);
+                await ap.tryAddBlockProposal(proposal1);
+                // Add proposal at slot 200 (different slot)
+                const proposal2 = await mockBlockProposalWithIndex(signers[1], 200, indexWithinCheckpoint);
+                const result = await ap.tryAddBlockProposal(proposal2);
+                expect(result.added).toBe(true);
+                // count = 1 means no duplicate for this position
+                expect(result.count).toBe(1);
+            });
+            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.count).toBe(1);
+                const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
+                const result2 = await ap.tryAddBlockProposal(proposal2);
+                expect(result2.count).toBe(2);
+                // Add a third proposal for same position
+                const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
+                const result3 = await ap.tryAddBlockProposal(proposal3);
+                expect(result3.added).toBe(true);
+                expect(result3.count).toBe(3);
+            });
+            it('should return added=false when exceeding capacity', async ()=>{
+                const slotNumber = 100;
+                const indexWithinCheckpoint = 0;
+                // 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, indexWithinCheckpoint);
+                    const result = await ap.tryAddBlockProposal(proposal);
+                    expect(result.added).toBe(true);
+                    expect(result.count).toBe(i + 1);
+                }
+                // The next proposal should not be added
+                const extraProposal = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
+                const result = await ap.tryAddBlockProposal(extraProposal);
+                expect(result.added).toBe(false);
+                expect(result.alreadyExists).toBe(false);
+                expect(result.count).toBe(MAX_BLOCK_PROPOSALS_PER_POSITION);
+            });
+            it('should clean up block position index when deleting old data', async ()=>{
+                const slotNumber = 100;
+                const indexWithinCheckpoint = 0;
+                // Add proposal
+                const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
+                await ap.tryAddBlockProposal(proposal1);
+                // 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.count).toBe(2);
+                // Delete old data
+                await ap.deleteOlderThan(SlotNumber(slotNumber + 1));
+                // 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.count).toBe(1);
+            });
+            it('should correctly delete block proposals at slot boundary', async ()=>{
+                // Add proposals at slots 99, 100, and 101 with various indices
+                const proposalSlot99Idx0 = await mockBlockProposalWithIndex(signers[0], 99, 0);
+                const proposalSlot99Idx1 = await mockBlockProposalWithIndex(signers[1], 99, 1);
+                const proposalSlot100Idx0 = await mockBlockProposalWithIndex(signers[2], 100, 0);
+                const proposalSlot101Idx0 = await mockBlockProposalWithIndex(signers[3], 101, 0);
+                await ap.tryAddBlockProposal(proposalSlot99Idx0);
+                await ap.tryAddBlockProposal(proposalSlot99Idx1);
+                await ap.tryAddBlockProposal(proposalSlot100Idx0);
+                await ap.tryAddBlockProposal(proposalSlot101Idx0);
+                // Delete slots older than 100 (should delete slot 99 only)
+                await ap.deleteOlderThan(SlotNumber(100));
+                // 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.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.count).toBe(2); // Still has the original
+                const newProposal101 = await mockBlockProposalWithIndex(signers[2], 101, 0);
+                const result101 = await ap.tryAddBlockProposal(newProposal101);
+                expect(result101.count).toBe(2); // Still has the original
+            });
+            it('should delete all indices for a given slot', async ()=>{
+                const slotNumber = 50;
+                // Add proposals at multiple indices for the same slot
+                const proposal0 = await mockBlockProposalWithIndex(signers[0], slotNumber, 0);
+                const proposal1 = await mockBlockProposalWithIndex(signers[1], slotNumber, 1);
+                const proposal2 = await mockBlockProposalWithIndex(signers[2], slotNumber, 2);
+                await ap.tryAddBlockProposal(proposal0);
+                await ap.tryAddBlockProposal(proposal1);
+                await ap.tryAddBlockProposal(proposal2);
+                // Delete slots older than slotNumber + 1
+                await ap.deleteOlderThan(SlotNumber(slotNumber + 1));
+                // All indices should be cleaned up
+                const newProposal0 = await mockBlockProposalWithIndex(signers[0], slotNumber, 0);
+                const result0 = await ap.tryAddBlockProposal(newProposal0);
+                expect(result0.count).toBe(1);
+                const newProposal1 = await mockBlockProposalWithIndex(signers[1], slotNumber, 1);
+                const result1 = await ap.tryAddBlockProposal(newProposal1);
+                expect(result1.count).toBe(1);
+                const newProposal2 = await mockBlockProposalWithIndex(signers[2], slotNumber, 2);
+                const result2 = await ap.tryAddBlockProposal(newProposal2);
+                expect(result2.count).toBe(1);
+            });
+            it('should delete block proposals from storage when deleting old data', async ()=>{
+                const oldSlot = 50;
+                const newSlot = 100;
+                // Add proposals at old and new slots
+                const oldProposal = await mockBlockProposalWithIndex(signers[0], oldSlot, 0);
+                const newProposal = await mockBlockProposalWithIndex(signers[1], newSlot, 0);
+                await ap.tryAddBlockProposal(oldProposal);
+                await ap.tryAddBlockProposal(newProposal);
+                // Verify both proposals exist
+                expect(await ap.getBlockProposal(oldProposal.archive.toString())).toBeDefined();
+                expect(await ap.getBlockProposal(newProposal.archive.toString())).toBeDefined();
+                // Delete slots older than newSlot (should delete oldSlot)
+                await ap.deleteOlderThan(SlotNumber(newSlot));
+                // Old proposal should be deleted from storage
+                expect(await ap.getBlockProposal(oldProposal.archive.toString())).toBeUndefined();
+                // New proposal should still exist
+                expect(await ap.getBlockProposal(newProposal.archive.toString())).toBeDefined();
+            });
+        });
+        describe('tryAddCheckpointProposal duplicate detection', ()=>{
+            const mockCheckpointProposalCoreForPool = async (signer, slotNumber, archive = Fr.random())=>{
+                const checkpointHeader = makeCheckpointHeader(1, {
+                    slotNumber: SlotNumber(slotNumber)
+                });
+                const blockHeader = makeBlockHeader(1);
+                const proposal = await makeCheckpointProposal({
+                    signer,
+                    checkpointHeader,
+                    archiveRoot: archive,
+                    lastBlock: {
+                        blockHeader
+                    }
+                });
+                return proposal.toCore();
+            };
+            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.count).toBe(1);
+            });
+            it('should return alreadyExists when same proposal exists', async ()=>{
+                const proposal = await mockCheckpointProposalCoreForPool(signers[0], 100);
+                await ap.tryAddCheckpointProposal(proposal);
+                const result = await ap.tryAddCheckpointProposal(proposal);
+                expect(result.added).toBe(false);
+                expect(result.alreadyExists).toBe(true);
+                expect(result.count).toBe(1);
+            });
+            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.count).toBe(1);
+                // Add a different proposal for same slot - this is a duplicate (equivocation)
+                const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
+                const result2 = await ap.tryAddCheckpointProposal(proposal2);
+                expect(result2.added).toBe(true);
+                expect(result2.alreadyExists).toBe(false);
+                // count >= 2 indicates duplicate detection
+                expect(result2.count).toBe(2);
+            });
+            it('should not detect duplicate for different slots', async ()=>{
+                // Add proposal at slot 100
+                const proposal1 = await mockCheckpointProposalCoreForPool(signers[0], 100);
+                await ap.tryAddCheckpointProposal(proposal1);
+                // Add proposal at slot 200 (different slot)
+                const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], 200);
+                const result = await ap.tryAddCheckpointProposal(proposal2);
+                expect(result.added).toBe(true);
+                // count = 1 means no duplicate for this slot
+                expect(result.count).toBe(1);
+            });
+            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.count).toBe(1);
+                const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
+                const result2 = await ap.tryAddCheckpointProposal(proposal2);
+                expect(result2.count).toBe(2);
+                // Add a third proposal for same slot
+                const proposal3 = await mockCheckpointProposalCoreForPool(signers[2], slotNumber);
+                const result3 = await ap.tryAddCheckpointProposal(proposal3);
+                expect(result3.added).toBe(true);
+                expect(result3.count).toBe(3);
+            });
+            it('should not count attestations as proposals for duplicate detection', async ()=>{
+                const slotNumber = 100;
+                const archive = Fr.random();
+                // Attestation arrives BEFORE the checkpoint proposal (race condition in p2p)
+                const attestation = mockCheckpointAttestation(signers[0], slotNumber, archive);
+                await ap.addOwnCheckpointAttestations([
+                    attestation
+                ]);
+                // Now the checkpoint proposal arrives - this should NOT be detected as a duplicate
+                const proposal = await mockCheckpointProposalCoreForPool(signers[1], slotNumber, archive);
+                const result = await ap.tryAddCheckpointProposal(proposal);
+                expect(result.added).toBe(true);
+                expect(result.alreadyExists).toBe(false);
+                // 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 ()=>{
+                const slotNumber = 100;
+                const archive1 = Fr.random();
+                const archive2 = Fr.random();
+                // Add attestations for two different proposals in the same slot
+                const attestation1 = mockCheckpointAttestation(signers[0], slotNumber, archive1);
+                const attestation2 = mockCheckpointAttestation(signers[1], slotNumber, archive2);
+                await ap.addOwnCheckpointAttestations([
+                    attestation1,
+                    attestation2
+                ]);
+                // Add the first checkpoint proposal - should not be affected by attestations
+                const proposal1 = await mockCheckpointProposalCoreForPool(signers[2], slotNumber, archive1);
+                const result1 = await ap.tryAddCheckpointProposal(proposal1);
+                expect(result1.added).toBe(true);
+                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.count).toBe(2);
+            });
         });
     });
 }

package/dest/mem_pools/attestation_pool/index.d.ts

@@ -1,3 +1,2 @@
-export * from './attestation_pool.js';
-export * from './memory_attestation_pool.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsOEJBQThCLENBQUMifQ==
+export { AttestationPool, type AttestationPoolApi, type TryAddResult, createTestAttestationPool, MAX_CHECKPOINT_PROPOSALS_PER_SLOT, MAX_BLOCK_PROPOSALS_PER_POSITION, MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER, } from './attestation_pool.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUNmLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssWUFBWSxFQUNqQix5QkFBeUIsRUFDekIsaUNBQWlDLEVBQ2pDLGdDQUFnQyxFQUNoQyxvQ0FBb0MsR0FDckMsTUFBTSx1QkFBdUIsQ0FBQyJ9

package/dest/mem_pools/attestation_pool/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,yBAAyB,EACzB,iCAAiC,EACjC,gCAAgC,EAChC,oCAAoC,GACrC,MAAM,uBAAuB,CAAC"}

package/dest/mem_pools/attestation_pool/index.js

@@ -1,2 +1 @@
-export * from './attestation_pool.js';
-export * from './memory_attestation_pool.js';
+export { AttestationPool, createTestAttestationPool, MAX_CHECKPOINT_PROPOSALS_PER_SLOT, MAX_BLOCK_PROPOSALS_PER_POSITION, MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER } from './attestation_pool.js';