@aztec/p2p 4.0.0-nightly.20260112 → 4.0.0-nightly.20260114

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -1,22 +1,12 @@
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
-import {
-  BlockProposal as BlockProposalClass,
-  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 { type MockProxy, mock } from 'jest-mock-extended';
-
-import type { PoolInstrumentation } from '../instrumentation.js';
+import type { BlockProposal, CheckpointAttestation, CheckpointProposal } from '@aztec/stdlib/p2p';
+import { makeBlockProposal, makeCheckpointProposal, makeL2BlockHeader } from '@aztec/stdlib/testing';
+
 import type { AttestationPool } from './attestation_pool.js';
-import { mockAttestation } from './mocks.js';
+import { MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
+import { mockCheckpointAttestation } from './mocks.js';
 
 const NUMBER_OF_SIGNERS_PER_TEST = 4;
 
@@ -24,273 +14,182 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   let ap: AttestationPool;
   let signers: Secp256k1Signer[];
 
-  // Check that metrics are recorded correctly
-  let metricsMock: MockProxy<PoolInstrumentation<BlockAttestation>>;
-
   beforeEach(() => {
     ap = getAttestationPool();
     signers = Array.from({ length: NUMBER_OF_SIGNERS_PER_TEST }, () => Secp256k1Signer.random());
-
-    metricsMock = mock<PoolInstrumentation<BlockAttestation>>();
-    // Can i overwrite this like this??
-    (ap as any).metrics = metricsMock;
   });
 
-  const createAttestationsForSlot = (slotNumber: number) => {
-    const archive = Fr.random();
-    return signers.map(signer => mockAttestation(signer, slotNumber, archive));
+  const createCheckpointAttestationsForSlot = (slotNumber: number, archive?: Fr) => {
+    const archiveToUse = archive ?? Fr.random();
+    return signers.map(signer => mockCheckpointAttestation(signer, slotNumber, archiveToUse));
   };
 
-  const mockBlockProposal = (signer: Secp256k1Signer, slotNumber: number, archive: Fr = Fr.random()): BlockProposal => {
+  const mockBlockProposalForPool = (
+    signer: Secp256k1Signer,
+    slotNumber: number,
+    archive: Fr = Fr.random(),
+  ): Promise<BlockProposal> => {
     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);
+    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: BlockAttestation[], a2: BlockAttestation[]) => {
+  // Compare checkpoint attestations buffers
+  // Using array containing as the kv store does not respect insertion order
+  const compareCheckpointAttestations = (a1: CheckpointAttestation[], a2: CheckpointAttestation[]) => {
     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: BlockAttestation[] = [];
-    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);
-  });
+  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));
 
-  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.addCheckpointAttestations(attestations);
 
-    await ap.addAttestations(attestations);
+      const retrievedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(
+        SlotNumber(slotNumber),
+        archive.toString(),
+      );
+      expect(retrievedAttestations.length).toBe(attestations.length);
+      compareCheckpointAttestations(retrievedAttestations, attestations);
 
-    for (const attestation of attestations) {
-      const slot = attestation.payload.header.slotNumber;
-      const archive = attestation.archive.toString();
+      // Check hasCheckpointAttestation for added attestations
+      for (const attestation of attestations) {
+        expect(await ap.hasCheckpointAttestation(attestation)).toBe(true);
+      }
 
-      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);
-    }
-  });
+      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 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]));
+    it('should handle duplicate proposals in a slot', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
 
-    await ap.addAttestations(attestations);
+      // Use the same signer for all attestations
+      const attestations: CheckpointAttestation[] = [];
+      const signer = signers[0];
+      for (let i = 0; i < NUMBER_OF_SIGNERS_PER_TEST; i++) {
+        attestations.push(mockCheckpointAttestation(signer, slotNumber, archive));
+      }
 
-    for (const attestation of attestations) {
-      const slot = attestation.payload.header.slotNumber;
-      const proposalId = attestation.archive.toString();
+      // Add them to store and check we end up with only one
+      await ap.addCheckpointAttestations(attestations);
 
-      const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot, proposalId);
+      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);
+      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);
+    });
 
-    const gottenAfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
-    expect(gottenAfterDelete.length).toBe(0);
+    it('should store attestations by differing slot', async () => {
+      const slotNumbers = [1, 2, 3, 4];
+      const attestations = signers.map((signer, i) => mockCheckpointAttestation(signer, slotNumbers[i]));
 
-    // Check hasAttestation after deletion
-    for (const attestation of attestations) {
-      expect(await ap.hasAttestation(attestation)).toBe(false);
-    }
-  });
+      await ap.addCheckpointAttestations(attestations);
 
-  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);
+      for (const attestation of attestations) {
+        const slot = attestation.payload.header.slotNumber;
+        const archive = attestation.archive.toString();
 
-    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
-    expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
-    compareAttestations(retreivedAttestations, attestations);
+        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);
+      }
+    });
 
-    await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
+    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]));
 
-    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(
-      SlotNumber(slotNumber),
-      proposalId,
-    );
-    expect(retreivedAttestationsAfterDelete.length).toBe(0);
-  });
+      await ap.addCheckpointAttestations(attestations);
 
-  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();
+      for (const attestation of attestations) {
+        const slot = attestation.payload.header.slotNumber;
+        const proposalId = attestation.archive.toString();
 
-    await ap.addAttestations(attestations);
+        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);
+      }
+    });
 
-    const attestationsForSlot1 = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
-    expect(attestationsForSlot1.length).toBe(signers.length);
+    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();
 
-    const deleteAttestationsSpy = jest.spyOn(ap, 'deleteAttestationsForSlot');
+      await ap.addCheckpointAttestations(attestations);
 
-    await ap.deleteAttestationsOlderThan(SlotNumber(73));
+      const attestationsForSlot1 = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
+      expect(attestationsForSlot1.length).toBe(signers.length);
 
-    const attestationsForSlot1AfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
-    expect(attestationsForSlot1AfterDelete.length).toBe(0);
+      await ap.deleteCheckpointAttestationsOlderThan(SlotNumber(73));
 
-    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));
+      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);
@@ -317,13 +216,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     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);
 
@@ -336,8 +235,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     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);
@@ -349,81 +248,126 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       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: Secp256k1Signer,
+      slotNumber: number,
+      archive: Fr = Fr.random(),
+    ): Promise<CheckpointProposal> => {
+      const header = makeL2BlockHeader(1, 2, slotNumber);
+      return makeCheckpointProposal({
+        signer,
+        checkpointHeader: header.toCheckpointHeader(),
+        archiveRoot: archive,
+        lastBlock: { blockHeader: header },
+      });
+    };
+
+    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);
+      await ap.addCheckpointProposal(proposal);
+
+      const retrievedProposal = await ap.getCheckpointProposal(proposalId);
 
-      // Verify proposal exists
-      let retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
-      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
+      // Should return core version (without lastBlock)
+      expect(retrievedProposal!.toBuffer()).toEqual(proposal.toCore().toBuffer());
 
-      // Delete attestations for slot and proposal
-      await ap.deleteAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
+      // Check hasCheckpointProposal with both id and object
+      expect(await ap.hasCheckpointProposal(proposalId)).toBe(true);
+      expect(await ap.hasCheckpointProposal(proposal)).toBe(true);
+    });
 
-      // Proposal should be deleted
-      retrievedProposal = await ap.getBlockProposal(proposalId);
-      expect(retrievedProposal).toBeUndefined();
-      expect(await ap.hasBlockProposal(proposalId)).toBe(false);
+    it('should extract and store block proposal when adding checkpoint proposal with lastBlock', 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 delete block proposal when deleting attestations for slot', 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 header = makeL2BlockHeader(1, 2, slotNumber);
+      // Create a checkpoint proposal WITHOUT lastBlock
+      const proposal = await makeCheckpointProposal({
+        signer: signers[0],
+        checkpointHeader: header.toCheckpointHeader(),
+        archiveRoot: archive,
+        // No lastBlock
+      });
       const proposalId = proposal.archive.toString();
 
-      // Add proposal
-      await ap.addBlockProposal(proposal);
+      await ap.addCheckpointProposal(proposal);
 
-      // Verify proposal exists
-      let retrievedProposal = await ap.getBlockProposal(proposalId);
-      expect(retrievedProposal).toBeDefined();
-      expect(await ap.hasBlockProposal(proposal)).toBe(true);
+      // The checkpoint proposal should be stored
+      const retrievedCheckpointProposal = await ap.getCheckpointProposal(proposalId);
+      expect(retrievedCheckpointProposal).toBeDefined();
 
-      // Delete attestations for slot
-      await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
+      // But no block proposal should be stored (archive key won't have a block proposal)
+      const retrievedBlockProposal = await ap.getBlockProposal(proposalId);
+      expect(retrievedBlockProposal).toBeUndefined();
+    });
 
-      // Proposal should be deleted
-      retrievedProposal = await ap.getBlockProposal(proposalId);
+    it('should return undefined for non-existent checkpoint proposal', async () => {
+      const nonExistentId = Fr.random().toString();
+      const retrievedProposal = await ap.getCheckpointProposal(nonExistentId);
       expect(retrievedProposal).toBeUndefined();
-      expect(await ap.hasBlockProposal(proposal)).toBe(false);
+
+      // Check hasCheckpointProposal returns false for non-existent proposal
+      expect(await ap.hasCheckpointProposal(nonExistentId)).toBe(false);
     });
 
-    it('should be able to fetch both block proposal and attestations', async () => {
+    it('should update checkpoint proposal if added twice with same id', async () => {
       const slotNumber = 420;
       const archive = Fr.random();
-      const proposal = mockBlockProposal(signers[0], slotNumber, archive);
-      const proposalId = proposal.archive.toString();
+      const proposal1 = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
+      const proposalId = proposal1.archive.toString();
 
-      // Add proposal first
-      await ap.addBlockProposal(proposal);
+      await ap.addCheckpointProposal(proposal1);
 
-      // Add attestations for the same proposal
-      const attestations = signers.slice(1).map(signer => mockAttestation(signer, slotNumber, archive));
-      await ap.addAttestations(attestations);
+      // Create a new proposal with same archive but different signer
+      const proposal2 = await mockCheckpointProposalForPool(signers[1], slotNumber, archive);
 
-      // Retrieve both proposal and attestations
-      const retrievedProposal = await ap.getBlockProposal(proposalId);
-      const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
+      await ap.addCheckpointProposal(proposal2);
 
+      const retrievedProposal = await ap.getCheckpointProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
-      expect(retrievedProposal).toEqual(proposal);
-      expect(await ap.hasBlockProposal(proposalId)).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());
+    });
 
-      compareAttestations(retrievedAttestations, attestations);
-      // Check hasAttestation for all attestations
-      for (const attestation of attestations) {
-        expect(await ap.hasAttestation(attestation)).toBe(true);
+    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');
     });
   });
 }