@aztec/p2p 0.0.1-commit.2ed92850 → 0.0.1-commit.3100065

package/src/msg_validators/clock_tolerance.ts

@@ -1,51 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-
-/**
- * Maximum clock disparity tolerance for P2P message validation (in milliseconds).
- * Messages for the previous slot are accepted if we're within this many milliseconds
- * of the current slot start. This prevents penalizing peers for messages that
- * were valid when sent but arrived slightly late due to network latency.
- *
- * This follows Ethereum's MAXIMUM_GOSSIP_CLOCK_DISPARITY approach.
- */
-export const MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS = 500;
-
-/**
- * Checks if a message for the previous slot should be accepted due to clock tolerance.
- *
- * @param messageSlot - The slot number from the received message
- * @param currentSlot - The current slot number
- * @param epochCache - EpochCache to get timing information
- * @returns true if the message is for the previous slot AND we're within the clock tolerance window
- */
-export function isWithinClockTolerance(
-  messageSlot: SlotNumber,
-  currentSlot: SlotNumber,
-  epochCache: EpochCacheInterface,
-): boolean {
-  // Guard against slot 0 edge case (genesis)
-  if (currentSlot === SlotNumber.ZERO) {
-    return false;
-  }
-
-  // Only apply tolerance to messages for the previous slot
-  const previousSlot = SlotNumber(currentSlot - 1);
-  if (messageSlot !== previousSlot) {
-    return false;
-  }
-
-  // Check how far we are into the current slot (in milliseconds)
-  const { ts: slotStartTs, nowMs, slot } = epochCache.getEpochAndSlotNow();
-
-  // Sanity check: ensure the epoch cache's current slot matches the expected current slot
-  if (slot !== currentSlot) {
-    return false;
-  }
-
-  // ts is in seconds, convert to ms; nowMs is already in milliseconds
-  const slotStartMs = slotStartTs * 1000n;
-  const elapsedMs = Number(nowMs - slotStartMs);
-
-  return elapsedMs < MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS;
-}

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -1,230 +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,
-  type ValidationResult,
-} 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<ValidationResult> };
-  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<ValidationResult> };
-    const previousSlot = getSlot(99);
-    const currentSlot = getSlot(100);
-    const nextSlot = getSlot(101);
-
-    function mockGetProposer(currentProposer: EthAddress, nextProposer: EthAddress, previousProposer?: EthAddress) {
-      epochCache.getProposerAttesterAddressInSlot.mockImplementation(slot => {
-        if (slot === currentSlot) {
-          return Promise.resolve(currentProposer);
-        }
-        if (slot === nextSlot) {
-          return Promise.resolve(nextProposer);
-        }
-        if (slot === previousSlot && previousProposer) {
-          return Promise.resolve(previousProposer);
-        }
-        throw new Error('Unexpected argument');
-      });
-    }
-
-    beforeEach(() => {
-      epochCache = epochCacheMock();
-      validator = validatorFactory(epochCache, { txsPermitted: true });
-      epochCache.getCurrentAndNextSlot.mockReturnValue({
-        currentSlot: currentSlot,
-        nextSlot: nextSlot,
-      });
-    });
-
-    it('returns high tolerance error if slot number is not current or next slot (outside clock tolerance)', async () => {
-      const header = makeHeader(1, 99, 99);
-      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
-
-      // Mock getEpochAndSlotNow to return time OUTSIDE clock tolerance (1000ms elapsed)
-      epochCache.getEpochAndSlotNow.mockReturnValue({
-        epoch: 1 as any,
-        slot: currentSlot,
-        ts: 1000n, // slot started at 1000 seconds
-        nowMs: 1001000n, // 1000ms elapsed, outside 500ms tolerance
-      });
-
-      epochCache.getProposerAttesterAddressInSlot.mockResolvedValue(getAddress());
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.HighToleranceError });
-
-      // Should not try to resolve proposers if base validation fails
-      expect(epochCache.getProposerAttesterAddressInSlot).not.toHaveBeenCalled();
-    });
-
-    it('returns ignore if previous slot proposal is within clock tolerance', async () => {
-      const previousProposer = getSigner();
-      const header = makeHeader(1, 99, 99);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: previousProposer,
-      });
-
-      // Mock getEpochAndSlotNow to return time WITHIN clock tolerance (100ms elapsed)
-      epochCache.getEpochAndSlotNow.mockReturnValue({
-        epoch: 1 as any,
-        slot: currentSlot,
-        ts: 1000n, // slot started at 1000 seconds
-        nowMs: 1000100n, // 100ms elapsed, within 500ms tolerance
-      });
-
-      mockGetProposer(getAddress(), getAddress(), getAddress(previousProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'ignore' });
-    });
-
-    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,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: 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,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: 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,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: 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,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'accept' });
-    });
-
-    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 });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'accept' });
-    });
-
-    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),
-        });
-
-        mockGetProposer(getAddress(currentProposer), getAddress());
-        const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toEqual({ result: 'reject', severity: 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),
-        });
-
-        mockGetProposer(getAddress(currentProposer), getAddress());
-        const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toEqual({ result: 'accept' });
-      });
-
-      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),
-        });
-
-        mockGetProposer(getAddress(currentProposer), getAddress());
-        const result = await validator.validate(mockProposal);
-        expect(result).toEqual({ result: 'accept' });
-      });
-    });
-  });
-}

package/src/services/reqresp/connection-sampler/batch_connection_sampler.ts

@@ -1,100 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-
-import type { PeerId } from '@libp2p/interface';
-
-import type { ConnectionSampler } from './connection_sampler.js';
-
-/**
- * Manages batches of peers for parallel request processing.
- * Tracks active peers and provides deterministic peer assignment for requests.
- *
- * Example with 3 peers and 10 requests:
- *
- * Peers:    [P1]      [P2]     [P3]
- *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
- * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
- *
- * Each peer handles a bucket of consecutive requests.
- * If a peer fails, it is replaced while maintaining the same bucket.
- */
-export class BatchConnectionSampler {
-  private readonly batch: PeerId[] = [];
-  private readonly requestsPerPeer: number;
-
-  constructor(
-    private readonly connectionSampler: ConnectionSampler,
-    batchSize: number,
-    maxPeers: number,
-    exclude?: PeerId[],
-    private readonly logger = createLogger('p2p:reqresp:batch-connection-sampler'),
-  ) {
-    if (maxPeers <= 0) {
-      throw new Error('Max peers cannot be 0');
-    }
-    if (batchSize <= 0) {
-      throw new Error('Batch size cannot be 0');
-    }
-
-    // Calculate how many requests each peer should handle, cannot be 0
-    this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
-
-    // Sample initial peers
-    const excluding = exclude && new Map(exclude.map(peerId => [peerId.toString(), true] as const));
-    this.batch = this.connectionSampler.samplePeersBatch(maxPeers, excluding);
-  }
-
-  /**
-   * Gets the peer responsible for handling a specific request index
-   *
-   * @param index - The request index
-   * @returns The peer assigned to handle this request
-   */
-  getPeerForRequest(index: number): PeerId | undefined {
-    if (this.batch.length === 0) {
-      return undefined;
-    }
-
-    // Calculate which peer bucket this index belongs to
-    const peerIndex = Math.floor(index / this.requestsPerPeer) % this.batch.length;
-    return this.batch[peerIndex];
-  }
-
-  /**
-   * Removes a peer and replaces it with a new one, maintaining the same position
-   * in the batch array to keep request distribution consistent
-   *
-   * @param peerId - The peer to remove and replace
-   */
-  removePeerAndReplace(peerId: PeerId): void {
-    const index = this.batch.findIndex(p => p === peerId);
-    if (index === -1) {
-      return;
-    }
-
-    const excluding = new Map([[peerId.toString(), true]]);
-    const newPeer = this.connectionSampler.getPeer(excluding); // Q: Shouldn't we accumulate all excluded peers? Otherwise the sampler could return us a previously excluded peer?
-
-    if (newPeer) {
-      this.batch[index] = newPeer;
-      this.logger.trace('Replaced peer', { peerId, newPeer });
-    } else {
-      // If we couldn't get a replacement, remove the peer and compact the array
-      this.batch.splice(index, 1);
-      this.logger.trace('Removed peer', { peerId });
-    }
-  }
-
-  /**
-   * Gets the number of active peers
-   */
-  get activePeerCount(): number {
-    return this.batch.length;
-  }
-
-  /**
-   * Gets the number of requests each peer is assigned to handle
-   */
-  get requestsPerBucket(): number {
-    return this.requestsPerPeer;
-  }
-}

package/src/services/reqresp/protocols/block.ts

@@ -1,37 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-
-import type { PeerId } from '@libp2p/interface';
-
-import type { ReqRespSubProtocolHandler } from '../interface.js';
-import { ReqRespStatus, ReqRespStatusError } from '../status.js';
-
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */
-export function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler {
-  /**
-   * @param peerId - the peer ID of the requester
-   * @param msg - the block request message, which is expected to contain valid block number as a Buffer
-   * @returns a Buffer containing the requested block data, or an empty Buffer if the block is not found
-   * @throws  ReqRespStatusError if the input msg is not a valid block number
-   * */
-  return async (_peerId: PeerId, msg: Buffer) => {
-    let blockNumber: Fr;
-    try {
-      blockNumber = Fr.fromBuffer(msg);
-    } catch (err: any) {
-      throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
-    }
-
-    try {
-      const foundBlock = await l2BlockSource.getBlock(BlockNumber(Number(blockNumber)));
-      return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
-    } catch (err: any) {
-      throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, { cause: err });
-    }
-  };
-}