@aztec-labs/p2p 6.0.0-rc.3 → 6.0.0-rc.4

package/src/services/peer-manager/peer_scoring.ts

@@ -56,6 +56,12 @@ const MIN_SCORE_BEFORE_BAN = -100;
 const MIN_SCORE_BEFORE_DISCONNECT = -50;
 const SCORE_CLEANUP_THRESHOLD = 0.1;
 
+// Upper bounds on retained scoring state so a remote peer churning throwaway identities cannot grow the
+// heartbeat-scanned maps without limit. Both sit far above any healthy non-connected count (maxPeerCount
+// defaults to 100). Over the cap, the least-recently-updated score and the earliest-expiring ban are evicted.
+const MAX_RETAINED_SCORED_PEERS = 4096;
+const MAX_RETAINED_BANS = 4096;
+
 /** An active ban: the score the peer held when banned, and the timestamp at which the ban lifts. */
 type BanRecord = { score: number; expiry: number };
 
@@ -123,8 +129,13 @@ export class PeerScoring {
     // Apply new score delta
     currentScore += scoreDelta;
 
+    // Re-insert so the most recently updated peer moves to the end of iteration order; the first entry is
+    // then the least-recently-updated (most-decayed) peer, which is the one evicted when over the cap.
+    this.scores.delete(peerId);
+    this.lastUpdateTime.delete(peerId);
     this.scores.set(peerId, currentScore);
     this.lastUpdateTime.set(peerId, currentTime);
+    this.evictLeastRecentScoreIfOverCap(peerId);
 
     this.maybeBanPeer(peerId, currentScore);
 
@@ -143,6 +154,7 @@ export class PeerScoring {
     }
     const record: BanRecord = { score, expiry: this.dateProvider.now() + this.banDurationMs };
     this.bannedPeers.set(peerId, record);
+    this.evictEarliestBanIfOverCap(peerId);
     this.logger.verbose(`Banning peer ${peerId} until ${new Date(record.expiry).toISOString()}`, {
       peerId,
       score,
@@ -194,6 +206,37 @@ export class PeerScoring {
     this.lastUpdateTime.delete(peerId);
   }
 
+  /**
+   * Bounds the score maps. When retention exceeds MAX_RETAINED_SCORED_PEERS, drops the least-recently-updated
+   * peer (front of iteration order) - its score has decayed longest and is closest to healthy - never the peer
+   * just updated. Keeps a reconnecting recent offender's penalty while capping churn-driven growth.
+   */
+  private evictLeastRecentScoreIfOverCap(keep: string): void {
+    while (this.scores.size > MAX_RETAINED_SCORED_PEERS) {
+      const oldest = this.scores.keys().next().value;
+      if (oldest === undefined || oldest === keep) {
+        break;
+      }
+      this.scores.delete(oldest);
+      this.lastUpdateTime.delete(oldest);
+    }
+  }
+
+  /**
+   * Bounds the ban map. Bans share a fixed duration, so insertion order is expiry order; when over
+   * MAX_RETAINED_BANS the first entry is the earliest-expiring, so dropping it lifts the ban closest to
+   * expiring rather than letting identity churn grow the map without limit.
+   */
+  private evictEarliestBanIfOverCap(keep: string): void {
+    while (this.bannedPeers.size > MAX_RETAINED_BANS) {
+      const earliest = this.bannedPeers.keys().next().value;
+      if (earliest === undefined || earliest === keep) {
+        break;
+      }
+      this.bannedPeers.delete(earliest);
+    }
+  }
+
   /**
    * The single source of truth for whether a peer is banned. Returns the ban score while the ban is
    * active, or undefined if the peer is not banned. A ban that has expired is lazily lifted before

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

@@ -3,6 +3,7 @@ import { keccak256 } from '@aztec-labs/foundation/crypto/keccak';
 import { Fr } from '@aztec-labs/foundation/curves/bn254';
 import { Signature } from '@aztec-labs/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { Buffer } from 'buffer';
 
 import { StatusMessage } from './status.js';
 

package/src/services/reqresp/protocols/block_txs/bitvector.ts

@@ -1,4 +1,5 @@
 import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { Buffer } from 'buffer';
 
 import { MAX_TXS_PER_BLOCK } from '../../constants.js';
 

package/src/services/reqresp/protocols/block_txs/block_txs_handler.ts

@@ -35,10 +35,15 @@ export function reqRespBlockTxsHandler(
       throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
     }
 
-    // The explicit-hash fallback is served even when the block is not found, so bound it:
-    // otherwise a peer could name many hashes (with an empty bit list) and force
-    // one response to serialize a full tx per hash.
-    if (request.txHashes.length > MAX_BLOCK_TXS_PER_REQUEST) {
+    // Cheap early bound before any attestation-pool / archiver / tx-pool work: reject when the
+    // explicit-hash list, or the number of requested indices, already exceeds the per-request cap on
+    // its own. The index bitvector has no duplicate positions, so its set-bit count is a lower bound
+    // on the served set; the explicit-hash list is bounded as it was before. The deduplicated
+    // served-set cap below stays the authoritative gate for the dual-form (index + explicit) overlap.
+    if (
+      request.txHashes.length > MAX_BLOCK_TXS_PER_REQUEST ||
+      request.txIndices.getTrueIndices().length > MAX_BLOCK_TXS_PER_REQUEST
+    ) {
       throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST);
     }
 
@@ -75,6 +80,14 @@ export function reqRespBlockTxsHandler(
       }
     }
 
+    // One response is capped at MAX_BLOCK_TXS_PER_REQUEST transactions. Both request forms feed one
+    // deduplicated set - the dumb-peer requester sends the same txs by index and by explicit hash -
+    // so cap the deduplicated served count, not the raw sum, before fetching and serializing. This
+    // bounds the work one peer can drive while still accepting a legitimate dual-form batch.
+    if (requestedTxsHashes.size > MAX_BLOCK_TXS_PER_REQUEST) {
+      throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST);
+    }
+
     // Finally, get the txs from the pool and create the response.
     const responseTxs = (
       await txPool.getTxsByHash(Array.from(requestedTxsHashes).map(h => TxHash.fromString(h)))

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

@@ -1,5 +1,6 @@
 import { createLogger } from '@aztec-labs/foundation/log';
 import type { PeerId } from '@libp2p/interface';
+import { Buffer } from 'buffer';
 
 import type { PeerManagerInterface } from '../../peer-manager/interface.js';
 import { ReqRespSubProtocol, type ReqRespSubProtocolHandler } from '../interface.js';

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

@@ -1,3 +1,5 @@
+import { Buffer } from 'buffer';
+
 /**
  * Handles the ping request.
  * @param _msg - The ping request message.

package/src/services/reqresp/reqresp.ts

@@ -5,6 +5,7 @@ import { executeTimeout } from '@aztec-labs/foundation/timer';
 import { PeerErrorSeverity } from '@aztec-labs/stdlib/p2p';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec-labs/telemetry-client';
 import type { IncomingStreamData, PeerId, Stream } from '@libp2p/interface';
+import { Buffer } from 'buffer';
 import type { Libp2p } from 'libp2p';
 import { pipeline } from 'node:stream/promises';
 import type { Uint8ArrayList } from 'uint8arraylist';

package/src/test-helpers/mock-pubsub.ts

@@ -17,6 +17,7 @@ import {
   TypedEventEmitter,
 } from '@libp2p/interface';
 import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+import { Buffer } from 'buffer';
 
 import type { P2PConfig } from '../config.js';
 import type { MemPools } from '../mem_pools/interface.js';

package/src/test-helpers/reqresp-nodes.ts

@@ -26,6 +26,7 @@ import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { multiaddr } from '@multiformats/multiaddr';
 import { SignableENR } from '@nethermindeth/enr';
+import { Buffer } from 'buffer';
 import getPort from 'get-port';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 

package/src/test-helpers/testbench-utils.ts

@@ -308,7 +308,7 @@ export class InMemoryAttestationPool {
  */
 export function createMockEpochCache(): EpochCacheInterface {
   const cache: EpochCacheInterface = {
-    getCommittee: () => Promise.resolve({ committee: [], seed: 1n, epoch: EpochNumber.ZERO, isEscapeHatchOpen: false }),
+    getCommittee: () => Promise.resolve({ state: 'open', seed: 1n, epoch: EpochNumber.ZERO, isEscapeHatchOpen: false }),
     getProposerIndexEncoding: () => '0x' as `0x${string}`,
     getSlotNow: () => SlotNumber.ZERO,
     getTargetSlot: () => SlotNumber.ZERO,
@@ -323,7 +323,7 @@ export function createMockEpochCache(): EpochCacheInterface {
     computeProposerIndex: () => 0n,
     getCurrentAndNextSlot: () => ({ currentSlot: SlotNumber.ZERO, nextSlot: SlotNumber.ZERO }),
     getTargetAndNextSlot: () => ({ targetSlot: SlotNumber.ZERO, nextSlot: SlotNumber.ZERO }),
-    getProposerAttesterAddressInSlot: () => Promise.resolve(undefined),
+    lookupProposer: () => Promise.resolve({ state: 'open' }),
     getEpochAndSlotInNextL1Slot: () => ({
       epoch: EpochNumber.ZERO,
       slot: SlotNumber.ZERO,
@@ -336,11 +336,11 @@ export function createMockEpochCache(): EpochCacheInterface {
       ts: 0n,
       nowSeconds: 0n,
     }),
-    isInCommittee: () => Promise.resolve(false),
+    lookupMembership: () => Promise.resolve({ state: 'open' }),
     getRegisteredValidators: () => Promise.resolve([]),
-    filterInCommittee: () => Promise.resolve([]),
-    isEscapeHatchOpen: () => Promise.resolve(false),
-    isEscapeHatchOpenAtSlot: () => Promise.resolve(false),
+    filterInCommittee: () => Promise.resolve({ state: 'open' }),
+    lookupEscapeHatch: () => Promise.resolve({ state: 'open', isEscapeHatchOpen: false }),
+    lookupEscapeHatchAtSlot: () => Promise.resolve({ state: 'open', isEscapeHatchOpen: false }),
     getL1Constants: () => ({
       l1StartBlock: 0n,
       l1GenesisTime: 0n,

package/src/testbench/p2p_client_testbench_worker.ts

@@ -29,6 +29,7 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec-labs/telemetry-
 import type { Message, PeerId } from '@libp2p/interface';
 import { TopicValidatorResult } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
+import { Buffer } from 'buffer';
 
 import type { P2PClient } from '../client/index.js';
 import type { P2PConfig } from '../config.js';

package/src/testbench/worker_client_manager.ts

@@ -1,3 +1,4 @@
+import { getEnv } from '@aztec-labs/foundation/config/env';
 import { EthAddress } from '@aztec-labs/foundation/eth-address';
 import type { Logger } from '@aztec-labs/foundation/log';
 import { retryUntil } from '@aztec-labs/foundation/retry';
@@ -115,7 +116,7 @@ class WorkerClientManager {
     }
 
     const env = {
-      ...process.env,
+      ...getEnv(),
       TS_NODE_PROJECT: tsconfigPath,
     };
 

package/src/util.ts

@@ -8,6 +8,7 @@ import type { Identify } from '@libp2p/identify';
 import type { PeerId, PrivateKey } from '@libp2p/interface';
 import type { AddressManager, ConnectionManager } from '@libp2p/interface-internal';
 import { createFromPrivKey } from '@libp2p/peer-id-factory';
+import { Buffer } from 'buffer';
 import { resolve } from 'dns/promises';
 import { promises as fs } from 'fs';
 import type { Libp2p } from 'libp2p';

package/src/versioning.ts

@@ -3,6 +3,7 @@ import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
 import type { ChainConfig } from '@aztec-labs/stdlib/config';
 import { compressComponentVersions, getComponentsVersionsFromConfig } from '@aztec-labs/stdlib/versioning';
 import type { SignableENR } from '@nethermindeth/enr';
+import { Buffer } from 'buffer';
 
 import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from './types/index.js';