@aztec/p2p 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -1,298 +0,0 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
-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, BlockProposal } from '@aztec/stdlib/p2p';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import { ProposalSlotCapExceededError } from '../../errors/attestation-pool.error.js';
-import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
-import type { AttestationPool } from './attestation_pool.js';
-
-export const MAX_PROPOSALS_PER_SLOT = 5;
-export const ATTESTATION_CAP_BUFFER = 10;
-
-export class KvAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<BlockAttestation>;
-
-  private attestations: AztecAsyncMap<string, Buffer>;
-  private proposals: AztecAsyncMap<
-    /*  proposal.payload.archive  */ string,
-    /* buffer representation of proposal */ Buffer
-  >;
-  private proposalsForSlot: AztecAsyncMultiMap<number, 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.proposals = store.openMap('proposals');
-    this.proposalsForSlot = store.openMultiMap('proposals_for_slot');
-    this.attestationsForProposal = store.openMultiMap('attestations_for_proposal');
-
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
-  }
-
-  private poolStats: PoolStatsCallback = async () => {
-    return {
-      itemCount: await this.attestations.sizeAsync(),
-    };
-  };
-
-  public async isEmpty(): Promise<boolean> {
-    for await (const _ of this.attestations.entriesAsync()) {
-      return false;
-    }
-    return true;
-  }
-
-  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.slotNumber;
-        const proposalId = attestation.archive;
-        const sender = attestation.getSender();
-
-        // Skip attestations with invalid signatures
-        if (!sender) {
-          this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber}`, {
-            signature: attestation.signature.toString(),
-            slotNumber,
-            proposalId,
-          });
-          continue;
-        }
-
-        const address = sender.toString();
-
-        await this.attestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
-
-        await this.proposalsForSlot.set(slotNumber, 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}`, {
-          signature: attestation.signature.toString(),
-          slotNumber,
-          address,
-          proposalId,
-        });
-      }
-    });
-  }
-
-  public async getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]> {
-    const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slot));
-    const attestations: BlockAttestation[] = [];
-
-    for (const proposalId of proposalIds) {
-      attestations.push(...(await this.getAttestationsForSlotAndProposal(slot, proposalId)));
-    }
-
-    return attestations;
-  }
-
-  public async getAttestationsForSlotAndProposal(slot: SlotNumber, 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: SlotNumber): Promise<void> {
-    const olderThan = await toArray(this.proposalsForSlot.keysAsync({ end: oldestSlot }));
-    for (const oldSlot of olderThan) {
-      await this.deleteAttestationsForSlot(SlotNumber(oldSlot));
-    }
-  }
-
-  public async deleteAttestationsForSlot(slot: SlotNumber): Promise<void> {
-    let numberOfAttestations = 0;
-    await this.store.transactionAsync(async () => {
-      const proposalIds = await toArray(this.proposalsForSlot.getValuesAsync(slot));
-      for (const proposalId of proposalIds) {
-        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.proposals.delete(proposalId);
-        await this.attestationsForProposal.delete(this.getProposalKey(slot, proposalId));
-      }
-
-      // Delete from proposalsForSlot
-      await this.proposalsForSlot.delete(slot);
-
-      this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
-    });
-  }
-
-  public async deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void> {
-    let numberOfAttestations = 0;
-    await this.store.transactionAsync(async () => {
-      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.proposals.delete(proposalId);
-      await this.proposalsForSlot.deleteValue(slot, proposalId);
-      await this.attestationsForProposal.delete(this.getProposalKey(slot, proposalId));
-
-      this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
-    });
-  }
-
-  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
-    await this.store.transactionAsync(async () => {
-      for (const attestation of attestations) {
-        const slotNumber = attestation.payload.header.slotNumber;
-        const proposalId = attestation.archive;
-        const sender = attestation.getSender();
-
-        // Skip attestations with invalid signatures
-        if (!sender) {
-          this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber}`);
-          continue;
-        }
-
-        const address = sender.toString();
-        const key = this.getAttestationKey(slotNumber, proposalId, address);
-
-        if (await this.attestations.hasAsync(key)) {
-          await this.attestations.delete(key);
-        }
-
-        await this.attestationsForProposal.deleteValue(
-          this.getProposalKey(slotNumber, proposalId),
-          this.getAttestationKey(slotNumber, proposalId, address),
-        );
-
-        this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
-      }
-    });
-  }
-
-  public async hasAttestation(attestation: BlockAttestation): Promise<boolean> {
-    const slotNumber = attestation.payload.header.slotNumber;
-    const proposalId = attestation.archive;
-    const sender = attestation.getSender();
-
-    // Attestations with invalid signatures are never in the pool
-    if (!sender) {
-      return false;
-    }
-
-    const address = sender.toString();
-    const key = this.getAttestationKey(slotNumber, proposalId, address);
-
-    return await this.attestations.hasAsync(key);
-  }
-
-  public async getBlockProposal(id: string): Promise<BlockProposal | undefined> {
-    const buffer = await this.proposals.getAsync(id);
-    try {
-      if (buffer && buffer.length > 0) {
-        return BlockProposal.fromBuffer(buffer);
-      }
-    } catch {
-      return Promise.resolve(undefined);
-    }
-
-    return Promise.resolve(undefined);
-  }
-
-  public async hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
-    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
-    return await this.proposals.hasAsync(id);
-  }
-
-  public async addBlockProposal(blockProposal: BlockProposal): Promise<void> {
-    await this.store.transactionAsync(async () => {
-      const slotKey = blockProposal.slotNumber;
-      const proposalId = blockProposal.archive.toString();
-
-      if (!(await this.canAddProposal(blockProposal))) {
-        throw new ProposalSlotCapExceededError(
-          `Maximum proposals per slot reached: slot=${slotKey} cap=${MAX_PROPOSALS_PER_SLOT} proposal=${proposalId}`,
-        );
-      }
-
-      await this.proposalsForSlot.set(slotKey, proposalId);
-      // Always update the stored proposal buffer so re-adds overwrite with latest data
-      await this.proposals.set(proposalId, blockProposal.toBuffer());
-    });
-  }
-
-  public async hasReachedProposalCap(slot: SlotNumber): Promise<boolean> {
-    const uniqueProposalCount = await this.proposalsForSlot.getValueCountAsync(slot);
-    return uniqueProposalCount >= MAX_PROPOSALS_PER_SLOT;
-  }
-
-  public async hasReachedAttestationCap(slot: SlotNumber, proposalId: string, committeeSize: number): Promise<boolean> {
-    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-    return (await this.attestationsForProposal.getValueCountAsync(this.getProposalKey(slot, proposalId))) >= limit;
-  }
-
-  public async canAddProposal(block: BlockProposal): Promise<boolean> {
-    return (
-      (await this.proposals.hasAsync(block.archive.toString())) || !(await this.hasReachedProposalCap(block.slotNumber))
-    );
-  }
-
-  public async canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean> {
-    return (
-      (await this.hasAttestation(attestation)) ||
-      !(await this.hasReachedAttestationCap(
-        attestation.payload.header.slotNumber,
-        attestation.archive.toString(),
-        committeeSize,
-      ))
-    );
-  }
-}

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,287 +0,0 @@
-import type { SlotNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
-import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
-import type { AttestationPool } from './attestation_pool.js';
-import { ATTESTATION_CAP_BUFFER, MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
-
-export class InMemoryAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<BlockAttestation>;
-
-  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  private attestations: Map<
-    /*slot=*/ SlotNumber,
-    Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>
-  >;
-  private proposals: Map<string, BlockProposal>;
-
-  constructor(
-    telemetry: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('p2p:attestation_pool'),
-  ) {
-    this.attestations = new Map();
-    this.proposals = new Map();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
-  }
-
-  private poolStats: PoolStatsCallback = () => {
-    return Promise.resolve({
-      itemCount: this.attestations.size,
-    });
-  };
-
-  public isEmpty(): Promise<boolean> {
-    return Promise.resolve(this.attestations.size === 0);
-  }
-
-  public getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]> {
-    return Promise.resolve(
-      Array.from(this.attestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
-        Array.from(proposalAttestationMap.values()),
-      ),
-    );
-  }
-
-  public getAttestationsForSlotAndProposal(slot: SlotNumber, 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 addAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      // Perf: order and group by slot before insertion
-      const slotNumber = attestation.payload.header.slotNumber;
-
-      const proposalId = attestation.archive.toString();
-      const sender = attestation.getSender();
-
-      // Skip attestations with invalid signatures
-      if (!sender) {
-        this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber}`, {
-          signature: attestation.signature.toString(),
-          slotNumber,
-          proposalId,
-        });
-        continue;
-      }
-
-      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber);
-      const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-      proposalAttestationMap.set(sender.toString(), attestation);
-
-      this.log.verbose(`Added attestation for slot ${slotNumber} from ${sender}`, {
-        signature: attestation.signature.toString(),
-        slotNumber,
-        address: sender,
-        proposalId,
-      });
-    }
-
-    return Promise.resolve();
-  }
-
-  #getNumberOfAttestationsInSlot(slot: SlotNumber): 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: SlotNumber): 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: SlotNumber): Promise<void> {
-    // We count the number of attestations we are removing
-    const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);
-    const proposalIdsToDelete = this.attestations.get(slot)?.keys();
-    let proposalIdsToDeleteCount = 0;
-    proposalIdsToDelete?.forEach(proposalId => {
-      this.proposals.delete(proposalId);
-      proposalIdsToDeleteCount++;
-    });
-
-    this.attestations.delete(slot);
-    this.log.verbose(
-      `Removed ${numberOfAttestations} attestations and ${proposalIdsToDeleteCount} proposals for slot ${slot}`,
-    );
-
-    return Promise.resolve();
-  }
-
-  public deleteAttestationsForSlotAndProposal(slot: SlotNumber, 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.proposals.delete(proposalId);
-    return Promise.resolve();
-  }
-
-  public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      const slotNumber = attestation.payload.header.slotNumber;
-      const slotAttestationMap = this.attestations.get(slotNumber);
-      if (slotAttestationMap) {
-        const proposalId = attestation.archive.toString();
-        const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-        if (proposalAttestationMap) {
-          const sender = attestation.getSender();
-
-          // Skip attestations with invalid signatures
-          if (!sender) {
-            this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber}`);
-            continue;
-          }
-
-          proposalAttestationMap.delete(sender.toString());
-          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${sender}`);
-        }
-      }
-    }
-    return Promise.resolve();
-  }
-
-  public hasAttestation(attestation: BlockAttestation): Promise<boolean> {
-    const slotNumber = attestation.payload.header.slotNumber;
-    const proposalId = attestation.archive.toString();
-    const sender = attestation.getSender();
-
-    // Attestations with invalid signatures are never in the pool
-    if (!sender) {
-      return Promise.resolve(false);
-    }
-
-    const slotAttestationMap = this.attestations.get(slotNumber);
-    if (!slotAttestationMap) {
-      return Promise.resolve(false);
-    }
-
-    const proposalAttestationMap = slotAttestationMap.get(proposalId);
-    if (!proposalAttestationMap) {
-      return Promise.resolve(false);
-    }
-
-    return Promise.resolve(proposalAttestationMap.has(sender.toString()));
-  }
-
-  public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
-    // We initialize slot-proposal mapping if it does not exist
-    // This is important to ensure we can delete this proposal if there were not attestations for it
-    const slotProposalMapping = getSlotOrDefault(this.attestations, blockProposal.slotNumber);
-    slotProposalMapping.set(blockProposal.payload.archive.toString(), new Map<string, BlockAttestation>());
-
-    this.proposals.set(blockProposal.payload.archive.toString(), blockProposal);
-    return Promise.resolve();
-  }
-
-  public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
-    return Promise.resolve(this.proposals.get(id));
-  }
-
-  public hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
-    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
-    return Promise.resolve(this.proposals.has(id));
-  }
-
-  public hasReachedProposalCap(slot: SlotNumber): Promise<boolean> {
-    const slotAttestationMap = this.attestations.get(slot);
-    const proposalCount = slotAttestationMap?.size ?? 0;
-    return Promise.resolve(proposalCount >= MAX_PROPOSALS_PER_SLOT);
-  }
-
-  public hasReachedAttestationCap(slot: SlotNumber, proposalId: string, committeeSize: number): Promise<boolean> {
-    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-    const count = this.attestations.get(slot)?.get(proposalId)?.size ?? 0;
-    return Promise.resolve(limit <= 0 || count >= limit);
-  }
-
-  public async canAddProposal(block: BlockProposal): Promise<boolean> {
-    return this.proposals.has(block.archive.toString()) || !(await this.hasReachedProposalCap(block.slotNumber));
-  }
-
-  public async canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean> {
-    const sender = attestation.getSender();
-    const slot = attestation.payload.header.slotNumber;
-    const pid = attestation.archive.toString();
-    return (
-      !!sender &&
-      ((this.attestations.get(slot)?.get(pid)?.has(sender.toString()) ?? false) ||
-        !(await this.hasReachedAttestationCap(slot, pid, committeeSize)))
-    );
-  }
-}
-
-/**
- * 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(
-  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  map: Map<SlotNumber, Map<string, Map<string, BlockAttestation>>>,
-  slot: SlotNumber,
-): 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)!;
-}