@aztec/p2p 0.67.1 → 0.68.1

package/src/client/factory.ts

@@ -0,0 +1,97 @@
+import {
+  type ClientProtocolCircuitVerifier,
+  type L2BlockSource,
+  P2PClientType,
+  type WorldStateSynchronizer,
+} from '@aztec/circuit-types';
+import { type EpochCache } from '@aztec/epoch-cache';
+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/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 { 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 '../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';
+
+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,
+  epochCache: EpochCache,
+  telemetry: TelemetryClient = new NoopTelemetryClient(),
+  deps: P2PClientDeps<T> = {},
+) => {
+  let config = { ..._config };
+  const logger = createLogger('p2p');
+  const store = deps.store ?? (await createStore('p2p', config, createLogger('p2p:lmdb')));
+
+  const mempools: MemPools<T> = {
+    txPool: deps.txPool ?? new AztecKVTxPool(store, telemetry),
+    epochProofQuotePool: deps.epochProofQuotePool ?? new MemoryEpochProofQuotePool(telemetry),
+    attestationPool:
+      clientType === P2PClientType.Full
+        ? ((deps.attestationPool ?? new InMemoryAttestationPool(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
+    const peerIdPrivateKey = await getPeerIdPrivateKey(config, store);
+    const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey);
+    const discoveryService = new DiscV5Service(peerId, config, telemetry);
+
+    p2pService = await LibP2PService.new<T>(
+      clientType,
+      config,
+      discoveryService,
+      peerId,
+      mempools,
+      l2BlockSource,
+      epochCache,
+      proofVerifier,
+      worldStateSynchronizer,
+      store,
+      telemetry,
+    );
+  } else {
+    logger.verbose('P2P is disabled. Using dummy P2P service');
+    p2pService = new DummyP2PService();
+  }
+  return new P2PClient(
+    clientType,
+    store,
+    l2BlockSource,
+    mempools,
+    p2pService,
+    config.keepProvenTxsInPoolFor,
+    telemetry,
+  );
+};

package/src/client/index.ts

@@ -1,74 +1,2 @@
-import type { ClientProtocolCircuitVerifier, L2BlockSource, 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/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 { 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 { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
-
 export * from './p2p_client.js';
-
-export const createP2PClient = async (
-  _config: P2PConfig & DataStoreConfig,
-  l2BlockSource: L2BlockSource,
-  proofVerifier: ClientProtocolCircuitVerifier,
-  worldStateSynchronizer: WorldStateSynchronizer,
-  telemetry: TelemetryClient = new NoopTelemetryClient(),
-  deps: {
-    txPool?: TxPool;
-    store?: AztecKVStore;
-    attestationPool?: AttestationPool;
-    epochProofQuotePool?: EpochProofQuotePool;
-  } = {},
-) => {
-  let config = { ..._config };
-  const logger = createLogger('p2p');
-  const store = deps.store ?? (await createStore('p2p', config, createLogger('p2p:lmdb')));
-
-  const mempools: MemPools = {
-    txPool: deps.txPool ?? new AztecKVTxPool(store, telemetry),
-    attestationPool: deps.attestationPool ?? new InMemoryAttestationPool(telemetry),
-    epochProofQuotePool: deps.epochProofQuotePool ?? new MemoryEpochProofQuotePool(telemetry),
-  };
-
-  let p2pService;
-
-  if (_config.p2pEnabled) {
-    logger.verbose('P2P is enabled. Using LibP2P service.');
-    config = await configureP2PClientAddresses(_config);
-
-    // Create peer discovery service
-    const peerIdPrivateKey = await getPeerIdPrivateKey(config, store);
-    const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey);
-    const discoveryService = new DiscV5Service(peerId, config, telemetry);
-
-    p2pService = await LibP2PService.new(
-      config,
-      discoveryService,
-      peerId,
-      mempools,
-      l2BlockSource,
-      proofVerifier,
-      worldStateSynchronizer,
-      store,
-      telemetry,
-    );
-  } else {
-    logger.verbose('P2P is disabled. Using dummy P2P service');
-    p2pService = new DummyP2PService();
-  }
-  return new P2PClient(store, l2BlockSource, mempools, p2pService, config.keepProvenTxsInPoolFor, telemetry);
-};
+export * from './factory.js';

package/src/client/p2p_client.ts

@@ -5,10 +5,10 @@ import {
   type L2Block,
   type L2BlockId,
   type L2BlockSource,
-  L2BlockStream,
   type L2BlockStreamEvent,
   type L2Tips,
   type P2PApi,
+  type P2PClientType,
   type PeerInfo,
   type Tx,
   type TxHash,
@@ -16,7 +16,13 @@ import {
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
 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';
@@ -26,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.
@@ -56,7 +62,7 @@ export interface P2PSyncState {
 /**
  * Interface of a P2P client.
  **/
-export interface P2P extends P2PApi {
+export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApi<T> & {
   /**
    * Broadcasts a block proposal to other peers.
    *
@@ -166,12 +172,15 @@ export interface P2P extends P2PApi {
 
   /** 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;
 
@@ -189,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. */
@@ -207,9 +216,10 @@ 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(),
@@ -221,7 +231,9 @@ export class P2PClient extends WithTracer implements P2P {
 
     this.keepAttestationsInPoolFor = keepAttestationsInPoolFor;
 
-    this.blockStream = new L2BlockStream(l2BlockSource, this, this, createLogger('p2p:block_stream'), {
+    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,
     });
@@ -231,8 +243,8 @@ 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 {
@@ -399,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
@@ -644,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();
   }
 

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.
@@ -170,7 +170,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   peerCheckIntervalMS: {
     env: 'P2P_PEER_CHECK_INTERVAL_MS',
     description: 'The frequency in which to check for new peers.',
-    ...numberConfigHelper(1_000),
+    ...numberConfigHelper(30_000),
   },
   l2QueueSize: {
     env: 'P2P_L2_QUEUE_SIZE',

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';
+export * from './msg_validators/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));
+  });
+}