@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.21caa21

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -1,4 +1,5 @@
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 
 /**
  * An Attestation Pool contains attestations collected by a validator
@@ -8,7 +9,30 @@ import type { BlockAttestation } from '@aztec/stdlib/p2p';
  */
 export interface AttestationPool {
   /**
-   * AddAttestation
+   * Adds new block proposal to the pool
+   */
+  addBlockProposal(blockProposal: BlockProposal): Promise<void>;
+
+  /**
+   * Get block proposal by it's ID
+   *
+   * @param id - The ID of the block proposal to retrieve. The ID is proposal.payload.archive
+   *
+   * @return The block proposal if it exists, otherwise undefined.
+   */
+  getBlockProposal(id: string): Promise<BlockProposal | undefined>;
+
+  /**
+   * Check if a block proposal exists in the pool
+   *
+   * @param idOrProposal - The ID of the block proposal or the block proposal itself to check. The ID is proposal.payload.archive
+   *
+   * @return True if the block proposal exists, false otherwise.
+   */
+  hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean>;
+
+  /**
+   * AddAttestations
    *
    * @param attestations - Attestations to add into the pool
    */
@@ -28,7 +52,7 @@ export interface AttestationPool {
    *
    * @param slot - The oldest slot to keep.
    */
-  deleteAttestationsOlderThan(slot: bigint): Promise<void>;
+  deleteAttestationsOlderThan(slot: SlotNumber): Promise<void>;
 
   /**
    * Delete Attestations for slot
@@ -37,7 +61,7 @@ export interface AttestationPool {
    *
    * @param slot - The slot to delete.
    */
-  deleteAttestationsForSlot(slot: bigint): Promise<void>;
+  deleteAttestationsForSlot(slot: SlotNumber): Promise<void>;
 
   /**
    * Delete Attestations for slot and proposal
@@ -47,10 +71,20 @@ export interface AttestationPool {
    * @param slot - The slot to delete.
    * @param proposalId - The proposal to delete.
    */
-  deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void>;
+  deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void>;
+
+  /**
+   * Get all Attestations for all proposals for a given slot
+   *
+   * Retrieve all of the attestations observed pertaining to a given slot
+   *
+   * @param slot - The slot to query
+   * @return BlockAttestations
+   */
+  getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]>;
 
   /**
-   * Get Attestations for slot
+   * Get Attestations for slot and given proposal
    *
    * Retrieve all of the attestations observed pertaining to a given slot
    *
@@ -58,5 +92,39 @@ export interface AttestationPool {
    * @param proposalId - The proposal to query
    * @return BlockAttestations
    */
-  getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
+  getAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<BlockAttestation[]>;
+
+  /**
+   * Check if a specific attestation exists in the pool
+   *
+   * @param attestation - The attestation to check
+   * @return True if the attestation exists, false otherwise
+   */
+  hasAttestation(attestation: BlockAttestation): Promise<boolean>;
+
+  /**
+   * Returns whether adding this proposal is permitted at current capacity:
+   * - True if the proposal already exists, allow overwrite to keep parity with tests.
+   * - True if the slot is below the proposal cap.
+   * - False if the slot is at/above cap and this would be a new unique proposal.
+   *
+   * @param block - The block proposal to check
+   * @returns True if the proposal can be added (or already exists), false otherwise.
+   */
+  canAddProposal(block: BlockProposal): Promise<boolean>;
+
+  /**
+   * Returns whether an attestation would be accepted for (slot, proposalId):
+   * - True if the attestation already exists for this sender.
+   * - True if the attestation cap for (slot, proposalId) has not been reached.
+   * - False if the cap is reached and this attestation would be a new unique entry.
+   *
+   * @param attestation - The attestation to check
+   * @param committeeSize - Committee size for the attestation's slot, implementation may add a small buffer
+   * @returns True if the attestation can be added, false otherwise.
+   */
+  canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean>;
+
+  /** Returns whether the pool is empty. */
+  isEmpty(): Promise<boolean>;
 }

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -1,6 +1,14 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Secp256k1Signer } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
+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';
@@ -30,7 +38,19 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
   const createAttestationsForSlot = (slotNumber: number) => {
     const archive = Fr.random();
-    return Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    return signers.map(signer => mockAttestation(signer, slotNumber, archive));
+  };
+
+  const mockBlockProposal = (signer: Secp256k1Signer, slotNumber: number, archive: Fr = Fr.random()): 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);
   };
 
   // We compare buffers as the objects can have cached values attached to them which are not serialised
@@ -45,163 +65,201 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   it('should add attestations to pool', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    const attestations = signers.slice(0, -1).map(signer => mockAttestation(signer, slotNumber, archive));
 
     await ap.addAttestations(attestations);
 
-    // Check metrics have been updated.
-    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations.length);
+    const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      archive.toString(),
+    );
+    expect(retrievedAttestations.length).toBe(attestations.length);
+    compareAttestations(retrievedAttestations, attestations);
 
-    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), archive.toString());
+    // Check hasAttestation for added attestations
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
 
-    expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
+    const retrievedAttestationsForSlot = await ap.getAttestationsForSlot(SlotNumber(slotNumber));
+    expect(retrievedAttestationsForSlot.length).toBe(attestations.length);
+    compareAttestations(retrievedAttestationsForSlot, attestations);
 
-    compareAttestations(retreivedAttestations, 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(BigInt(slotNumber));
-
-    expect(metricsMock.recordRemovedObjects).toHaveBeenCalledWith(attestations.length);
+    await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
 
-    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlot(BigInt(slotNumber), archive.toString());
+    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 () => {
+  it('should handle duplicate proposals in a slot', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const txs = [0, 1, 2, 3, 4, 5].map(() => TxHash.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(await mockAttestation(signer, slotNumber, archive, txs));
+      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.getAttestationsForSlot(BigInt(slotNumber), archive.toString());
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      archive.toString(),
+    );
     expect(retreivedAttestations.length).toBe(1);
     expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
-    expect(retreivedAttestations[0].payload.txHashes).toEqual(txs);
-    expect((await retreivedAttestations[0].getSender()).toString()).toEqual(signer.address.toString());
+    expect(retreivedAttestations[0].getSender()?.toString()).toEqual(signer.address.toString());
+
+    // Try adding them on another operation and check they are still not duplicated
+    await ap.addAttestations([attestations[0]]);
+    expect(await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString())).toHaveLength(1);
   });
 
-  it('Should store attestations by differing slot', async () => {
+  it('should store attestations by differing slot', async () => {
     const slotNumbers = [1, 2, 3, 4];
-    const attestations = await Promise.all(signers.map((signer, i) => mockAttestation(signer, slotNumbers[i])));
+    const attestations = signers.map((signer, i) => mockAttestation(signer, slotNumbers[i]));
 
     await ap.addAttestations(attestations);
 
     for (const attestation of attestations) {
-      const slot = attestation.payload.header.globalVariables.slotNumber;
+      const slot = attestation.payload.header.slotNumber;
       const archive = attestation.archive.toString();
 
-      const retreivedAttestations = await ap.getAttestationsForSlot(slot.toBigInt(), archive);
+      const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot, archive);
       expect(retreivedAttestations.length).toBe(1);
       expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
-      expect(retreivedAttestations[0].payload.header.globalVariables.slotNumber).toEqual(slot);
+      expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
     }
   });
 
-  it('Should store attestations by differing slot and archive', async () => {
+  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 = await Promise.all(
-      signers.map((signer, i) => mockAttestation(signer, slotNumbers[i], archives[i])),
-    );
+    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.globalVariables.slotNumber;
+      const slot = attestation.payload.header.slotNumber;
       const proposalId = attestation.archive.toString();
 
-      const retreivedAttestations = await ap.getAttestationsForSlot(slot.toBigInt(), proposalId);
+      const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot, proposalId);
       expect(retreivedAttestations.length).toBe(1);
       expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
-      expect(retreivedAttestations[0].payload.header.globalVariables.slotNumber).toEqual(slot);
+      expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
     }
   });
 
-  it('Should delete attestations', async () => {
+  it('should delete attestations', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    const attestations = signers.map(signer => mockAttestation(signer, slotNumber, archive));
     const proposalId = attestations[0].archive.toString();
 
     await ap.addAttestations(attestations);
 
-    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations.length);
-
-    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
-    await ap.deleteAttestations(attestations);
+    // Check hasAttestation before deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
 
-    expect(metricsMock.recordRemovedObjects).toHaveBeenCalledWith(attestations.length);
+    await ap.deleteAttestations(attestations);
 
-    const gottenAfterDelete = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    const gottenAfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(gottenAfterDelete.length).toBe(0);
+
+    // Check hasAttestation after deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(false);
+    }
   });
 
-  it('Should blanket delete attestations per slot', async () => {
+  it('should blanket delete attestations per slot', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    const attestations = signers.map(signer => mockAttestation(signer, slotNumber, archive));
     const proposalId = attestations[0].archive.toString();
 
     await ap.addAttestations(attestations);
 
-    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
-    await ap.deleteAttestationsForSlot(BigInt(slotNumber));
+    await ap.deleteAttestationsForSlot(SlotNumber(slotNumber));
 
-    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      proposalId,
+    );
     expect(retreivedAttestationsAfterDelete.length).toBe(0);
   });
 
-  it('Should blanket delete attestations per slot and proposal', async () => {
+  it('should blanket delete attestations per slot and proposal', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    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 = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive2)));
+    const attestations2 = signers.map(signer => mockAttestation(signer, slotNumber, archive2));
     const proposalId2 = attestations2[0].archive.toString();
 
     await ap.addAttestations(attestations);
     await ap.addAttestations(attestations2);
 
-    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations.length);
-    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations2.length);
-
-    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
-    await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+    await ap.deleteAttestationsForSlotAndProposal(SlotNumber(slotNumber), proposalId);
 
-    expect(metricsMock.recordRemovedObjects).toHaveBeenCalledWith(attestations.length);
-
-    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlotAndProposal(
+      SlotNumber(slotNumber),
+      proposalId,
+    );
     expect(retreivedAttestationsAfterDelete.length).toBe(0);
 
-    const retreivedAttestationsAfterDeleteForOtherProposal = await ap.getAttestationsForSlot(
-      BigInt(slotNumber),
+    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 () => {
+  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)))
@@ -210,21 +268,162 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     await ap.addAttestations(attestations);
 
-    const attestationsForSlot1 = await ap.getAttestationsForSlot(BigInt(1), proposalId);
+    const attestationsForSlot1 = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
     expect(attestationsForSlot1.length).toBe(signers.length);
 
     const deleteAttestationsSpy = jest.spyOn(ap, 'deleteAttestationsForSlot');
 
-    await ap.deleteAttestationsOlderThan(BigInt(73));
+    await ap.deleteAttestationsOlderThan(SlotNumber(73));
 
-    const attestationsForSlot1AfterDelete = await ap.getAttestationsForSlot(BigInt(1), proposalId);
+    const attestationsForSlot1AfterDelete = await ap.getAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
     expect(attestationsForSlot1AfterDelete.length).toBe(0);
 
     expect(deleteAttestationsSpy).toHaveBeenCalledTimes(5);
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(1));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(2));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(3));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(69));
-    expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(72));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(1));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(2));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(3));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(69));
+    expect(deleteAttestationsSpy).toHaveBeenCalledWith(SlotNumber(72));
+  });
+
+  describe('BlockProposal in attestation pool', () => {
+    it('should add and retrieve block proposal', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+      const proposalId = proposal.archive.toString();
+
+      await ap.addBlockProposal(proposal);
+
+      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 () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal1 = mockBlockProposal(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);
+
+      await ap.addBlockProposal(proposal2);
+
+      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 = mockBlockProposal(signers[0], 100, archive);
+      const proposal2 = mockBlockProposal(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));
+    });
+
+    it('should delete block proposal when deleting attestations for slot and proposal', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(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);
+      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);
+    });
+
+    it('should delete block proposal when deleting attestations for slot', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(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);
+    });
+
+    it('should be able to fetch both block proposal and attestations', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(signers[0], slotNumber, 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);
+
+      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);
+      }
+    });
   });
 }