@aztec/p2p 0.67.0 → 0.67.1-devnet

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.

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));
+  });
+}

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -0,0 +1,153 @@
+import { BlockAttestation } from '@aztec/circuit-types';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { type AztecKVStore, type AztecMapWithSize, type AztecMultiMap } from '@aztec/kv-store';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { type AttestationPool } from './attestation_pool.js';
+
+export class KvAttestationPool implements AttestationPool {
+  private metrics: PoolInstrumentation<BlockAttestation>;
+
+  // Index of all proposal ids in a slot
+  private attestations: AztecMultiMap<string, string>;
+
+  constructor(
+    private store: AztecKVStore,
+    telemetry: TelemetryClient,
+    private log = createLogger('aztec:attestation_pool'),
+  ) {
+    this.attestations = store.openMultiMap('attestations');
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
+  }
+
+  private getProposalMapKey(slot: string, proposalId: string): string {
+    return `proposal-${slot}-${proposalId}`;
+  }
+
+  /**
+   * Get the proposal map for a given slot and proposalId
+   *
+   * Essentially a nested mapping of address -> attestation
+   *
+   * @param slot - The slot to get the proposal map for
+   * @param proposalId - The proposalId to get the map for
+   * @returns The proposal map
+   */
+  private getProposalMap(slot: string, proposalId: string): AztecMapWithSize<string, Buffer> {
+    const mapKey = this.getProposalMapKey(slot, proposalId);
+    return this.store.openMapWithSize(mapKey);
+  }
+
+  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
+    for (const attestation of attestations) {
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber.toString();
+      const proposalId = attestation.archive.toString();
+      const address = attestation.getSender().toString();
+
+      // Index the proposalId in the slot map
+      await this.attestations.set(slotNumber, proposalId);
+
+      // Store the actual attestation in the proposal map
+      const proposalMap = this.getProposalMap(slotNumber, proposalId);
+      await proposalMap.set(address, attestation.toBuffer());
+
+      this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
+    }
+
+    this.metrics.recordAddedObjects(attestations.length);
+  }
+
+  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+    const slotNumber = new Fr(slot).toString();
+    const proposalMap = this.getProposalMap(slotNumber, proposalId);
+    const attestations = proposalMap.values();
+    const attestationsArray = Array.from(attestations).map(attestation => BlockAttestation.fromBuffer(attestation));
+    return Promise.resolve(attestationsArray);
+  }
+
+  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+    const olderThan = [];
+
+    const slots = this.attestations.keys();
+    for (const slot of slots) {
+      if (BigInt(slot) < oldestSlot) {
+        olderThan.push(slot);
+      }
+    }
+
+    await Promise.all(olderThan.map(oldSlot => this.deleteAttestationsForSlot(BigInt(oldSlot))));
+    return Promise.resolve();
+  }
+
+  public async deleteAttestationsForSlot(slot: bigint): Promise<void> {
+    const deletionPromises = [];
+
+    const slotString = new Fr(slot).toString();
+    let numberOfAttestations = 0;
+    const proposalIds = this.attestations.getValues(slotString);
+
+    if (proposalIds) {
+      for (const proposalId of proposalIds) {
+        const proposalMap = this.getProposalMap(slotString, proposalId);
+        numberOfAttestations += proposalMap.size();
+        deletionPromises.push(proposalMap.clear());
+      }
+    }
+
+    await Promise.all(deletionPromises);
+
+    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
+    this.metrics.recordRemovedObjects(numberOfAttestations);
+    return Promise.resolve();
+  }
+
+  public async deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+    const deletionPromises = [];
+
+    const slotString = new Fr(slot).toString();
+    const exists = this.attestations.get(slotString);
+
+    if (exists) {
+      // Remove the proposalId from the slot index
+      deletionPromises.push(this.attestations.deleteValue(slotString, proposalId));
+
+      // Delete all attestations for the proposalId
+      const proposalMap = this.getProposalMap(slotString, proposalId);
+      const numberOfAttestations = proposalMap.size();
+      deletionPromises.push(proposalMap.clear());
+
+      this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
+      this.metrics.recordRemovedObjects(numberOfAttestations);
+    }
+
+    await Promise.all(deletionPromises);
+    return Promise.resolve();
+  }
+
+  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+    const deletionPromises = [];
+
+    for (const attestation of attestations) {
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber.toString();
+      const proposalId = attestation.archive.toString();
+      const proposalMap = this.getProposalMap(slotNumber, proposalId);
+
+      if (proposalMap) {
+        const address = attestation.getSender().toString();
+        deletionPromises.push(proposalMap.delete(address));
+        this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
+      }
+
+      if (proposalMap.size() === 0) {
+        deletionPromises.push(this.attestations.deleteValue(slotNumber, proposalId));
+      }
+    }
+
+    await Promise.all(deletionPromises);
+
+    this.metrics.recordRemovedObjects(attestations.length);
+    return Promise.resolve();
+  }
+}

package/src/mem_pools/interface.ts

@@ -1,3 +1,5 @@
+import { type P2PClientType } from '@aztec/circuit-types';
+
 import { type AttestationPool } from './attestation_pool/attestation_pool.js';
 import { type EpochProofQuotePool } from './epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { type TxPool } from './tx_pool/tx_pool.js';
@@ -5,8 +7,8 @@ import { type TxPool } from './tx_pool/tx_pool.js';
 /**
  * A interface the combines all mempools
  */
-export interface MemPools {
+export type MemPools<T extends P2PClientType = P2PClientType.Full> = {
   txPool: TxPool;
-  attestationPool: AttestationPool;
+  attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
   epochProofQuotePool: EpochProofQuotePool;
-}
+};

package/src/mocks/index.ts

@@ -1,6 +1,7 @@
 import {
   type ClientProtocolCircuitVerifier,
   type L2BlockSource,
+  type P2PClientType,
   type Tx,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
@@ -23,11 +24,11 @@ import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 import { BootstrapNode } from '../bootstrap/bootstrap.js';
 import { type BootnodeConfig, type P2PConfig } from '../config.js';
 import { type MemPools } from '../mem_pools/interface.js';
-import { DiscV5Service } from '../service/discV5_service.js';
-import { LibP2PService } from '../service/libp2p_service.js';
-import { type PeerManager } from '../service/peer_manager.js';
-import { type P2PReqRespConfig } from '../service/reqresp/config.js';
-import { pingHandler, statusHandler } from '../service/reqresp/handlers.js';
+import { DiscV5Service } from '../services/discv5/discV5_service.js';
+import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import { type PeerManager } from '../services/peer_manager.js';
+import { type P2PReqRespConfig } from '../services/reqresp/config.js';
+import { pingHandler, statusHandler } from '../services/reqresp/handlers.js';
 import {
   PING_PROTOCOL,
   type ReqRespSubProtocolHandlers,
@@ -35,8 +36,8 @@ import {
   STATUS_PROTOCOL,
   TX_REQ_PROTOCOL,
   noopValidator,
-} from '../service/reqresp/interface.js';
-import { ReqResp } from '../service/reqresp/reqresp.js';
+} from '../services/reqresp/interface.js';
+import { ReqResp } from '../services/reqresp/reqresp.js';
 import { type PubSubLibp2p } from '../util.js';
 
 /**
@@ -95,11 +96,12 @@ export async function createLibp2pNode(
  *
  *
  */
-export async function createTestLibP2PService(
+export async function createTestLibP2PService<T extends P2PClientType>(
+  clientType: T,
   boostrapAddrs: string[] = [],
   l2BlockSource: L2BlockSource,
   worldStateSynchronizer: WorldStateSynchronizer,
-  mempools: MemPools,
+  mempools: MemPools<T>,
   telemetry: TelemetryClient,
   port: number = 0,
   peerId?: PeerId,
@@ -123,7 +125,8 @@ export async function createTestLibP2PService(
   // No bootstrap nodes provided as the libp2p service will register them in the constructor
   const p2pNode = await createLibp2pNode([], peerId, port, /*enable gossip */ true, /**start */ false);
 
-  return new LibP2PService(
+  return new LibP2PService<T>(
+    clientType,
     config,
     p2pNode as PubSubLibp2p,
     discoveryService,

package/src/{service → services/discv5}/discV5_service.ts

@@ -8,9 +8,9 @@ import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
 import EventEmitter from 'events';
 
-import type { P2PConfig } from '../config.js';
-import { convertToMultiaddr } from '../util.js';
-import { type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
+import type { P2PConfig } from '../../config.js';
+import { convertToMultiaddr } from '../../util.js';
+import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
 
 export const AZTEC_ENR_KEY = 'aztec_network';