@aztec/p2p 0.66.0 → 0.67.1-devnet

package/src/client/index.ts

@@ -1,51 +1,66 @@
-import type { ClientProtocolCircuitVerifier, L2BlockSource, WorldStateSynchronizer } from '@aztec/circuit-types';
-import { createDebugLogger } from '@aztec/foundation/log';
+import {
+  type ClientProtocolCircuitVerifier,
+  type L2BlockSource,
+  P2PClientType,
+  type WorldStateSynchronizer,
+} from '@aztec/circuit-types';
+import { createLogger } from '@aztec/foundation/log';
 import { type AztecKVStore } from '@aztec/kv-store';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
-import { createStore } from '@aztec/kv-store/utils';
+import { createStore } from '@aztec/kv-store/lmdb';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
 import { P2PClient } from '../client/p2p_client.js';
 import { type P2PConfig } from '../config.js';
 import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { InMemoryAttestationPool } from '../mem_pools/attestation_pool/memory_attestation_pool.js';
+import { KvAttestationPool } from '../mem_pools/attestation_pool/kv_attestation_pool.js';
 import { type EpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { MemoryEpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/memory_epoch_proof_quote_pool.js';
 import { type MemPools } from '../mem_pools/interface.js';
 import { AztecKVTxPool, type TxPool } from '../mem_pools/tx_pool/index.js';
-import { DiscV5Service } from '../service/discV5_service.js';
-import { DummyP2PService } from '../service/dummy_service.js';
-import { LibP2PService } from '../service/index.js';
+import { DiscV5Service } from '../services/discv5/discV5_service.js';
+import { DummyP2PService } from '../services/dummy_service.js';
+import { LibP2PService } from '../services/index.js';
 import { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
 
 export * from './p2p_client.js';
 
-export const createP2PClient = async (
+type P2PClientDeps<T extends P2PClientType> = {
+  txPool?: TxPool;
+  store?: AztecKVStore;
+  attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
+  epochProofQuotePool?: EpochProofQuotePool;
+};
+
+export const createP2PClient = async <T extends P2PClientType>(
+  clientType: T,
   _config: P2PConfig & DataStoreConfig,
   l2BlockSource: L2BlockSource,
   proofVerifier: ClientProtocolCircuitVerifier,
   worldStateSynchronizer: WorldStateSynchronizer,
   telemetry: TelemetryClient = new NoopTelemetryClient(),
-  deps: {
-    txPool?: TxPool;
-    store?: AztecKVStore;
-    attestationPool?: AttestationPool;
-    epochProofQuotePool?: EpochProofQuotePool;
-  } = {},
+  deps: P2PClientDeps<T> = {},
 ) => {
   let config = { ..._config };
-  const store = deps.store ?? (await createStore('p2p', config, createDebugLogger('aztec:p2p:lmdb')));
+  const logger = createLogger('p2p');
+  const store = deps.store ?? (await createStore('p2p', config, createLogger('p2p:lmdb')));
 
-  const mempools: MemPools = {
+  const mempools: MemPools<T> = {
     txPool: deps.txPool ?? new AztecKVTxPool(store, telemetry),
-    attestationPool: deps.attestationPool ?? new InMemoryAttestationPool(telemetry),
     epochProofQuotePool: deps.epochProofQuotePool ?? new MemoryEpochProofQuotePool(telemetry),
+    attestationPool:
+      clientType === P2PClientType.Full
+        ? ((deps.attestationPool ?? new KvAttestationPool(store, telemetry)) as T extends P2PClientType.Full
+            ? AttestationPool
+            : undefined)
+        : undefined,
   };
 
   let p2pService;
 
   if (_config.p2pEnabled) {
+    logger.verbose('P2P is enabled. Using LibP2P service.');
     config = await configureP2PClientAddresses(_config);
 
     // Create peer discovery service
@@ -53,7 +68,8 @@ export const createP2PClient = async (
     const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey);
     const discoveryService = new DiscV5Service(peerId, config, telemetry);
 
-    p2pService = await LibP2PService.new(
+    p2pService = await LibP2PService.new<T>(
+      clientType,
       config,
       discoveryService,
       peerId,
@@ -65,7 +81,16 @@ export const createP2PClient = async (
       telemetry,
     );
   } else {
+    logger.verbose('P2P is disabled. Using dummy P2P service');
     p2pService = new DummyP2PService();
   }
-  return new P2PClient(store, l2BlockSource, mempools, p2pService, config.keepProvenTxsInPoolFor, telemetry);
+  return new P2PClient(
+    clientType,
+    store,
+    l2BlockSource,
+    mempools,
+    p2pService,
+    config.keepProvenTxsInPoolFor,
+    telemetry,
+  );
 };

package/src/client/p2p_client.ts

@@ -5,16 +5,24 @@ import {
   type L2Block,
   type L2BlockId,
   type L2BlockSource,
-  L2BlockStream,
   type L2BlockStreamEvent,
   type L2Tips,
+  type P2PApi,
+  type P2PClientType,
+  type PeerInfo,
   type Tx,
   type TxHash,
 } from '@aztec/circuit-types';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { type AztecKVStore, type AztecMap, type AztecSingleton } from '@aztec/kv-store';
-import { Attributes, type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
+import {
+  Attributes,
+  type TelemetryClient,
+  TraceableL2BlockStream,
+  WithTracer,
+  trackSpan,
+} from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
 import { type ENR } from '@chainsafe/enr';
@@ -24,8 +32,8 @@ import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_
 import { type EpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { type MemPools } from '../mem_pools/interface.js';
 import { type TxPool } from '../mem_pools/tx_pool/index.js';
-import { TX_REQ_PROTOCOL } from '../service/reqresp/interface.js';
-import type { P2PService } from '../service/service.js';
+import { TX_REQ_PROTOCOL } from '../services/reqresp/interface.js';
+import type { P2PService } from '../services/service.js';
 
 /**
  * Enum defining the possible states of the p2p client.
@@ -54,7 +62,7 @@ export interface P2PSyncState {
 /**
  * Interface of a P2P client.
  **/
-export interface P2P {
+export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApi<T> & {
   /**
    * Broadcasts a block proposal to other peers.
    *
@@ -62,15 +70,6 @@ export interface P2P {
    */
   broadcastProposal(proposal: BlockProposal): void;
 
-  /**
-   * Queries the Attestation pool for attestations for the given slot
-   *
-   * @param slot - the slot to query
-   * @param proposalId - the proposal id to query
-   * @returns BlockAttestations
-   */
-  getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
-
   /**
    * Queries the EpochProofQuote pool for quotes for the given epoch
    *
@@ -122,12 +121,6 @@ export interface P2P {
    **/
   deleteTxs(txHashes: TxHash[]): Promise<void>;
 
-  /**
-   * Returns all transactions in the transaction pool.
-   * @returns An array of Txs.
-   */
-  getTxs(filter: 'all' | 'pending' | 'mined'): Tx[];
-
   /**
    * Returns a transaction in the transaction pool by its hash.
    * @param txHash  - Hash of tx to return.
@@ -173,15 +166,21 @@ export interface P2P {
   getStatus(): Promise<P2PSyncState>;
 
   /**
-   * Returns the ENR for this node, if any.
+   * Returns the ENR of this node, if any.
    */
   getEnr(): ENR | undefined;
-}
+
+  /** Identifies a p2p client. */
+  isP2PClient(): true;
+};
 
 /**
  * The P2P client implementation.
  */
-export class P2PClient extends WithTracer implements P2P {
+export class P2PClient<T extends P2PClientType = P2PClientType.Full>
+  extends WithTracer
+  implements P2P, P2P<P2PClientType.Prover>
+{
   /** Property that indicates whether the client is running. */
   private stopping = false;
 
@@ -199,7 +198,7 @@ export class P2PClient extends WithTracer implements P2P {
   private synchedProvenBlockNumber: AztecSingleton<number>;
 
   private txPool: TxPool;
-  private attestationPool: AttestationPool;
+  private attestationPool: T extends P2PClientType.Full ? AttestationPool : undefined;
   private epochProofQuotePool: EpochProofQuotePool;
 
   /** How many slots to keep attestations for. */
@@ -217,13 +216,14 @@ export class P2PClient extends WithTracer implements P2P {
    * @param log - A logger.
    */
   constructor(
+    clientType: T,
     store: AztecKVStore,
     private l2BlockSource: L2BlockSource,
-    mempools: MemPools,
+    mempools: MemPools<T>,
     private p2pService: P2PService,
     private keepProvenTxsFor: number,
     telemetry: TelemetryClient = new NoopTelemetryClient(),
-    private log = createDebugLogger('aztec:p2p'),
+    private log = createLogger('p2p'),
   ) {
     super(telemetry, 'P2PClient');
 
@@ -231,7 +231,9 @@ export class P2PClient extends WithTracer implements P2P {
 
     this.keepAttestationsInPoolFor = keepAttestationsInPoolFor;
 
-    this.blockStream = new L2BlockStream(l2BlockSource, this, this, {
+    const tracer = telemetry.getTracer('P2PL2BlockStream');
+    const logger = createLogger('p2p:l2-block-stream');
+    this.blockStream = new TraceableL2BlockStream(l2BlockSource, this, this, tracer, 'P2PL2BlockStream', logger, {
       batchSize: blockRequestBatchSize,
       pollIntervalMS: blockCheckIntervalMS,
     });
@@ -241,8 +243,16 @@ export class P2PClient extends WithTracer implements P2P {
     this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
 
     this.txPool = mempools.txPool;
-    this.attestationPool = mempools.attestationPool;
     this.epochProofQuotePool = mempools.epochProofQuotePool;
+    this.attestationPool = mempools.attestationPool!;
+  }
+
+  public isP2PClient(): true {
+    return true;
+  }
+
+  public getPeers(includePending?: boolean): Promise<PeerInfo[]> {
+    return Promise.resolve(this.p2pService.getPeers(includePending));
   }
 
   public getL2BlockHash(number: number): Promise<string | undefined> {
@@ -361,7 +371,7 @@ export class P2PClient extends WithTracer implements P2P {
       this.setCurrentState(P2PClientState.RUNNING);
       this.syncPromise = Promise.resolve();
       await this.p2pService.start();
-      this.log.verbose(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
+      this.log.debug(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
     }
 
     // publish any txs in TxPool after its doing initial sync
@@ -401,7 +411,7 @@ export class P2PClient extends WithTracer implements P2P {
   }
 
   public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
-    return Promise.resolve(this.attestationPool.getAttestationsForSlot(slot, proposalId));
+    return Promise.resolve(this.attestationPool?.getAttestationsForSlot(slot, proposalId) ?? []);
   }
 
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
@@ -436,14 +446,20 @@ export class P2PClient extends WithTracer implements P2P {
   public async requestTxByHash(txHash: TxHash): Promise<Tx | undefined> {
     const tx = await this.p2pService.sendRequest(TX_REQ_PROTOCOL, txHash);
 
-    this.log.debug(`Requested ${txHash.toString()} from peer | success = ${!!tx}`);
     if (tx) {
+      this.log.debug(`Received tx ${txHash.toString()} from peer`);
       await this.txPool.addTxs([tx]);
+    } else {
+      this.log.debug(`Failed to receive tx ${txHash.toString()} from peer`);
     }
 
     return tx;
   }
 
+  public getPendingTxs(): Promise<Tx[]> {
+    return Promise.resolve(this.getTxs('pending'));
+  }
+
   /**
    * Returns all transactions in the transaction pool.
    * @returns An array of Txs.
@@ -514,6 +530,10 @@ export class P2PClient extends WithTracer implements P2P {
     return this.p2pService.getEnr();
   }
 
+  public getEncodedEnr(): Promise<string | undefined> {
+    return Promise.resolve(this.p2pService.getEnr()?.encodeTxt());
+  }
+
   /**
    * Deletes the 'txs' from the pool.
    * NOT used if we use sendTx as reconcileTxPool will handle this.
@@ -636,16 +656,17 @@ export class P2PClient extends WithTracer implements P2P {
     // We delete attestations older than the last block slot minus the number of slots we want to keep in the pool.
     const lastBlockSlotMinusKeepAttestationsInPoolFor = lastBlockSlot - BigInt(this.keepAttestationsInPoolFor);
     if (lastBlockSlotMinusKeepAttestationsInPoolFor >= BigInt(INITIAL_L2_BLOCK_NUM)) {
-      await this.attestationPool.deleteAttestationsOlderThan(lastBlockSlotMinusKeepAttestationsInPoolFor);
+      await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlotMinusKeepAttestationsInPoolFor);
     }
 
-    await this.synchedProvenBlockNumber.set(lastBlockNum);
-    this.log.debug(`Synched to proven block ${lastBlockNum}`);
     const provenEpochNumber = await this.l2BlockSource.getProvenL2EpochNumber();
     if (provenEpochNumber !== undefined) {
       this.epochProofQuotePool.deleteQuotesToEpoch(BigInt(provenEpochNumber));
     }
 
+    await this.synchedProvenBlockNumber.set(lastBlockNum);
+    this.log.debug(`Synched to proven block ${lastBlockNum}`);
+
     await this.startServiceIfSynched();
   }
 
@@ -709,8 +730,9 @@ export class P2PClient extends WithTracer implements P2P {
    * @param newState - New state value.
    */
   private setCurrentState(newState: P2PClientState) {
+    const oldState = this.currentState;
     this.currentState = newState;
-    this.log.debug(`Moved to state ${P2PClientState[this.currentState]}`);
+    this.log.debug(`Moved from state ${P2PClientState[oldState]} to ${P2PClientState[this.currentState]}`);
   }
 
   private async publishStoredTxs() {

package/src/config.ts

@@ -8,7 +8,7 @@ import {
 } from '@aztec/foundation/config';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
 
-import { type P2PReqRespConfig, p2pReqRespConfigMappings } from './service/reqresp/config.js';
+import { type P2PReqRespConfig, p2pReqRespConfigMappings } from './services/reqresp/config.js';
 
 /**
  * P2P client configuration values.

package/src/errors/reqresp.error.ts

@@ -3,7 +3,7 @@
  * This error will be thrown when a request to a specific peer times out.
  * @category Errors
  */
-export class IndiviualReqRespTimeoutError extends Error {
+export class IndividualReqRespTimeoutError extends Error {
   constructor() {
     super(`Request to peer timed out`);
   }
@@ -19,3 +19,17 @@ export class CollectiveReqRespTimeoutError extends Error {
     super(`Request to all peers timed out`);
   }
 }
+
+/** Invalid response error
+ *
+ * This error will be thrown when a response is received that is not valid.
+ *
+ * This error does not need to be punished as message validators will handle punishing invalid
+ * requests
+ * @category Errors
+ */
+export class InvalidResponseError extends Error {
+  constructor() {
+    super(`Invalid response received`);
+  }
+}

package/src/index.ts

@@ -3,6 +3,6 @@ export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';
 export * from './config.js';
 export * from './mem_pools/epoch_proof_quote_pool/index.js';
-export * from './service/index.js';
+export * from './services/index.js';
 export * from './mem_pools/tx_pool/index.js';
 export * from './tx_validator/index.js';

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -39,6 +39,16 @@ export interface AttestationPool {
    */
   deleteAttestationsForSlot(slot: bigint): Promise<void>;
 
+  /**
+   * Delete Attestations for slot and proposal
+   *
+   * Removes all attestations associated with a slot and proposal
+   *
+   * @param slot - The slot to delete.
+   * @param proposalId - The proposal to delete.
+   */
+  deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void>;
+
   /**
    * Get Attestations for slot
    *

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -0,0 +1,237 @@
+import { type BlockAttestation, TxHash } from '@aztec/circuit-types';
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+
+import { jest } from '@jest/globals';
+import { type MockProxy, mock } from 'jest-mock-extended';
+
+import { type PoolInstrumentation } from '../instrumentation.js';
+import { type AttestationPool } from './attestation_pool.js';
+import { mockAttestation } from './mocks.js';
+
+const NUMBER_OF_SIGNERS_PER_TEST = 4;
+
+export function describeAttestationPool(getAttestationPool: () => AttestationPool) {
+  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));
+  };
+
+  // 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[]) => {
+    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.map(signer => mockAttestation(signer, slotNumber, archive));
+
+    await ap.addAttestations(attestations);
+
+    // Check metrics have been updated.
+    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations.length);
+
+    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), archive.toString());
+
+    expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
+
+    compareAttestations(retreivedAttestations, attestations);
+
+    // Delete by slot
+    await ap.deleteAttestationsForSlot(BigInt(slotNumber));
+
+    expect(metricsMock.recordRemovedObjects).toHaveBeenCalledWith(attestations.length);
+
+    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlot(BigInt(slotNumber), archive.toString());
+    expect(retreivedAttestationsAfterDelete.length).toBe(0);
+  });
+
+  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(mockAttestation(signer, slotNumber, archive, txs));
+    }
+
+    await ap.addAttestations(attestations);
+
+    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), archive.toString());
+    expect(retreivedAttestations.length).toBe(1);
+    expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
+    expect(retreivedAttestations[0].payload.txHashes).toEqual(txs);
+    expect(retreivedAttestations[0].getSender().toString()).toEqual(signer.address.toString());
+  });
+
+  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.globalVariables.slotNumber;
+      const archive = attestation.archive.toString();
+
+      const retreivedAttestations = await ap.getAttestationsForSlot(slot.toBigInt(), archive);
+      expect(retreivedAttestations.length).toBe(1);
+      expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
+      expect(retreivedAttestations[0].payload.header.globalVariables.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.globalVariables.slotNumber;
+      const proposalId = attestation.archive.toString();
+
+      const retreivedAttestations = await ap.getAttestationsForSlot(slot.toBigInt(), proposalId);
+      expect(retreivedAttestations.length).toBe(1);
+      expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
+      expect(retreivedAttestations[0].payload.header.globalVariables.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);
+
+    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations.length);
+
+    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
+    compareAttestations(retreivedAttestations, attestations);
+
+    await ap.deleteAttestations(attestations);
+
+    expect(metricsMock.recordRemovedObjects).toHaveBeenCalledWith(attestations.length);
+
+    const gottenAfterDelete = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    expect(gottenAfterDelete.length).toBe(0);
+  });
+
+  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 proposalId = attestations[0].archive.toString();
+
+    await ap.addAttestations(attestations);
+
+    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
+    compareAttestations(retreivedAttestations, attestations);
+
+    await ap.deleteAttestationsForSlot(BigInt(slotNumber));
+
+    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlot(BigInt(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);
+
+    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations.length);
+    expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(attestations2.length);
+
+    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
+    compareAttestations(retreivedAttestations, attestations);
+
+    await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+
+    expect(metricsMock.recordRemovedObjects).toHaveBeenCalledWith(attestations.length);
+
+    const retreivedAttestationsAfterDelete = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    expect(retreivedAttestationsAfterDelete.length).toBe(0);
+
+    const retreivedAttestationsAfterDeleteForOtherProposal = await ap.getAttestationsForSlot(
+      BigInt(slotNumber),
+      proposalId2,
+    );
+    expect(retreivedAttestationsAfterDeleteForOtherProposal.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
+    compareAttestations(retreivedAttestationsAfterDeleteForOtherProposal, attestations2);
+  });
+
+  it('Should blanket delete attestations per slot and proposal (does not perform db ops if there are no attestations)', async () => {
+    const slotNumber = 420;
+    const proposalId = 'proposalId';
+
+    const retreivedAttestations = await ap.getAttestationsForSlot(BigInt(slotNumber), proposalId);
+    expect(retreivedAttestations.length).toBe(0);
+
+    await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+
+    expect(metricsMock.recordRemovedObjects).toHaveBeenCalledTimes(0);
+  });
+
+  it('Should delete attestations older than a given slot', async () => {
+    const slotNumbers = [1, 2, 3, 69, 72, 74, 88, 420];
+    const attestations = slotNumbers.map(slotNumber => createAttestationsForSlot(slotNumber)).flat();
+    const proposalId = attestations[0].archive.toString();
+
+    await ap.addAttestations(attestations);
+
+    const attestationsForSlot1 = await ap.getAttestationsForSlot(BigInt(1), proposalId);
+    expect(attestationsForSlot1.length).toBe(signers.length);
+
+    const deleteAttestationsSpy = jest.spyOn(ap, 'deleteAttestationsForSlot');
+
+    await ap.deleteAttestationsOlderThan(BigInt(73));
+
+    const attestationsForSlot1AfterDelete = await ap.getAttestationsForSlot(BigInt(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));
+  });
+}