@aztec/p2p 0.76.4 → 0.77.0-testnet-ignition.21

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

@@ -1,10 +1,10 @@
 import { createLogger } from '@aztec/foundation/log';
 
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 
-import { type PeerManager } from '../../peer-manager/peer_manager.js';
+import type { PeerManager } from '../../peer-manager/peer_manager.js';
 import { ReqRespSubProtocol, type ReqRespSubProtocolHandler } from '../interface.js';
-import { type ReqResp } from '../reqresp.js';
+import type { ReqResp } from '../reqresp.js';
 
 /**
  * Enum defining the possible reasons for a goodbye message.
@@ -12,8 +12,8 @@ import { type ReqResp } from '../reqresp.js';
 export enum GoodByeReason {
   /** The peer has shutdown, will be received whenever a peer's node is routinely stopped */
   SHUTDOWN = 0x1,
-  /** Whenever the peer must disconnect due to maintaining max peers */
-  DISCONNECTED = 0x2,
+  /** The max peer count has been reached, will be received whenever a low scoring peer is disconnected to satisfy the max peer count */
+  MAX_PEERS = 0x2,
   /** The peer has a low score, will be received whenever a peer's score is low */
   LOW_SCORE = 0x3,
   /** The peer has been banned, will be received whenever a peer is banned */
@@ -48,8 +48,8 @@ export function prettyGoodbyeReason(reason: GoodByeReason): string {
   switch (reason) {
     case GoodByeReason.SHUTDOWN:
       return 'shutdown';
-    case GoodByeReason.DISCONNECTED:
-      return 'disconnected';
+    case GoodByeReason.MAX_PEERS:
+      return 'max_peers';
     case GoodByeReason.LOW_SCORE:
       return 'low_score';
     case GoodByeReason.BANNED:

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

@@ -1,10 +1,10 @@
-import { type P2PClientType } from '@aztec/circuit-types';
-import { TxHash } from '@aztec/circuit-types/tx_hash';
+import type { P2PClientType } from '@aztec/stdlib/p2p';
+import { TxHash } from '@aztec/stdlib/tx';
 
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 
-import { type MemPools } from '../../../mem_pools/interface.js';
-import { type ReqRespSubProtocolHandler } from '../interface.js';
+import type { MemPools } from '../../../mem_pools/interface.js';
+import type { ReqRespSubProtocolHandler } from '../interface.js';
 
 /**
  * We want to keep the logic of the req resp handler in this file, but we do not have a reference to the mempools here

package/src/services/reqresp/rate-limiter/rate_limiter.ts

@@ -3,12 +3,12 @@
  * Rationale is that if it was good enough for them, then it should be good enough for us.
  * https://github.com/ChainSafe/lodestar
  */
-import { PeerErrorSeverity } from '@aztec/circuit-types';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 
-import { type PeerScoring } from '../../peer-manager/peer_scoring.js';
-import { type ReqRespSubProtocol, type ReqRespSubProtocolRateLimits } from '../interface.js';
+import type { PeerScoring } from '../../peer-manager/peer_scoring.js';
+import type { ReqRespSubProtocol, ReqRespSubProtocolRateLimits } from '../interface.js';
 import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
 
 // Check for disconnected peers every 10 minutes
@@ -72,10 +72,21 @@ interface PeerRateLimiter {
   lastAccess: number;
 }
 
-enum RateLimitStatus {
-  Allowed,
+export enum RateLimitStatus {
   DeniedGlobal,
   DeniedPeer,
+  Allowed, // Note: allowed last to prevent enum evaluating to 0 for success
+}
+
+export function prettyPrintRateLimitStatus(status: RateLimitStatus) {
+  switch (status) {
+    case RateLimitStatus.DeniedGlobal:
+      return 'DeniedGlobal';
+    case RateLimitStatus.DeniedPeer:
+      return 'DeniedPeer';
+    case RateLimitStatus.Allowed:
+      return 'Allowed';
+  }
 }
 
 /**
@@ -191,24 +202,17 @@ export class RequestResponseRateLimiter {
     }, CHECK_DISCONNECTED_PEERS_INTERVAL_MS);
   }
 
-  allow(subProtocol: ReqRespSubProtocol, peerId: PeerId): boolean {
+  allow(subProtocol: ReqRespSubProtocol, peerId: PeerId): RateLimitStatus {
     const limiter = this.subProtocolRateLimiters.get(subProtocol);
     if (!limiter) {
-      return true;
+      return RateLimitStatus.Allowed;
     }
     const rateLimitStatus = limiter.allow(peerId);
 
-    switch (rateLimitStatus) {
-      case RateLimitStatus.DeniedPeer:
-        // Hitting a peer specific limit, we should lightly penalise the peer
-        this.peerScoring.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
-        return false;
-      case RateLimitStatus.DeniedGlobal:
-        // Hitting a global limit, we should not penalise the peer
-        return false;
-      default:
-        return true;
+    if (rateLimitStatus === RateLimitStatus.DeniedPeer) {
+      this.peerScoring.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
     }
+    return rateLimitStatus;
   }
 
   cleanupInactivePeers() {

package/src/services/reqresp/reqresp.ts

@@ -1,13 +1,13 @@
 // @attribution: lodestar impl for inspiration
-import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { executeTimeout } from '@aztec/foundation/timer';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import { type IncomingStreamData, type PeerId, type Stream } from '@libp2p/interface';
+import type { IncomingStreamData, PeerId, Stream } from '@libp2p/interface';
 import { pipe } from 'it-pipe';
-import { type Libp2p } from 'libp2p';
-import { type Uint8ArrayList } from 'uint8arraylist';
+import type { Libp2p } from 'libp2p';
+import type { Uint8ArrayList } from 'uint8arraylist';
 
 import {
   CollectiveReqRespTimeoutError,
@@ -15,8 +15,8 @@ import {
   InvalidResponseError,
 } from '../../errors/reqresp.error.js';
 import { SnappyTransform } from '../encoding.js';
-import { type PeerScoring } from '../peer-manager/peer_scoring.js';
-import { type P2PReqRespConfig } from './config.js';
+import type { PeerScoring } from '../peer-manager/peer_scoring.js';
+import type { P2PReqRespConfig } from './config.js';
 import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
 import { ConnectionSampler } from './connection-sampler/connection_sampler.js';
 import {
@@ -30,7 +30,11 @@ import {
   subProtocolMap,
 } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
-import { RequestResponseRateLimiter } from './rate-limiter/rate_limiter.js';
+import {
+  RateLimitStatus,
+  RequestResponseRateLimiter,
+  prettyPrintRateLimitStatus,
+} from './rate-limiter/rate_limiter.js';
 import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.js';
 
 /**
@@ -589,8 +593,13 @@ export class ReqResp {
 
     try {
       // Store a reference to from this for the async generator
-      if (!this.rateLimiter.allow(protocol, connection.remotePeer)) {
-        this.logger.warn(`Rate limit exceeded for ${protocol} from ${connection.remotePeer}`);
+      const rateLimitStatus = this.rateLimiter.allow(protocol, connection.remotePeer);
+      if (rateLimitStatus != RateLimitStatus.Allowed) {
+        this.logger.warn(
+          `Rate limit exceeded ${prettyPrintRateLimitStatus(rateLimitStatus)} for ${protocol} from ${
+            connection.remotePeer
+          }`,
+        );
 
         throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
       }
@@ -598,8 +607,6 @@ export class ReqResp {
       const handler = this.subProtocolHandlers[protocol];
       const transform = this.snappyTransform;
 
-      this.logger.info(`Stream handler for ${protocol}`);
-
       await pipe(
         stream,
         async function* (source: any) {

package/src/services/service.ts

@@ -1,10 +1,11 @@
-import type { BlockAttestation, BlockProposal, Gossipable, PeerInfo } from '@aztec/circuit-types';
+import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
 
 import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import type EventEmitter from 'events';
 
-import { type ReqRespSubProtocol, type SubProtocolMap } from './reqresp/interface.js';
+import type { ReqRespSubProtocol, SubProtocolMap } from './reqresp/interface.js';
 
 export enum PeerDiscoveryState {
   RUNNING = 'running',

package/src/test-helpers/make-enrs.ts

@@ -1,4 +1,4 @@
-import { type ChainConfig } from '@aztec/circuit-types/config';
+import type { ChainConfig } from '@aztec/stdlib/config';
 
 import { SignableENR } from '@chainsafe/enr';
 import { multiaddr } from '@multiformats/multiaddr';

package/src/test-helpers/make-test-p2p-clients.ts

@@ -1,15 +1,16 @@
 import { MockL2BlockSource } from '@aztec/archiver/test';
-import { P2PClientType, type WorldStateSynchronizer } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import type { EpochCache } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
 
 import { createP2PClient } from '../client/index.js';
-import { type P2PClient } from '../client/p2p_client.js';
-import { type P2PConfig } from '../config.js';
-import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { type TxPool } from '../mem_pools/tx_pool/index.js';
+import type { P2PClient } from '../client/p2p_client.js';
+import type { P2PConfig } from '../config.js';
+import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import type { TxPool } from '../mem_pools/tx_pool/index.js';
 import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-private-keys.js';
 import { getPorts } from './get-ports.js';
 import { makeEnrs } from './make-enrs.js';
@@ -65,6 +66,7 @@ export async function makeTestP2PClient(
     bootstrapNodes: peers,
     peerCheckIntervalMS: 1000,
     maxPeerCount: 10,
+    bootstrapNodesAsFullPeers: true,
     ...p2pConfigOverrides,
   } as P2PConfig & DataStoreConfig;
 

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

@@ -1,35 +1,34 @@
-import {
-  type ClientProtocolCircuitVerifier,
-  type L2BlockSource,
-  type P2PClientType,
-  type Tx,
-  type WorldStateSynchronizer,
-} from '@aztec/circuit-types';
-import { type ChainConfig, emptyChainConfig } from '@aztec/circuit-types/config';
-import { type EpochCache } from '@aztec/epoch-cache';
+import type { EpochCache } from '@aztec/epoch-cache';
 import { timesParallel } from '@aztec/foundation/collection';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
+import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { P2PClientType } from '@aztec/stdlib/p2p';
+import type { Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
+import { SignableENR } from '@chainsafe/enr';
 import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { bootstrap } from '@libp2p/bootstrap';
 import { identify } from '@libp2p/identify';
-import { type PeerId } from '@libp2p/interface';
+import type { PeerId } from '@libp2p/interface';
 import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
+import { multiaddr } from '@multiformats/multiaddr';
 import getPort from 'get-port';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 
 import { BootstrapNode } from '../bootstrap/bootstrap.js';
-import { type BootnodeConfig, type P2PConfig } from '../config.js';
-import { type MemPools } from '../mem_pools/interface.js';
+import type { BootnodeConfig, P2PConfig } from '../config.js';
+import type { MemPools } from '../mem_pools/interface.js';
 import { DiscV5Service } from '../services/discv5/discV5_service.js';
 import { LibP2PService } from '../services/libp2p/libp2p_service.js';
-import { type PeerScoring } from '../services/peer-manager/peer_scoring.js';
-import { type P2PReqRespConfig } from '../services/reqresp/config.js';
+import type { PeerScoring } from '../services/peer-manager/peer_scoring.js';
+import type { P2PReqRespConfig } from '../services/reqresp/config.js';
 import {
   ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
@@ -38,7 +37,7 @@ import {
 } from '../services/reqresp/interface.js';
 import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
 import { ReqResp } from '../services/reqresp/reqresp.js';
-import { type PubSubLibp2p } from '../util.js';
+import { type PubSubLibp2p, convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
 
 /**
  * Creates a libp2p node, pre configured.
@@ -235,13 +234,13 @@ export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier
 // Bootnodes
 export function createBootstrapNodeConfig(privateKey: string, port: number, chainConfig: ChainConfig): BootnodeConfig {
   return {
+    l1ChainId: chainConfig.l1ChainId,
     udpListenAddress: `0.0.0.0:${port}`,
     udpAnnounceAddress: `127.0.0.1:${port}`,
     peerIdPrivateKey: privateKey,
-    maxPeerCount: 100,
     dataDirectory: undefined,
     dataStoreMapSizeKB: 0,
-    ...chainConfig,
+    bootstrapNodes: [],
   };
 }
 
@@ -255,6 +254,21 @@ export function createBootstrapNodeFromPrivateKey(
   return startBootstrapNode(config, telemetry);
 }
 
+/**
+ * Create a bootstrap node ENR
+ * @param privateKey - the private key of the bootstrap node
+ * @param port - the port of the bootstrap node
+ * @returns the bootstrap node ENR
+ */
+export async function getBootstrapNodeEnr(privateKey: string, port: number) {
+  const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
+  const enr = SignableENR.createFromPeerId(peerId);
+  const listenAddrUdp = multiaddr(convertToMultiaddr(`127.0.0.1:${port}`, 'udp'));
+  enr.setLocationMultiaddr(listenAddrUdp);
+
+  return enr;
+}
+
 export async function createBootstrapNode(
   port: number,
   telemetry: TelemetryClient = getTelemetryClient(),

package/src/testbench/p2p_client_testbench_worker.ts

@@ -4,18 +4,22 @@
  * Used when running testbench commands
  */
 import { MockL2BlockSource } from '@aztec/archiver/test';
-import { P2PClientType, Tx, TxStatus, type WorldStateSynchronizer } from '@aztec/circuit-types';
-import { type EpochCacheInterface } from '@aztec/epoch-cache';
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { Tx, TxStatus } from '@aztec/stdlib/tx';
 
-import { type P2PConfig } from '../config.js';
+import type { Message, PeerId } from '@libp2p/interface';
+
+import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
-import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { type TxPool } from '../mem_pools/tx_pool/index.js';
+import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import type { TxPool } from '../mem_pools/tx_pool/index.js';
 import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
 
 // Simple mock implementation
@@ -101,12 +105,15 @@ process.on('message', async msg => {
 
       // Create spy for gossip messages
       let gossipMessageCount = 0;
-      (client as any).p2pService.handleNewGossipMessage = (...args: any[]) => {
+      (client as any).p2pService.handleNewGossipMessage = (msg: Message, msgId: string, source: PeerId) => {
         gossipMessageCount++;
-        process.send!({ type: 'GOSSIP_RECEIVED', count: gossipMessageCount });
+        process.send!({
+          type: 'GOSSIP_RECEIVED',
+          count: gossipMessageCount,
+        });
         return (client as any).p2pService.constructor.prototype.handleNewGossipMessage.apply(
           (client as any).p2pService,
-          args,
+          [msg, msgId, source],
         );
       };
 

package/src/testbench/parse_log_file.ts

@@ -0,0 +1,175 @@
+// Parse Log File
+// 1. Determine when a message was sent from the Sent Message log
+// 2. Parse all Received Tx logs, extracting the timestamp and peer ID
+// 3. Compute the delay for each peer relative to the timestamp of the sent message
+// 4. Print the delays
+import { createLogger } from '@aztec/foundation/log';
+
+import * as fs from 'fs';
+
+const logger = createLogger('parse_log_file');
+
+interface LogEvent {
+  timestamp: number; // in milliseconds (from start of log)
+  peerId: string;
+}
+
+interface BenchmarkResult {
+  delays: {
+    peerId: string;
+    delay: number;
+  }[];
+  stats: {
+    numberReceived: number;
+    minDelay: number;
+    maxDelay: number;
+    averageDelay: number;
+    medianDelay: number;
+  };
+}
+
+function getTimestamp(line: string): number | null {
+  const timestampMatch = line.match(/"time":(\d+)/);
+  if (!timestampMatch) {
+    return null;
+  }
+  return parseInt(timestampMatch[1], 10);
+}
+
+/**
+ * Parses a single log line. If the line contains an "rpc.from" event,
+ * it extracts the timestamp and the peer ID.
+ */
+function parseReceivedTx(line: string): LogEvent | null {
+  if (!line.includes('Received tx')) {
+    return null;
+  }
+
+  // Extract timestamp from the line: e.g. {"time":1740142435845}
+  const timestamp = getTimestamp(line);
+  if (!timestamp) {
+    logger.error('No timestamp found in received tx log');
+    return null;
+  }
+
+  // TODO: this is not correct - it is just the tx hash for now
+  // Extract the peer ID after "Received tx"
+  const peerIdMatch = line.match(/p2p:(\d+):/);
+  if (!peerIdMatch) {
+    logger.error('No peer Number found in received tx log');
+    return null;
+  }
+  const peerId = peerIdMatch[1];
+
+  return {
+    timestamp,
+    peerId,
+  };
+}
+
+function parseSentMessage(line: string): number | null {
+  if (!line.includes('Sent message')) {
+    return null;
+  }
+
+  const timestamp = getTimestamp(line);
+  if (!timestamp) {
+    logger.error('No timestamp found in sent message log');
+    return null;
+  }
+
+  return timestamp;
+}
+
+/**
+ * Processes the given log file, extracts all rpc.from events, computes the
+ * propagation delay for each peer relative to the earliest event, and prints
+ * some benchmark statistics.
+ */
+function processLogFile(logFilePath: string, outputJsonPath?: string) {
+  const content = fs.readFileSync(logFilePath, 'utf-8');
+  const lines = content.split('\n');
+  const events: LogEvent[] = [];
+  let t0 = 0;
+
+  // We begin our search as soon as we see the Sent message log
+  let messageSent = false;
+  for (const line of lines) {
+    // Look for Sent message log
+    if (line.includes('Sent message')) {
+      messageSent = true;
+      t0 = parseSentMessage(line)!;
+    }
+
+    if (!messageSent) {
+      continue;
+    }
+    // Once we see the sent message log, we begin parsing Received tx logs
+    const event = parseReceivedTx(line);
+    if (event) {
+      events.push(event);
+    }
+  }
+
+  if (events.length === 0) {
+    logger.error('No message received events found in log file.');
+    return;
+  }
+
+  // Sort events by timestamp (ascending)
+  events.sort((a, b) => a.timestamp - b.timestamp);
+
+  // Compute delay for each event relative to t0
+  const numberReceived = events.length;
+  const delays = events.map(e => ({
+    peerId: e.peerId,
+    delay: e.timestamp - t0,
+  }));
+
+  logger.info('Propagation delays (in ms) per peer:');
+  for (const d of delays) {
+    logger.info(`${d.peerId}: ${d.delay} ms`);
+  }
+
+  // Compute basic statistics
+  const delayValues = delays.map(d => d.delay);
+  const minDelay = Math.min(...delayValues);
+  const maxDelay = Math.max(...delayValues);
+  const sumDelay = delayValues.reduce((sum, val) => sum + val, 0);
+  const avgDelay = sumDelay / delayValues.length;
+  const sortedDelays = delayValues.slice().sort((a, b) => a - b);
+  const medianDelay = sortedDelays[Math.floor(sortedDelays.length / 2)];
+
+  logger.info('\nBenchmark Statistics:');
+  logger.info(`Number of messages received: ${numberReceived}`);
+  logger.info(`Min delay: ${minDelay} ms`);
+  logger.info(`Max delay: ${maxDelay} ms`);
+  logger.info(`Average delay: ${avgDelay.toFixed(2)} ms`);
+  logger.info(`Median delay: ${medianDelay} ms`);
+
+  // If output JSON path is provided, write results to file
+  if (outputJsonPath) {
+    const result: BenchmarkResult = {
+      delays,
+      stats: {
+        numberReceived,
+        minDelay,
+        maxDelay,
+        averageDelay: Number(avgDelay.toFixed(2)),
+        medianDelay,
+      },
+    };
+
+    fs.writeFileSync(outputJsonPath, JSON.stringify(result, null, 2));
+    logger.info(`\nResults written to ${outputJsonPath}`);
+  }
+}
+
+// Get the log file path and optional output JSON path from command-line arguments
+const [logFilePath, outputJsonPath] = process.argv.slice(2);
+if (!logFilePath) {
+  logger.error('Usage: ts-node parse_log_file.ts <logFilePath> [outputJsonPath]');
+  process.exit(1);
+}
+
+processLogFile(logFilePath, outputJsonPath);