@aztec/p2p 0.0.1-commit.7d4e6cd → 0.0.1-commit.7ffbba4

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,264 +0,0 @@
-import type { SlotNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
-import type {
-  BlockProposal,
-  CheckpointAttestation,
-  CheckpointProposal,
-  CheckpointProposalCore,
-} 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';
-import { ATTESTATION_CAP_BUFFER, MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
-
-export class InMemoryAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<CheckpointAttestation>;
-
-  private proposals: Map<string, BlockProposal>;
-
-  // Checkpoint attestations
-  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  private checkpointAttestations: Map<
-    /*slot=*/ SlotNumber,
-    Map</*proposalId*/ string, Map</*address=*/ string, CheckpointAttestation>>
-  >;
-  private checkpointProposals: Map<string, CheckpointProposalCore>;
-
-  constructor(
-    telemetry: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('p2p:attestation_pool'),
-  ) {
-    this.proposals = new Map();
-    this.checkpointAttestations = new Map();
-    this.checkpointProposals = new Map();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
-  }
-
-  private poolStats: PoolStatsCallback = () => {
-    return Promise.resolve({
-      itemCount: this.checkpointAttestations.size,
-    });
-  };
-
-  public isEmpty(): Promise<boolean> {
-    return Promise.resolve(this.checkpointAttestations.size === 0 && this.proposals.size === 0);
-  }
-
-  public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
-    // Strip signedTxs before storing to avoid holding full tx data in memory
-    this.proposals.set(blockProposal.archive.toString(), blockProposal.withoutSignedTxs());
-    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.archive.toString();
-    return Promise.resolve(this.proposals.has(id));
-  }
-
-  public canAddProposal(_block: BlockProposal): Promise<boolean> {
-    // TODO(palla/mbps): See when to allow
-    return Promise.resolve(true);
-  }
-
-  // Checkpoint attestation methods
-
-  public async addCheckpointProposal(proposal: CheckpointProposal): Promise<void> {
-    if (!(await this.canAddCheckpointProposal(proposal))) {
-      throw new ProposalSlotCapExceededError(
-        `Maximum checkpoint proposals per slot reached: slot=${proposal.slotNumber} cap=${MAX_PROPOSALS_PER_SLOT} proposal=${proposal.archive.toString()}`,
-      );
-    }
-
-    // Extract and validate the block proposal if present
-    const blockProposal = proposal.getBlockProposal();
-    if (blockProposal && !(await this.canAddProposal(blockProposal))) {
-      throw new ProposalSlotCapExceededError(
-        `Maximum block proposals per slot reached when extracting from checkpoint: slot=${proposal.slotNumber} proposal=${blockProposal.archive.toString()}`,
-      );
-    }
-
-    const slotProposalMapping = getCheckpointSlotOrDefault(this.checkpointAttestations, proposal.slotNumber);
-    slotProposalMapping.set(proposal.archive.toString(), new Map<string, CheckpointAttestation>());
-
-    // Store the checkpoint proposal as core (without lastBlock) to avoid duplication
-    this.checkpointProposals.set(proposal.archive.toString(), proposal.toCore());
-
-    // Store the extracted block proposal separately
-    if (blockProposal) {
-      this.proposals.set(blockProposal.archive.toString(), blockProposal.withoutSignedTxs());
-    }
-
-    return Promise.resolve();
-  }
-
-  public getCheckpointProposal(id: string): Promise<CheckpointProposalCore | undefined> {
-    return Promise.resolve(this.checkpointProposals.get(id));
-  }
-
-  public hasCheckpointProposal(idOrProposal: string | CheckpointProposal): Promise<boolean> {
-    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
-    return Promise.resolve(this.checkpointProposals.has(id));
-  }
-
-  public addCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      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 checkpoint attestation with invalid signature for slot ${slotNumber}`, {
-          signature: attestation.signature.toString(),
-          slotNumber,
-          proposalId,
-        });
-        continue;
-      }
-
-      const slotAttestationMap = getCheckpointSlotOrDefault(this.checkpointAttestations, slotNumber);
-      const proposalAttestationMap = getCheckpointProposalOrDefault(slotAttestationMap, proposalId);
-      proposalAttestationMap.set(sender.toString(), attestation);
-
-      this.log.verbose(`Added checkpoint attestation for slot ${slotNumber} from ${sender}`, {
-        signature: attestation.signature.toString(),
-        slotNumber,
-        address: sender,
-        proposalId,
-      });
-    }
-
-    return Promise.resolve();
-  }
-
-  public getCheckpointAttestationsForSlot(slot: SlotNumber): Promise<CheckpointAttestation[]> {
-    return Promise.resolve(
-      Array.from(this.checkpointAttestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
-        Array.from(proposalAttestationMap.values()),
-      ),
-    );
-  }
-
-  public getCheckpointAttestationsForSlotAndProposal(
-    slot: SlotNumber,
-    proposalId: string,
-  ): Promise<CheckpointAttestation[]> {
-    const slotAttestationMap = this.checkpointAttestations.get(slot);
-    if (slotAttestationMap) {
-      const proposalAttestationMap = slotAttestationMap.get(proposalId);
-      if (proposalAttestationMap) {
-        return Promise.resolve(Array.from(proposalAttestationMap.values()));
-      }
-    }
-    return Promise.resolve([]);
-  }
-
-  public deleteCheckpointAttestationsOlderThan(oldestSlot: SlotNumber): Promise<void> {
-    const olderThan = [];
-
-    const slots = this.checkpointAttestations.keys();
-    for (const slot of slots) {
-      if (slot < oldestSlot) {
-        olderThan.push(slot);
-      } else {
-        break;
-      }
-    }
-
-    for (const oldSlot of olderThan) {
-      const proposalIds = this.checkpointAttestations.get(oldSlot)?.keys();
-      proposalIds?.forEach(proposalId => this.checkpointProposals.delete(proposalId));
-      this.checkpointAttestations.delete(oldSlot);
-    }
-    return Promise.resolve();
-  }
-
-  public hasReachedCheckpointProposalCap(slot: SlotNumber): Promise<boolean> {
-    const slotAttestationMap = this.checkpointAttestations.get(slot);
-    const proposalCount = slotAttestationMap?.size ?? 0;
-    return Promise.resolve(proposalCount >= MAX_PROPOSALS_PER_SLOT);
-  }
-
-  public hasReachedCheckpointAttestationCap(
-    slot: SlotNumber,
-    proposalId: string,
-    committeeSize: number,
-  ): Promise<boolean> {
-    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-    const count = this.checkpointAttestations.get(slot)?.get(proposalId)?.size ?? 0;
-    return Promise.resolve(limit <= 0 || count >= limit);
-  }
-
-  public async canAddCheckpointProposal(proposal: CheckpointProposal): Promise<boolean> {
-    return (
-      this.checkpointProposals.has(proposal.archive.toString()) ||
-      !(await this.hasReachedCheckpointProposalCap(proposal.slotNumber))
-    );
-  }
-
-  public async canAddCheckpointAttestation(
-    attestation: CheckpointAttestation,
-    committeeSize: number,
-  ): Promise<boolean> {
-    const sender = attestation.getSender();
-    const slot = attestation.payload.header.slotNumber;
-    const pid = attestation.archive.toString();
-    return (
-      !!sender &&
-      ((this.checkpointAttestations.get(slot)?.get(pid)?.has(sender.toString()) ?? false) ||
-        !(await this.hasReachedCheckpointAttestationCap(slot, pid, committeeSize)))
-    );
-  }
-
-  public hasCheckpointAttestation(attestation: CheckpointAttestation): 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.checkpointAttestations.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()));
-  }
-}
-
-// Checkpoint attestation helper functions
-
-function getCheckpointSlotOrDefault(
-  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  map: Map<SlotNumber, Map<string, Map<string, CheckpointAttestation>>>,
-  slot: SlotNumber,
-): Map<string, Map<string, CheckpointAttestation>> {
-  if (!map.has(slot)) {
-    map.set(slot, new Map<string, Map<string, CheckpointAttestation>>());
-  }
-  return map.get(slot)!;
-}
-
-function getCheckpointProposalOrDefault(
-  map: Map<string, Map<string, CheckpointAttestation>>,
-  proposalId: string,
-): Map<string, CheckpointAttestation> {
-  if (!map.has(proposalId)) {
-    map.set(proposalId, new Map<string, CheckpointAttestation>());
-  }
-  return map.get(proposalId)!;
-}

package/src/mem_pools/tx_pool/eviction/insufficient_fee_payer_balance_rule.ts

@@ -1,108 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { GasFees } from '@aztec/stdlib/gas';
-import type { ReadonlyWorldStateAccess } from '@aztec/stdlib/interfaces/server';
-import { DatabasePublicStateSource, type MerkleTreeReadOperations } from '@aztec/stdlib/trees';
-import type { TxHash } from '@aztec/stdlib/tx';
-
-import { GasTxValidator } from '../../../msg_validators/index.js';
-import type { TxPoolOptions } from '../tx_pool.js';
-import {
-  type EvictionContext,
-  EvictionEvent,
-  type EvictionResult,
-  type EvictionRule,
-  type PendingTxInfo,
-  type TxPoolOperations,
-} from './eviction_strategy.js';
-
-export class InsufficientFeePayerBalanceRule implements EvictionRule {
-  public readonly name = 'InsufficientFeePayerBalance';
-  public readonly reason = 'insufficient_fee_juice';
-
-  public constructor(private worldState: ReadonlyWorldStateAccess) {}
-
-  private log = createLogger('p2p:mempool:tx_pool:insufficient_fee_payer_balance_rule');
-
-  async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
-    try {
-      if (context.event === EvictionEvent.CHAIN_PRUNED) {
-        const affectedTxs = await txPool.getPendingTxInfos();
-        return this.evictTxs(affectedTxs, context.blockNumber, txPool);
-      }
-
-      if (context.event === EvictionEvent.BLOCK_MINED) {
-        const affectedTxs = await txPool.getPendingTxsWithFeePayer(context.minedFeePayers);
-
-        // TODO: fix this edge-case
-        // This can lead to a race condition if we are catching up in the p2p client.
-        // Let's say we have 3 txs for the same fee payer, which get mined in blocks 1, 2, 3.
-        // Tx1 consumes fee juice, tx2 increases it, tx3 consumes it again. We see block1 with tx1 first, run this rule, and evict tx3.
-        // But tx3 was valid (due to tx2) and mined on block3. And we have just removed from the mempool a tx we needed for proving/reexec.
-        // -----
-        // Proposed fix: evict only if node is synched
-        return this.evictTxs(affectedTxs, context.block.getBlockNumber(), txPool);
-      }
-
-      return {
-        reason: this.reason,
-        success: true,
-        txsEvicted: [],
-      };
-    } catch (err) {
-      this.log.error('Failed to evict invalid transactions after mining', { err });
-      return {
-        reason: this.reason,
-        success: false,
-        txsEvicted: [],
-        error: new Error('Failed to evict invalid txs after mining', { cause: err }),
-      };
-    }
-  }
-
-  private async evictTxs(
-    candidateTxs: PendingTxInfo[],
-    blockNumber: number,
-    txPool: TxPoolOperations,
-  ): Promise<EvictionResult> {
-    const txsToEvict: TxHash[] = [];
-    const gasValidator = this.createGasTxValidator(this.worldState.getSnapshot(blockNumber));
-
-    for (const { txHash, isEvictable } of candidateTxs) {
-      if (!isEvictable) {
-        continue;
-      }
-
-      const tx = await txPool.getTxByHash(txHash);
-      if (!tx) {
-        continue;
-      }
-
-      this.log.debug(`Validating tx balance ${txHash}`);
-
-      if ((await gasValidator.validateTxFee(tx)).result === 'invalid') {
-        this.log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
-        txsToEvict.push(txHash);
-        continue;
-      }
-    }
-
-    if (txsToEvict.length > 0) {
-      await txPool.deleteTxs(txsToEvict);
-    }
-
-    this.log.verbose(`Evicted ${txsToEvict.length} invalid txs after block mined`, { txsToEvict });
-
-    return {
-      reason: this.reason,
-      success: true,
-      txsEvicted: txsToEvict,
-    };
-  }
-
-  private createGasTxValidator(db: MerkleTreeReadOperations): GasTxValidator {
-    return new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, GasFees.empty());
-  }
-
-  updateConfig(_config: TxPoolOptions): void {}
-}

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -1,206 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type BlockProposal, type CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-import type { TxHash } from '@aztec/stdlib/tx';
-
-import type { MockProxy } from 'jest-mock-extended';
-
-export interface ProposalValidatorTestParams<TProposal extends BlockProposal | CheckpointProposal> {
-  validatorFactory: (
-    epochCache: EpochCacheInterface,
-    opts: { txsPermitted: boolean },
-  ) => { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
-  makeProposal: (options?: any) => Promise<TProposal>;
-  makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
-  getSigner: () => Secp256k1Signer;
-  getAddress: (signer?: Secp256k1Signer) => EthAddress;
-  getSlot: (slot: number | bigint) => any;
-  getTxHashes: (n: number) => TxHash[];
-  getTxs: () => any[];
-  epochCacheMock: () => MockProxy<EpochCacheInterface>;
-}
-
-export function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(
-  params: ProposalValidatorTestParams<TProposal>,
-) {
-  const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } =
-    params;
-
-  describe('shared proposal validation logic', () => {
-    let epochCache: MockProxy<EpochCacheInterface>;
-    let validator: { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
-
-    beforeEach(() => {
-      epochCache = epochCacheMock();
-      validator = validatorFactory(epochCache, { txsPermitted: true });
-    });
-
-    it('returns high tolerance error if slot number is not current or next slot', async () => {
-      const header = makeHeader(1, 97, 97);
-      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(98),
-        nextSlot: getSlot(99),
-        currentProposer: getAddress(),
-        nextProposer: getAddress(),
-      });
-      const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.HighToleranceError);
-    });
-
-    it('returns mid tolerance error if proposer is not current proposer for current slot', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const invalidProposer = getSigner();
-      const header = makeHeader(1, 100, 100);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: invalidProposer,
-      });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
-      const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-    });
-
-    it('returns mid tolerance error if proposer is not next proposer for next slot', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const invalidProposer = getSigner();
-      const header = makeHeader(1, 101, 101);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: invalidProposer,
-      });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
-      const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-    });
-
-    it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const header = makeHeader(1, 101, 101);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: currentProposer,
-      });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
-      const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-    });
-
-    it('returns undefined if proposal is valid for current slot and proposer', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const header = makeHeader(1, 100, 100);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: currentProposer,
-      });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
-      const result = await validator.validate(mockProposal);
-      expect(result).toBeUndefined();
-    });
-
-    it('returns undefined if proposal is valid for next slot and proposer', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const header = makeHeader(1, 101, 101);
-      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header, signer: nextProposer });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
-      const result = await validator.validate(mockProposal);
-      expect(result).toBeUndefined();
-    });
-
-    describe('transaction permission validation', () => {
-      it('returns mid tolerance error if txs not permitted and proposal contains txHashes', async () => {
-        const currentProposer = getSigner();
-        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
-        const header = makeHeader(1, 100, 100);
-        const mockProposal = await makeProposal({
-          blockHeader: header,
-          lastBlockHeader: header,
-          signer: currentProposer,
-          txHashes: getTxHashes(2),
-        });
-        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-          currentSlot: getSlot(100),
-          nextSlot: getSlot(101),
-          currentProposer: getAddress(currentProposer),
-          nextProposer: getAddress(),
-        });
-        const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-      });
-
-      it('returns undefined if txs not permitted but proposal has no txHashes', async () => {
-        const currentProposer = getSigner();
-        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
-        const header = makeHeader(1, 100, 100);
-        const mockProposal = await makeProposal({
-          blockHeader: header,
-          lastBlockHeader: header,
-          signer: currentProposer,
-          txHashes: getTxHashes(0),
-        });
-        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-          currentSlot: getSlot(100),
-          nextSlot: getSlot(101),
-          currentProposer: getAddress(currentProposer),
-          nextProposer: getAddress(),
-        });
-        const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toBeUndefined();
-      });
-
-      it('returns undefined if txs permitted and proposal contains txHashes', async () => {
-        const currentProposer = getSigner();
-        const header = makeHeader(1, 100, 100);
-        const mockProposal = await makeProposal({
-          blockHeader: header,
-          lastBlockHeader: header,
-          signer: currentProposer,
-          txHashes: getTxHashes(2),
-        });
-        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-          currentSlot: getSlot(100),
-          nextSlot: getSlot(101),
-          currentProposer: getAddress(currentProposer),
-          nextProposer: getAddress(),
-        });
-        const result = await validator.validate(mockProposal);
-        expect(result).toBeUndefined();
-      });
-    });
-  });
-}