@aztec/p2p 0.0.0-test.0

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -0,0 +1,230 @@
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import { jest } from '@jest/globals';
+import { type MockProxy, mock } from 'jest-mock-extended';
+
+import type { PoolInstrumentation } from '../instrumentation.js';
+import type { 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 Promise.all(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 = await Promise.all(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(await 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((await retreivedAttestations[0].getSender()).toString()).toEqual(signer.address.toString());
+  });
+
+  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])));
+
+    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 = await Promise.all(
+      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 = await Promise.all(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 = await Promise.all(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 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 delete attestations older than a given slot', async () => {
+    const slotNumbers = [1, 2, 3, 69, 72, 74, 88, 420];
+    const attestations = (
+      await Promise.all(slotNumbers.map(slotNumber => createAttestationsForSlot(slotNumber)))
+    ).flat();
+    const proposalId = attestations[0].archive.toString();
+
+    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/index.ts

@@ -0,0 +1,2 @@
+export * from './attestation_pool.js';
+export * from './memory_attestation_pool.js';

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -0,0 +1,159 @@
+import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
+import { createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
+import { BlockAttestation } from '@aztec/stdlib/p2p';
+import { type TelemetryClient, getTelemetryClient } 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>;
+
+  private attestations: AztecAsyncMap<string, Buffer>;
+  private proposalsForSlot: AztecAsyncMultiMap<string, string>;
+  private attestationsForProposal: AztecAsyncMultiMap<string, string>;
+
+  constructor(
+    private store: AztecAsyncKVStore,
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('aztec:attestation_pool'),
+  ) {
+    this.attestations = store.openMap('attestations');
+    this.proposalsForSlot = store.openMultiMap('proposals_for_slot');
+    this.attestationsForProposal = store.openMultiMap('attestations_for_proposal');
+
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
+  }
+
+  private getProposalKey(slot: number | bigint | Fr | string, proposalId: Fr | string | Buffer): string {
+    const slotStr = typeof slot === 'string' ? slot : new Fr(slot).toString();
+    const proposalIdStr =
+      typeof proposalId === 'string'
+        ? proposalId
+        : Buffer.isBuffer(proposalId)
+        ? Fr.fromBuffer(proposalId).toString()
+        : proposalId.toString();
+
+    return `${slotStr}-${proposalIdStr}`;
+  }
+
+  private getAttestationKey(slot: number | bigint | Fr | string, proposalId: Fr | string, address: string): string {
+    return `${this.getProposalKey(slot, proposalId)}-${address}`;
+  }
+
+  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
+    await this.store.transactionAsync(async () => {
+      for (const attestation of attestations) {
+        const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+        const proposalId = attestation.archive;
+        const address = (await attestation.getSender()).toString();
+
+        await this.attestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
+
+        await this.proposalsForSlot.set(slotNumber.toString(), proposalId.toString());
+        await this.attestationsForProposal.set(
+          this.getProposalKey(slotNumber, proposalId),
+          this.getAttestationKey(slotNumber, proposalId, address),
+        );
+
+        this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
+      }
+    });
+
+    this.metrics.recordAddedObjects(attestations.length);
+  }
+
+  public async getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+    const attestationIds = await toArray(
+      this.attestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
+    );
+    const attestations: BlockAttestation[] = [];
+
+    // alternatively iterate this.attestaions starting from slot-proposal-EthAddress.zero
+    for (const id of attestationIds) {
+      const buf = await this.attestations.getAsync(id);
+
+      if (!buf) {
+        // this should not happen unless we lost writes
+        throw new Error('Attestation not found ' + id);
+      }
+
+      const attestation = BlockAttestation.fromBuffer(buf);
+      attestations.push(attestation);
+    }
+
+    return attestations;
+  }
+
+  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+    const olderThan = await toArray(this.proposalsForSlot.keysAsync({ end: new Fr(oldestSlot).toString() }));
+    for (const oldSlot of olderThan) {
+      await this.deleteAttestationsForSlot(BigInt(oldSlot));
+    }
+  }
+
+  public async deleteAttestationsForSlot(slot: bigint): Promise<void> {
+    const slotFr = new Fr(slot);
+    let numberOfAttestations = 0;
+    await this.store.transactionAsync(async () => {
+      const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slotFr.toString()));
+      for (const proposalId of proposalIds) {
+        const attestations = await toArray(
+          this.attestationsForProposal.getValuesAsync(this.getProposalKey(slotFr, proposalId)),
+        );
+
+        numberOfAttestations += attestations.length;
+        for (const attestation of attestations) {
+          await this.attestations.delete(attestation);
+        }
+
+        await this.attestationsForProposal.delete(this.getProposalKey(slotFr, proposalId));
+      }
+    });
+
+    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
+    this.metrics.recordRemovedObjects(numberOfAttestations);
+  }
+
+  public async deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+    let numberOfAttestations = 0;
+    await this.store.transactionAsync(async () => {
+      const slotString = new Fr(slot).toString();
+      const attestations = await toArray(
+        this.attestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
+      );
+
+      numberOfAttestations += attestations.length;
+      for (const attestation of attestations) {
+        await this.attestations.delete(attestation);
+      }
+
+      await this.proposalsForSlot.deleteValue(slotString, proposalId);
+      await this.attestationsForProposal.delete(this.getProposalKey(slotString, proposalId));
+    });
+
+    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
+    this.metrics.recordRemovedObjects(numberOfAttestations);
+  }
+
+  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+    await this.store.transactionAsync(async () => {
+      for (const attestation of attestations) {
+        const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+        const proposalId = attestation.archive;
+        const address = (await attestation.getSender()).toString();
+
+        await this.attestations.delete(this.getAttestationKey(slotNumber, proposalId, address));
+        await this.attestationsForProposal.deleteValue(
+          this.getProposalKey(slotNumber, proposalId),
+          this.getAttestationKey(slotNumber, proposalId, address),
+        );
+
+        this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
+      }
+    });
+    this.metrics.recordRemovedObjects(attestations.length);
+  }
+}

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -0,0 +1,161 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import type { AttestationPool } from './attestation_pool.js';
+
+export class InMemoryAttestationPool implements AttestationPool {
+  private metrics: PoolInstrumentation<BlockAttestation>;
+
+  private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
+
+  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:attestation_pool')) {
+    this.attestations = new Map();
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
+  }
+
+  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+    const slotAttestationMap = this.attestations.get(slot);
+    if (slotAttestationMap) {
+      const proposalAttestationMap = slotAttestationMap.get(proposalId);
+      if (proposalAttestationMap) {
+        return Promise.resolve(Array.from(proposalAttestationMap.values()));
+      }
+    }
+    return Promise.resolve([]);
+  }
+
+  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
+    for (const attestation of attestations) {
+      // Perf: order and group by slot before insertion
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+
+      const proposalId = attestation.archive.toString();
+      const address = await attestation.getSender();
+
+      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
+      const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
+      proposalAttestationMap.set(address.toString(), attestation);
+
+      this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
+    }
+
+    // TODO: set these to pending or something ????
+    this.metrics.recordAddedObjects(attestations.length);
+    return Promise.resolve();
+  }
+
+  #getNumberOfAttestationsInSlot(slot: bigint): number {
+    let total = 0;
+    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
+
+    if (slotAttestationMap) {
+      for (const proposalAttestationMap of slotAttestationMap.values() ?? []) {
+        total += proposalAttestationMap.size;
+      }
+    }
+    return total;
+  }
+
+  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+    const olderThan = [];
+
+    // Entries are iterated in insertion order, so we can break as soon as we find a slot that is older than the oldestSlot.
+    // Note: this will only prune correctly if attestations are added in order of rising slot, it is important that we do not allow
+    // insertion of attestations that are old. #(https://github.com/AztecProtocol/aztec-packages/issues/10322)
+    const slots = this.attestations.keys();
+    for (const slot of slots) {
+      if (slot < oldestSlot) {
+        olderThan.push(slot);
+      } else {
+        break;
+      }
+    }
+
+    for (const oldSlot of olderThan) {
+      await this.deleteAttestationsForSlot(oldSlot);
+    }
+    return Promise.resolve();
+  }
+
+  public deleteAttestationsForSlot(slot: bigint): Promise<void> {
+    // We count the number of attestations we are removing
+    const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);
+
+    this.attestations.delete(slot);
+    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
+
+    this.metrics.recordRemovedObjects(numberOfAttestations);
+    return Promise.resolve();
+  }
+
+  public deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
+    if (slotAttestationMap) {
+      if (slotAttestationMap.has(proposalId)) {
+        const numberOfAttestations = slotAttestationMap.get(proposalId)?.size ?? 0;
+
+        slotAttestationMap.delete(proposalId);
+
+        this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
+        this.metrics.recordRemovedObjects(numberOfAttestations);
+      }
+    }
+    return Promise.resolve();
+  }
+
+  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+    for (const attestation of attestations) {
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+      const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
+      if (slotAttestationMap) {
+        const proposalId = attestation.archive.toString();
+        const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
+        if (proposalAttestationMap) {
+          const address = await attestation.getSender();
+          proposalAttestationMap.delete(address.toString());
+          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
+        }
+      }
+    }
+    this.metrics.recordRemovedObjects(attestations.length);
+    return Promise.resolve();
+  }
+}
+
+/**
+ * Get Slot or Default
+ *
+ * Fetch the slot mapping, if it does not exist, then create a mapping and return it
+ * @param map - The map to fetch from
+ * @param slot - The slot to fetch
+ * @returns The slot mapping
+ */
+function getSlotOrDefault(
+  map: Map<bigint, Map<string, Map<string, BlockAttestation>>>,
+  slot: bigint,
+): Map<string, Map<string, BlockAttestation>> {
+  if (!map.has(slot)) {
+    map.set(slot, new Map<string, Map<string, BlockAttestation>>());
+  }
+  return map.get(slot)!;
+}
+
+/**
+ * Get Proposal or Default
+ *
+ * Fetch the proposal mapping, if it does not exist, then create a mapping and return it
+ * @param map - The map to fetch from
+ * @param proposalId - The proposal id to fetch
+ * @returns The proposal mapping
+ */
+function getProposalOrDefault(
+  map: Map<string, Map<string, BlockAttestation>>,
+  proposalId: string,
+): Map<string, BlockAttestation> {
+  if (!map.has(proposalId)) {
+    map.set(proposalId, new Map<string, BlockAttestation>());
+  }
+  return map.get(proposalId)!;
+}

package/src/mem_pools/attestation_pool/mocks.ts

@@ -0,0 +1,44 @@
+import type { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import {
+  BlockAttestation,
+  ConsensusPayload,
+  SignatureDomainSeparator,
+  getHashedSignaturePayloadEthSignedMessage,
+} from '@aztec/stdlib/p2p';
+import { makeHeader } from '@aztec/stdlib/testing';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import { type LocalAccount, generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+
+/** Generate Account
+ *
+ * Create a random signer
+ * @returns A random viem signer
+ */
+export const generateAccount = (): LocalAccount => {
+  const privateKey = generatePrivateKey();
+  return privateKeyToAccount(privateKey);
+};
+
+/** Mock Attestation
+ *
+ * @param signer A viem signer to create a signature
+ * @param slot The slot number the attestation is for
+ * @returns A Block Attestation
+ */
+export const mockAttestation = async (
+  signer: Secp256k1Signer,
+  slot: number = 0,
+  archive: Fr = Fr.random(),
+  txs: TxHash[] = [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
+): Promise<BlockAttestation> => {
+  // Use arbitrary numbers for all other than slot
+  const header = makeHeader(1, 2, slot);
+  const payload = new ConsensusPayload(header, archive, txs);
+
+  const hash = await getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const signature = signer.sign(hash);
+
+  return new BlockAttestation(payload, signature);
+};

package/src/mem_pools/index.ts

@@ -0,0 +1,3 @@
+export { type AttestationPool } from './attestation_pool/attestation_pool.js';
+export { type MemPools } from './interface.js';
+export { type TxPool } from './tx_pool/tx_pool.js';