@aztec/p2p 0.0.1-commit.b655e406 → 0.0.1-commit.c0b82b2

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,253 +0,0 @@
-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';
-
-export class InMemoryAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<BlockAttestation>;
-
-  private attestations: Map</*slot=*/ bigint, 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: bigint): Promise<BlockAttestation[]> {
-    return Promise.resolve(
-      Array.from(this.attestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
-        Array.from(proposalAttestationMap.values()),
-      ),
-    );
-  }
-
-  public getAttestationsForSlotAndProposal(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 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.toBigInt()}`, {
-          signature: attestation.signature.toString(),
-          slotNumber,
-          proposalId,
-        });
-        continue;
-      }
-
-      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
-      const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-      proposalAttestationMap.set(sender.toString(), attestation);
-
-      this.log.verbose(`Added attestation for slot ${slotNumber.toBigInt()} from ${sender}`, {
-        signature: attestation.signature.toString(),
-        slotNumber,
-        address: sender,
-        proposalId,
-      });
-    }
-
-    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);
-    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: 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.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.toBigInt());
-      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.toBigInt()}`);
-            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.toBigInt());
-    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.toBigInt());
-    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));
-  }
-}
-
-/**
- * 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/tx_pool/memory_tx_pool.ts

@@ -1,283 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import type { TypedEventEmitter } from '@aztec/foundation/types';
-import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
-import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import EventEmitter from 'node:events';
-
-import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
-import { getPendingTxPriority } from './priority.js';
-import type { TxPool, TxPoolEvents, TxPoolOptions } from './tx_pool.js';
-
-/**
- * In-memory implementation of the Transaction Pool.
- */
-export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter<TxPoolEvents>) implements TxPool {
-  /**
-   * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
-   */
-  private txs: Map<bigint, Tx>;
-  private minedTxs: Map<bigint, number>;
-  private pendingTxs: Set<bigint>;
-  private deletedMinedTxHashes: Map<bigint, number>;
-  private blockToDeletedMinedTxHash: Map<number, Set<bigint>>;
-
-  private metrics: PoolInstrumentation<Tx>;
-
-  /**
-   * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
-   * @param log - A logger.
-   */
-  constructor(
-    telemetry: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('p2p:tx_pool'),
-  ) {
-    super();
-    this.txs = new Map<bigint, Tx>();
-    this.minedTxs = new Map();
-    this.pendingTxs = new Set();
-    this.deletedMinedTxHashes = new Map();
-    this.blockToDeletedMinedTxHash = new Map();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTx);
-  }
-
-  private countTx: PoolStatsCallback = () => {
-    return Promise.resolve({
-      itemCount: {
-        mined: this.minedTxs.size,
-        pending: this.pendingTxs.size,
-      },
-    });
-  };
-
-  public isEmpty(): Promise<boolean> {
-    return Promise.resolve(this.txs.size === 0);
-  }
-
-  public markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void> {
-    const keys = txHashes.map(x => x.toBigInt());
-    for (const key of keys) {
-      // If this tx was previously soft-deleted, remove it from the deleted sets
-      if (this.deletedMinedTxHashes.has(key)) {
-        const originalBlock = this.deletedMinedTxHashes.get(key)!;
-        this.deletedMinedTxHashes.delete(key);
-        // Remove from block-to-hash mapping
-        const txHashesForBlock = this.blockToDeletedMinedTxHash.get(originalBlock);
-        if (txHashesForBlock) {
-          txHashesForBlock.delete(key);
-          if (txHashesForBlock.size === 0) {
-            this.blockToDeletedMinedTxHash.delete(originalBlock);
-          }
-        }
-      }
-      this.minedTxs.set(key, blockHeader.globalVariables.blockNumber);
-      this.pendingTxs.delete(key);
-    }
-    return Promise.resolve();
-  }
-
-  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
-    if (txHashes.length === 0) {
-      return Promise.resolve();
-    }
-
-    const keys = txHashes.map(x => x.toBigInt());
-    for (const key of keys) {
-      this.minedTxs.delete(key);
-
-      // only add back to the pending set if we have the tx object
-      if (this.txs.has(key)) {
-        this.pendingTxs.add(key);
-      }
-    }
-
-    return Promise.resolve();
-  }
-
-  public async getPendingTxHashes(): Promise<TxHash[]> {
-    const txs = (await this.getAllTxs()).sort(
-      (tx1, tx2) => -getPendingTxPriority(tx1).localeCompare(getPendingTxPriority(tx2)),
-    );
-    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
-
-    // No need to check deleted since pending txs are never soft-deleted
-    return txHashes.filter(txHash => {
-      const key = txHash.toBigInt();
-      return this.pendingTxs.has(key);
-    });
-  }
-
-  public getMinedTxHashes(): Promise<[TxHash, number][]> {
-    return Promise.resolve(
-      Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]),
-    );
-  }
-
-  public getPendingTxCount(): Promise<number> {
-    // Soft-deleted transactions are always mined, never pending
-    return Promise.resolve(this.pendingTxs.size);
-  }
-
-  public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined> {
-    const key = txHash.toBigInt();
-
-    if (this.deletedMinedTxHashes.has(key)) {
-      return Promise.resolve('deleted');
-    }
-    if (this.minedTxs.has(key)) {
-      return Promise.resolve('mined');
-    }
-    if (this.pendingTxs.has(key)) {
-      return Promise.resolve('pending');
-    }
-    return Promise.resolve(undefined);
-  }
-
-  /**
-   * Checks if a transaction exists in the pool and returns it.
-   * @param txHash - The generated tx hash.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  public getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
-    const result = this.txs.get(txHash.toBigInt());
-    return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
-  }
-
-  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
-    return Promise.all(txHashes.map(txHash => this.getTxByHash(txHash)));
-  }
-  hasTxs(txHashes: TxHash[]): Promise<boolean[]> {
-    return Promise.resolve(txHashes.map(txHash => this.txs.has(txHash.toBigInt())));
-  }
-
-  async hasTx(txHash: TxHash): Promise<boolean> {
-    const result = await this.hasTxs([txHash]);
-    return result[0];
-  }
-
-  public getArchivedTxByHash(): Promise<Tx | undefined> {
-    return Promise.resolve(undefined);
-  }
-
-  /**
-   * Adds a list of transactions to the pool. Duplicates are ignored.
-   * @param txs - An array of txs to be added to the pool.
-   * @returns Empty promise.
-   */
-  public addTxs(txs: Tx[], opts: { source?: string } = {}): Promise<number> {
-    const added: Tx[] = [];
-    for (const tx of txs) {
-      const txHash = tx.getTxHash();
-      this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
-        eventName: 'tx-added-to-pool',
-        ...tx.getStats(),
-      } satisfies TxAddedToPoolStats);
-
-      const key = txHash.toBigInt();
-      if (!this.txs.has(key)) {
-        added.push(tx as Tx);
-        this.txs.set(key, tx);
-      }
-
-      if (!this.minedTxs.has(key)) {
-        this.metrics.recordSize(tx);
-        this.pendingTxs.add(key);
-      }
-    }
-    if (added.length > 0) {
-      this.emit('txs-added', { ...opts, txs: added });
-    }
-    return Promise.resolve(added.length);
-  }
-
-  /**
-   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
-   * Mined transactions are soft-deleted with a timestamp, pending transactions are permanently deleted.
-   * @param txHashes - An array of tx hashes to be deleted from the tx pool.
-   * @returns Empty promise.
-   */
-  public deleteTxs(txHashes: TxHash[], opts?: { permanently?: boolean }): Promise<void> {
-    for (const txHash of txHashes) {
-      const key = txHash.toBigInt();
-      if (this.txs.has(key)) {
-        if (this.minedTxs.has(key)) {
-          const blockNumber = this.minedTxs.get(key)!;
-          this.minedTxs.delete(key);
-          // Soft-delete mined transactions: remove from mined set but keep in storage
-          if (opts?.permanently) {
-            // Permanently delete mined transactions if specified
-            this.txs.delete(key);
-          } else {
-            this.deletedMinedTxHashes.set(key, blockNumber);
-            if (!this.blockToDeletedMinedTxHash.has(blockNumber)) {
-              this.blockToDeletedMinedTxHash.set(blockNumber, new Set());
-            }
-            this.blockToDeletedMinedTxHash.get(blockNumber)!.add(key);
-          }
-        } else {
-          // Permanently delete pending transactions
-          this.txs.delete(key);
-          this.pendingTxs.delete(key);
-        }
-      }
-    }
-
-    return Promise.resolve();
-  }
-
-  /**
-   * Gets all the transactions stored in the pool.
-   * @returns Array of tx objects in the order they were added to the pool.
-   */
-  public getAllTxs(): Promise<Tx[]> {
-    return Promise.resolve(Array.from(this.txs.values()).map(x => Tx.clone(x)));
-  }
-
-  /**
-   * Gets the hashes of all transactions currently in the tx pool.
-   * @returns An array of transaction hashes found in the tx pool.
-   */
-  public getAllTxHashes(): Promise<TxHash[]> {
-    return Promise.resolve(Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x)));
-  }
-
-  updateConfig(_config: TxPoolOptions): void {}
-
-  markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
-    return Promise.resolve();
-  }
-
-  /**
-   * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
-   * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
-   * @returns The number of transactions permanently deleted.
-   */
-  public cleanupDeletedMinedTxs(blockNumber: number): Promise<number> {
-    let deletedCount = 0;
-    const blocksToDelete: number[] = [];
-
-    // Find all blocks up to the specified block number
-    for (const [block, txHashes] of this.blockToDeletedMinedTxHash.entries()) {
-      if (block <= blockNumber) {
-        // Permanently delete all transactions from this block
-        for (const txHash of txHashes) {
-          this.txs.delete(txHash);
-          this.deletedMinedTxHashes.delete(txHash);
-          deletedCount++;
-        }
-        blocksToDelete.push(block);
-      }
-    }
-
-    // Clean up block-to-hash mapping
-    for (const block of blocksToDelete) {
-      this.blockToDeletedMinedTxHash.delete(block);
-    }
-
-    if (deletedCount > 0) {
-      this.log.debug(`Permanently deleted ${deletedCount} deleted mined txs from blocks up to ${blockNumber}`);
-    }
-    return Promise.resolve(deletedCount);
-  }
-}

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -1,81 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { NoCommitteeError } from '@aztec/ethereum';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-
-export class BlockProposalValidator implements P2PValidator<BlockProposal> {
-  private epochCache: EpochCacheInterface;
-  private logger: Logger;
-  private txsPermitted: boolean;
-
-  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
-    this.epochCache = epochCache;
-    this.txsPermitted = opts.txsPermitted;
-    this.logger = createLogger('p2p:block_proposal_validator');
-  }
-
-  async validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined> {
-    try {
-      // Check signature validity first - invalid signatures are a high-severity issue
-      const proposer = block.getSender();
-      if (!proposer) {
-        this.logger.debug(`Penalizing peer for block proposal with invalid signature`);
-        return PeerErrorSeverity.MidToleranceError;
-      }
-
-      // Check if transactions are permitted when the proposal contains transaction hashes
-      if (!this.txsPermitted && block.txHashes.length > 0) {
-        this.logger.debug(
-          `Penalizing peer for block proposal with ${block.txHashes.length} transaction(s) when transactions are not permitted`,
-        );
-        return PeerErrorSeverity.MidToleranceError;
-      }
-
-      const { currentProposer, nextProposer, currentSlot, nextSlot } =
-        await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
-
-      // Check that the attestation is for the current or next slot
-      const slotNumberBigInt = block.payload.header.slotNumber.toBigInt();
-      if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-        this.logger.debug(`Penalizing peer for invalid slot number ${slotNumberBigInt}`, { currentSlot, nextSlot });
-        return PeerErrorSeverity.HighToleranceError;
-      }
-
-      // Check that the block proposal is from the current or next proposer
-      if (slotNumberBigInt === currentSlot && currentProposer !== undefined && !proposer.equals(currentProposer)) {
-        this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumberBigInt}`, {
-          currentProposer,
-          nextProposer,
-          proposer: proposer.toString(),
-        });
-        return PeerErrorSeverity.MidToleranceError;
-      }
-
-      if (slotNumberBigInt === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
-        this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumberBigInt}`, {
-          currentProposer,
-          nextProposer,
-          proposer: proposer.toString(),
-        });
-        return PeerErrorSeverity.MidToleranceError;
-      }
-
-      // Validate tx hashes for all txs embedded in the proposal
-      if (!(await Promise.all(block.txs?.map(tx => tx.validateTxHash()) ?? [])).every(v => v)) {
-        this.logger.warn(`Penalizing peer for invalid tx hashes in block proposal`, {
-          proposer,
-          slotNumber: slotNumberBigInt,
-        });
-        return PeerErrorSeverity.LowToleranceError;
-      }
-
-      return undefined;
-    } catch (e) {
-      // People shouldn't be sending us block proposals if the committee doesn't exist
-      if (e instanceof NoCommitteeError) {
-        return PeerErrorSeverity.LowToleranceError;
-      }
-      throw e;
-    }
-  }
-}

package/src/msg_validators/block_proposal_validator/index.ts

@@ -1 +0,0 @@
-export * from './block_proposal_validator.js';