@aztec/p2p 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.js

@@ -1,243 +1,178 @@
 import { SlotNumber } from '@aztec/foundation/branded-types';
-import { Secp256k1Signer } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { BlockProposal as BlockProposalClass, ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '@aztec/stdlib/p2p';
-import { makeL2BlockHeader } from '@aztec/stdlib/testing';
-import { TxHash } from '@aztec/stdlib/tx';
-import { jest } from '@jest/globals';
-import { mock } from 'jest-mock-extended';
-import { mockAttestation } from './mocks.js';
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeBlockHeader, makeBlockProposal, makeCheckpointHeader, makeCheckpointProposal } from '@aztec/stdlib/testing';
+import { MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
+import { mockCheckpointAttestation } from './mocks.js';
 const NUMBER_OF_SIGNERS_PER_TEST = 4;
 export function describeAttestationPool(getAttestationPool) {
     let ap;
     let signers;
-    // Check that metrics are recorded correctly
-    let metricsMock;
     beforeEach(()=>{
         ap = getAttestationPool();
         signers = Array.from({
             length: NUMBER_OF_SIGNERS_PER_TEST
         }, ()=>Secp256k1Signer.random());
-        metricsMock = mock();
-        // Can i overwrite this like this??
-        ap.metrics = metricsMock;
     });
-    const createAttestationsForSlot = (slotNumber)=>{
-        const archive = Fr.random();
-        return signers.map((signer)=>mockAttestation(signer, slotNumber, archive));
+    const createCheckpointAttestationsForSlot = (slotNumber, archive)=>{
+        const archiveToUse = archive ?? Fr.random();
+        return signers.map((signer)=>mockCheckpointAttestation(signer, slotNumber, archiveToUse));
     };
-    const mockBlockProposal = (signer, slotNumber, archive = Fr.random())=>{
-        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(payload, signature, txHashes);
+    const mockBlockProposalForPool = (signer, slotNumber, archive = Fr.random())=>{
+        const header = makeBlockHeader(1, {
+            slotNumber: SlotNumber(slotNumber)
+        });
+        return makeBlockProposal({
+            signer,
+            blockHeader: header,
+            archiveRoot: archive
+        });
     };
-    // We compare buffers as the objects can have cached values attached to them which are not serialised
-    // using array containing as the kv store does not respect insertion order
-    const compareAttestations = (a1, a2)=>{
+    // Compare checkpoint attestations buffers
+    // Using array containing as the kv store does not respect insertion order
+    const compareCheckpointAttestations = (a1, a2)=>{
         const a1Buffer = a1.map((attestation)=>attestation.toBuffer());
         const a2Buffer = a2.map((attestation)=>attestation.toBuffer());
         expect(a1Buffer.length).toBe(a2Buffer.length);
         expect(a1Buffer).toEqual(expect.arrayContaining(a2Buffer));
     };
-    it('should add attestations to pool', async ()=>{
-        const slotNumber = 420;
-        const archive = Fr.random();
-        const attestations = signers.slice(0, -1).map((signer)=>mockAttestation(signer, slotNumber, archive));
-        await ap.addAttestations(attestations);
-        const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
-        expect(retrievedAttestations.length).toBe(attestations.length);
-        compareAttestations(retrievedAttestations, attestations);
-        // 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);
-        // Add another one
-        const newAttestation = mockAttestation(signers[NUMBER_OF_SIGNERS_PER_TEST - 1], slotNumber, archive);
-        await ap.addAttestations([
-            newAttestation
-        ]);
-        const retrievedAttestationsAfterAdd = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
-        expect(retrievedAttestationsAfterAdd.length).toBe(attestations.length + 1);
-        compareAttestations(retrievedAttestationsAfterAdd, [
-            ...attestations,
-            newAttestation
-        ]);
-        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(SlotNumber(slotNumber));
-        const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(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 ()=>{
-        const slotNumber = 420;
-        const archive = Fr.random();
-        // Use the same signer for all attestations
-        const attestations = [];
-        const signer = signers[0];
-        for(let i = 0; i < NUMBER_OF_SIGNERS_PER_TEST; i++){
-            attestations.push(mockAttestation(signer, slotNumber, archive));
-        }
-        // Add them to store and check we end up with only one
-        await ap.addAttestations(attestations);
-        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());
-        // Try adding them on another operation and check they are still not duplicated
-        await ap.addAttestations([
-            attestations[0]
-        ]);
-        expect(await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString())).toHaveLength(1);
-    });
-    it('should store attestations by differing slot', async ()=>{
-        const slotNumbers = [
-            1,
-            2,
-            3,
-            4
-        ];
-        const attestations = signers.map((signer, i)=>mockAttestation(signer, slotNumbers[i]));
-        await ap.addAttestations(attestations);
-        for (const attestation of attestations){
-            const slot = attestation.payload.header.slotNumber;
-            const archive = attestation.archive.toString();
-            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);
-        }
-    });
-    it('should store attestations by differing slot and archive', async ()=>{
-        const slotNumbers = [
-            1,
-            1,
-            2,
-            3
-        ];
-        const archives = [
-            Fr.random(),
-            Fr.random(),
-            Fr.random(),
-            Fr.random()
-        ];
-        const attestations = signers.map((signer, i)=>mockAttestation(signer, slotNumbers[i], archives[i]));
-        await ap.addAttestations(attestations);
-        for (const attestation of attestations){
-            const slot = attestation.payload.header.slotNumber;
-            const proposalId = attestation.archive.toString();
-            const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot, proposalId);
+    describe('CheckpointAttestation', ()=>{
+        it('should add attestations to pool', async ()=>{
+            const slotNumber = 420;
+            const archive = Fr.random();
+            const attestations = signers.slice(0, -1).map((signer)=>mockCheckpointAttestation(signer, slotNumber, archive));
+            await ap.addCheckpointAttestations(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([
+                newAttestation
+            ]);
+            const retrievedAttestationsAfterAdd = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
+            expect(retrievedAttestationsAfterAdd.length).toBe(attestations.length + 1);
+            compareCheckpointAttestations(retrievedAttestationsAfterAdd, [
+                ...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, [
+                ...attestations,
+                newAttestation
+            ]);
+            // Delete by slot
+            await ap.deleteCheckpointAttestationsOlderThan(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();
+            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, header));
+            }
+            // Add them to store and check we end up with only one
+            await ap.addCheckpointAttestations(attestations);
+            const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
             expect(retreivedAttestations.length).toBe(1);
-            expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
-            expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
-        }
-    });
-    it('should delete attestations', async ()=>{
-        const slotNumber = 420;
-        const archive = Fr.random();
-        const attestations = signers.map((signer)=>mockAttestation(signer, slotNumber, archive));
-        const proposalId = attestations[0].archive.toString();
-        await ap.addAttestations(attestations);
-        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(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 ()=>{
-        const slotNumber = 420;
-        const archive = Fr.random();
-        const attestations = signers.map((signer)=>mockAttestation(signer, slotNumber, archive));
-        const proposalId = attestations[0].archive.toString();
-        await ap.addAttestations(attestations);
-        const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
-        expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
-        compareAttestations(retreivedAttestations, attestations);
-        await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
-        const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
-        expect(retreivedAttestationsAfterDelete.length).toBe(0);
-    });
-    it('should blanket delete attestations per slot and proposal', async ()=>{
-        const slotNumber = 420;
-        const archive = Fr.random();
-        const attestations = signers.map((signer)=>mockAttestation(signer, slotNumber, archive));
-        const proposalId = attestations[0].archive.toString();
-        // Add another set of attestations with a different proposalId, yet the same slot
-        const archive2 = Fr.random();
-        const attestations2 = signers.map((signer)=>mockAttestation(signer, slotNumber, archive2));
-        const proposalId2 = attestations2[0].archive.toString();
-        await ap.addAttestations(attestations);
-        await ap.addAttestations(attestations2);
-        const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
-        expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
-        compareAttestations(retreivedAttestations, attestations);
-        await ap.deleteAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
-        const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
-        expect(retreivedAttestationsAfterDelete.length).toBe(0);
-        const retreivedAttestationsAfterDeleteForOtherProposal = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId2);
-        expect(retreivedAttestationsAfterDeleteForOtherProposal.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
-        compareAttestations(retreivedAttestationsAfterDeleteForOtherProposal, attestations2);
-    });
-    it('should delete attestations older than a given slot', async ()=>{
-        const slotNumbers = [
-            1,
-            2,
-            3,
-            69,
-            72,
-            74,
-            88,
-            420
-        ];
-        const attestations = (await Promise.all(slotNumbers.map((slotNumber)=>createAttestationsForSlot(slotNumber)))).flat();
-        const proposalId = attestations[0].archive.toString();
-        await ap.addAttestations(attestations);
-        const attestationsForSlot1 = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
-        expect(attestationsForSlot1.length).toBe(signers.length);
-        const deleteAttestationsSpy = jest.spyOn(ap, 'deleteAttestationsForSlot');
-        await ap.deleteAttestationsOlderThan(SlotNumber(73));
-        const attestationsForSlot1AfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
-        expect(attestationsForSlot1AfterDelete.length).toBe(0);
-        expect(deleteAttestationsSpy).toHaveBeenCalledTimes(5);
-        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));
+            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([
+                attestations[0]
+            ]);
+            expect(await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString())).toHaveLength(1);
+        });
+        it('should store attestations by differing slot', async ()=>{
+            const slotNumbers = [
+                1,
+                2,
+                3,
+                4
+            ];
+            const attestations = signers.map((signer, i)=>mockCheckpointAttestation(signer, slotNumbers[i]));
+            await ap.addCheckpointAttestations(attestations);
+            for (const attestation of attestations){
+                const slot = attestation.payload.header.slotNumber;
+                const archive = attestation.archive.toString();
+                const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, archive);
+                expect(retreivedAttestations.length).toBe(1);
+                expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
+                expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
+            }
+        });
+        it('should store attestations by differing slot and archive', async ()=>{
+            const slotNumbers = [
+                1,
+                1,
+                2,
+                3
+            ];
+            const archives = [
+                Fr.random(),
+                Fr.random(),
+                Fr.random(),
+                Fr.random()
+            ];
+            const attestations = signers.map((signer, i)=>mockCheckpointAttestation(signer, slotNumbers[i], archives[i]));
+            await ap.addCheckpointAttestations(attestations);
+            for (const attestation of attestations){
+                const slot = attestation.payload.header.slotNumber;
+                const proposalId = attestation.archive.toString();
+                const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, proposalId);
+                expect(retreivedAttestations.length).toBe(1);
+                expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
+                expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
+            }
+        });
+        it('should delete attestations older than a given slot', async ()=>{
+            const slotNumbers = [
+                1,
+                2,
+                3,
+                69,
+                72,
+                74,
+                88,
+                420
+            ];
+            const attestations = (await Promise.all(slotNumbers.map((slotNumber)=>createCheckpointAttestationsForSlot(slotNumber)))).flat();
+            const proposalId = attestations[0].archive.toString();
+            await ap.addCheckpointAttestations(attestations);
+            const attestationsForSlot1 = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
+            expect(attestationsForSlot1.length).toBe(signers.length);
+            await ap.deleteCheckpointAttestationsOlderThan(SlotNumber(73));
+            const attestationsForSlot1AfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
+            expect(attestationsForSlot1AfterDelete.length).toBe(0);
+        });
     });
     describe('BlockProposal in attestation pool', ()=>{
         it('should add and retrieve block proposal', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
-            const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+            const proposal = await mockBlockProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal.archive.toString();
             await ap.addBlockProposal(proposal);
             const retrievedProposal = await ap.getBlockProposal(proposalId);
@@ -257,11 +192,11 @@ export function describeAttestationPool(getAttestationPool) {
         it('should update block proposal if added twice with same id', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
-            const proposal1 = mockBlockProposal(signers[0], slotNumber, archive);
+            const proposal1 = await mockBlockProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal1.archive.toString();
             await ap.addBlockProposal(proposal1);
             // Create a new proposal with same archive but different signer
-            const proposal2 = mockBlockProposal(signers[1], slotNumber, archive);
+            const proposal2 = await mockBlockProposalForPool(signers[1], slotNumber, archive);
             await ap.addBlockProposal(proposal2);
             const retrievedProposal = await ap.getBlockProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
@@ -271,8 +206,8 @@ export function describeAttestationPool(getAttestationPool) {
         });
         it('should handle block proposals with different slots and same archive', async ()=>{
             const archive = Fr.random();
-            const proposal1 = mockBlockProposal(signers[0], 100, archive);
-            const proposal2 = mockBlockProposal(signers[1], 200, archive);
+            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);
@@ -282,65 +217,104 @@ export function describeAttestationPool(getAttestationPool) {
             expect(retrievedProposal.toBuffer()).toEqual(proposal2.toBuffer());
             expect(retrievedProposal.slotNumber).toBe(SlotNumber(200));
         });
-        it('should delete block proposal when deleting attestations for slot and proposal', async ()=>{
+    });
+    describe('CheckpointProposal in attestation pool', ()=>{
+        const mockCheckpointProposalForPool = (signer, slotNumber, archive = Fr.random())=>{
+            const checkpointHeader = makeCheckpointHeader(1, {
+                slotNumber: SlotNumber(slotNumber)
+            });
+            const blockHeader = makeBlockHeader(1);
+            return makeCheckpointProposal({
+                signer,
+                checkpointHeader,
+                archiveRoot: archive,
+                lastBlock: {
+                    blockHeader
+                }
+            });
+        };
+        it('should add and retrieve checkpoint proposal as core (without lastBlock)', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
-            const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+            const proposal = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal.archive.toString();
-            // Add proposal and some attestations
-            await ap.addBlockProposal(proposal);
-            const attestations = signers.map((signer)=>mockAttestation(signer, slotNumber, archive));
-            await ap.addAttestations(attestations);
-            // Verify proposal exists
-            let retrievedProposal = await ap.getBlockProposal(proposalId);
+            await ap.addCheckpointProposal(proposal);
+            const retrievedProposal = await ap.getCheckpointProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
-            expect(await ap.hasBlockProposal(proposalId)).toBe(true);
-            // Delete attestations for slot and proposal
-            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);
+            // 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);
         });
-        it('should delete block proposal when deleting attestations for slot', async ()=>{
+        it('should extract and store block proposal when adding checkpoint proposal with lastBlock', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
-            const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+            const proposal = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
             const proposalId = proposal.archive.toString();
-            // Add proposal
-            await ap.addBlockProposal(proposal);
-            // 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(SlotNumber(slotNumber));
-            // Proposal should be deleted
-            retrievedProposal = await ap.getBlockProposal(proposalId);
-            expect(retrievedProposal).toBeUndefined();
-            expect(await ap.hasBlockProposal(proposal)).toBe(false);
+            // 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 be able to fetch both block proposal and attestations', async ()=>{
+        it('should not store block proposal when checkpoint proposal has no lastBlock', async ()=>{
             const slotNumber = 420;
             const archive = Fr.random();
-            const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+            const checkpointHeader = makeCheckpointHeader(1, {
+                slotNumber: SlotNumber(slotNumber)
+            });
+            // Create a checkpoint proposal WITHOUT lastBlock
+            const proposal = await makeCheckpointProposal({
+                signer: signers[0],
+                checkpointHeader,
+                archiveRoot: archive
+            });
             const proposalId = proposal.archive.toString();
-            // Add proposal first
-            await ap.addBlockProposal(proposal);
-            // Add attestations for the same proposal
-            const attestations = signers.slice(1).map((signer)=>mockAttestation(signer, slotNumber, archive));
-            await ap.addAttestations(attestations);
-            // Retrieve both proposal and attestations
-            const retrievedProposal = await ap.getBlockProposal(proposalId);
-            const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
+            await ap.addCheckpointProposal(proposal);
+            // 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)
+            const retrievedBlockProposal = await ap.getBlockProposal(proposalId);
+            expect(retrievedBlockProposal).toBeUndefined();
+        });
+        it('should return undefined for non-existent checkpoint proposal', async ()=>{
+            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 ()=>{
+            const slotNumber = 420;
+            const archive = Fr.random();
+            const proposal1 = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
+            const proposalId = proposal1.archive.toString();
+            await ap.addCheckpointProposal(proposal1);
+            // Create a new proposal with same archive but different signer
+            const proposal2 = await mockCheckpointProposalForPool(signers[1], slotNumber, archive);
+            await ap.addCheckpointProposal(proposal2);
+            const retrievedProposal = await ap.getCheckpointProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
-            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);
+            // Should have the second proposal (as core)
+            expect(retrievedProposal.toBuffer()).toEqual(proposal2.toCore().toBuffer());
+            expect(retrievedProposal.getSender()?.toString()).toBe(signers[1].address.toString());
+        });
+        it('should throw ProposalSlotCapExceededError when exceeding capacity', async ()=>{
+            const slotNumber = 420;
+            // Add MAX_PROPOSALS_PER_SLOT proposals
+            for(let i = 0; i < MAX_PROPOSALS_PER_SLOT; i++){
+                const proposal = await mockCheckpointProposalForPool(signers[i % NUMBER_OF_SIGNERS_PER_TEST], slotNumber);
+                await ap.addCheckpointProposal(proposal);
             }
+            // The next proposal should throw
+            const extraProposal = await mockCheckpointProposalForPool(signers[0], slotNumber);
+            await expect(ap.addCheckpointProposal(extraProposal)).rejects.toThrow('Maximum checkpoint proposals per slot');
         });
     });
 }