@aztec/p2p 0.0.1-commit.9ef841308 → 0.0.1-commit.a5db02d

package/src/testbench/p2p_client_testbench_worker.ts

@@ -17,12 +17,14 @@ import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { GasFees } from '@aztec/stdlib/gas';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import { type BlockProposal, P2PMessage } from '@aztec/stdlib/p2p';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import { makeAztecAddress, makeBlockHeader, makeBlockProposal, mockTx } from '@aztec/stdlib/testing';
-import { Tx, TxHash, type TxValidationResult } from '@aztec/stdlib/tx';
+import { Tx, TxHash, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { Message, PeerId } from '@libp2p/interface';
@@ -33,10 +35,10 @@ import type { P2PClient } from '../client/index.js';
 import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
 import type { MemPools } from '../mem_pools/index.js';
-import { BatchTxRequesterCollector, LibP2PService, SendBatchRequestCollector } from '../services/index.js';
+import { LibP2PService } from '../services/index.js';
 import type { PeerManager } from '../services/peer-manager/peer_manager.js';
+import { BatchTxRequester } from '../services/reqresp/batch-tx-requester/batch_tx_requester.js';
 import type { BatchTxRequesterLibP2PService } from '../services/reqresp/batch-tx-requester/interface.js';
-import type { IBatchRequestTxValidator } from '../services/reqresp/batch-tx-requester/tx_validator.js';
 import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
 import type { ReqResp } from '../services/reqresp/reqresp.js';
 import type { PeerDiscoveryService } from '../services/service.js';
@@ -44,7 +46,6 @@ import { RequestTracker } from '../services/tx_collection/request_tracker.js';
 import { AlwaysTrueCircuitVerifier } from '../test-helpers/index.js';
 import {
   BENCHMARK_CONSTANTS,
-  type CollectorType,
   type DistributionPattern,
   InMemoryAttestationPool,
   InMemoryTxPool,
@@ -55,15 +56,13 @@ import {
 } from '../test-helpers/index.js';
 import type { PubSubLibp2p } from '../util.js';
 
-export type { DistributionPattern, CollectorType } from '../test-helpers/testbench-utils.js';
-export { COLLECTOR_DISPLAY_NAMES } from '../test-helpers/testbench-utils.js';
+export type { DistributionPattern } from '../test-helpers/testbench-utils.js';
 
 export interface BenchReqRespCommand {
   type: 'BENCH_REQRESP';
   txCount: number;
   peerCount: number;
   distribution: DistributionPattern;
-  collectorType: CollectorType;
   timeoutMs: number;
   isAggregator: boolean;
   peerIndex: number;
@@ -86,6 +85,25 @@ export interface BenchReadyMessage {
 }
 const txCache = new Map<number, Tx[]>();
 
+const BENCH_L1_CONSTANTS: L1RollupConstants = {
+  ...EmptyL1RollupConstants,
+  slotDuration: 12,
+  ethereumSlotDuration: 4,
+};
+
+class TestbenchL2BlockSource extends MockL2BlockSource {
+  public override getL1Constants(): Promise<L1RollupConstants> {
+    return Promise.resolve(BENCH_L1_CONSTANTS);
+  }
+}
+
+function createBenchmarkEpochCache(): EpochCacheInterface {
+  return {
+    ...createMockEpochCache(),
+    getL1Constants: () => BENCH_L1_CONSTANTS,
+  };
+}
+
 class TestLibP2PService extends LibP2PService {
   private disableTxValidation: boolean;
   private gossipMessageCount = 0;
@@ -116,6 +134,7 @@ class TestLibP2PService extends LibP2PService {
       epochCache,
       proofVerifier,
       worldStateSynchronizer,
+      { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
       telemetry,
       logger,
     );
@@ -204,10 +223,28 @@ function installUnlimitedRateLimits(client: P2PClient): void {
   rateLimiter.allow = () => RateLimitStatus.Allowed;
 }
 
+/** Resets peer scores to prevent cross-case contamination in benchmarks. */
+function resetPeerScores(client: P2PClient): void {
+  const peerManager = (client as any).p2pService.peerManager;
+  const peerScoring = peerManager?.peerScoring;
+  if (peerScoring?.resetAllScores) {
+    peerScoring.resetAllScores();
+  }
+}
+
+/** Returns the number of connected peers for connectivity checks. */
+function getConnectedPeerCount(client: P2PClient): number {
+  const p2pService = (client as any).p2pService;
+  const connectionSampler = p2pService?.reqresp?.getConnectionSampler?.();
+  if (connectionSampler?.getPeerListSortedByConnectionCountAsc) {
+    return connectionSampler.getPeerListSortedByConnectionCountAsc().length;
+  }
+  return 0;
+}
+
 async function runAggregatorBenchmark(
   client: P2PClient,
   blockProposal: BlockProposal,
-  collectorType: CollectorType,
   timeoutMs: number,
   pinnedPeerId: string | undefined,
   pinnedPeerIndex: number | undefined,
@@ -258,44 +295,22 @@ async function runAggregatorBenchmark(
       }
     }
 
-    const noopTxValidator: IBatchRequestTxValidator = {
-      validateRequestedTx: (_tx: Tx): Promise<TxValidationResult> => Promise.resolve({ result: 'valid' }),
-      validateRequestedTxs: (txs: Tx[]): Promise<TxValidationResult[]> =>
-        Promise.resolve(txs.map(() => ({ result: 'valid' }))),
+    const noopTxValidator: TxValidator = {
+      validateTx: (_tx: Tx): Promise<TxValidationResult> => Promise.resolve({ result: 'valid' }),
     };
 
     timer = new Timer();
-    if (collectorType === 'batch-requester') {
-      const collector = new BatchTxRequesterCollector(
-        batchTxRequesterService,
-        logger,
-        new DateProvider(),
-        noopTxValidator,
-      );
-      const fetchedTxs = await collector.collectTxs(
-        RequestTracker.create(txHashes, new Date(Date.now() + timeoutMs)),
-        blockProposal,
-        pinnedPeer,
-      );
-      const durationMs = timer.ms();
-      return {
-        type: 'BENCH_RESULT',
-        durationMs,
-        fetchedCount: fetchedTxs.length,
-        success: fetchedTxs.length === txHashes.length,
-      };
-    }
-
-    const collector = new SendBatchRequestCollector(
-      batchTxRequesterService,
-      BENCHMARK_CONSTANTS.FIXED_MAX_PEERS,
-      BENCHMARK_CONSTANTS.FIXED_MAX_RETRY_ATTEMPTS,
-    );
-    const fetchedTxs = await collector.collectTxs(
-      RequestTracker.create(txHashes, new Date(Date.now() + timeoutMs)),
+    const tracker = RequestTracker.create(txHashes, new Date(Date.now() + timeoutMs));
+    const batchRequester = new BatchTxRequester(
+      tracker,
       blockProposal,
       pinnedPeer,
+      batchTxRequesterService,
+      logger,
+      new DateProvider(),
+      { txValidator: noopTxValidator },
     );
+    const fetchedTxs = await BatchTxRequester.collectAllTxs(batchRequester.run());
     const durationMs = timer.ms();
     return {
       type: 'BENCH_RESULT',
@@ -375,9 +390,9 @@ process.on('message', async msg => {
       workerConfig = config;
       workerTxPool = new InMemoryTxPool();
       workerAttestationPool = new InMemoryAttestationPool();
-      const epochCache = createMockEpochCache();
+      const epochCache = createBenchmarkEpochCache();
       const worldState = createMockWorldStateSynchronizer();
-      const l2BlockSource = new MockL2BlockSource();
+      const l2BlockSource = new TestbenchL2BlockSource();
 
       const proofVerifier = new AlwaysTrueCircuitVerifier();
       kvStore = await openTmpStore(`test-${clientIndex}`, true, BENCHMARK_CONSTANTS.KV_STORE_MAP_SIZE_KB);
@@ -398,10 +413,12 @@ process.on('message', async msg => {
         proofVerifier as ClientProtocolCircuitVerifier,
         worldState,
         epochCache,
+        { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
         'test-p2p-bench-worker',
         undefined,
         telemetry as TelemetryClient,
         deps,
+        await l2BlockSource.getInitialHeader().hash(),
       );
 
       const testService = new TestLibP2PService(
@@ -452,6 +469,13 @@ process.on('message', async msg => {
         }
         break;
 
+      case 'GET_PEER_COUNT':
+        process.send!({
+          type: 'PEER_COUNT',
+          count: workerClient ? getConnectedPeerCount(workerClient) : 0,
+        });
+        break;
+
       case 'BENCH_REQRESP': {
         const benchCmd = cmd as BenchReqRespCommand;
         if (!workerClient || !workerTxPool || !workerAttestationPool || !workerConfig || !workerLogger) {
@@ -468,6 +492,7 @@ process.on('message', async msg => {
         // Reset state before each benchmark run to avoid cross-run contamination
         workerTxPool.resetState();
         workerAttestationPool.resetState();
+        resetPeerScores(workerClient);
 
         installUnlimitedRateLimits(workerClient);
 
@@ -484,13 +509,12 @@ process.on('message', async msg => {
           workerTxPool.clearTxs();
 
           workerLogger.info(
-            `[BENCH] Aggregator starting benchmark: txCount=${benchCmd.txCount}, collector=${benchCmd.collectorType}, distribution=${benchCmd.distribution}`,
+            `[BENCH] Aggregator starting benchmark: txCount=${benchCmd.txCount}, distribution=${benchCmd.distribution}`,
           );
 
           const result = await runAggregatorBenchmark(
             workerClient,
             blockProposal,
-            benchCmd.collectorType,
             benchCmd.timeoutMs,
             benchCmd.pinnedPeerId,
             benchCmd.pinnedPeerIndex,

package/src/testbench/worker_client_manager.ts

@@ -13,12 +13,7 @@ import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-priv
 import { getPorts } from '../test-helpers/get-ports.js';
 import { makeEnr, makeEnrs } from '../test-helpers/make-enrs.js';
 import { BENCHMARK_CONSTANTS } from '../test-helpers/testbench-utils.js';
-import type {
-  BenchReqRespCommand,
-  BenchResultMessage,
-  CollectorType,
-  DistributionPattern,
-} from './p2p_client_testbench_worker.js';
+import type { BenchReqRespCommand, BenchResultMessage, DistributionPattern } from './p2p_client_testbench_worker.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const p2pRoot = path.resolve(__dirname, '../..');
@@ -29,15 +24,12 @@ const tsconfigPath = path.join(p2pRoot, 'tsconfig.json');
 const testChainConfig: ChainConfig = {
   l1ChainId: 31337,
   rollupVersion: 1,
-  l1Contracts: {
-    rollupAddress: EthAddress.random(),
-  },
+  rollupAddress: EthAddress.random(),
 };
 
 export interface ReqRespBenchmarkConfig {
   txCount: number;
   distribution: DistributionPattern;
-  collectorType: CollectorType;
   timeoutMs: number;
   pinnedPeerIndex?: number;
   blockNumber?: number;
@@ -47,7 +39,6 @@ export interface ReqRespBenchmarkConfig {
 export interface ReqRespBenchmarkResult {
   txCount: number;
   distribution: DistributionPattern;
-  collector: CollectorType;
   durationMs: number;
   fetchedCount: number;
   success: boolean;
@@ -424,6 +415,61 @@ class WorkerClientManager {
     this.logger.info('All worker processes cleaned up');
   }
 
+  /**
+   * Checks that the aggregator (client 0) has sufficient peer connections before running a benchmark.
+   * This prevents benchmark cases from starting with degraded connectivity after a previous case
+   * caused connection failures.
+   */
+  async waitForConnectivity(minPeers: number, timeoutMs: number = 15_000): Promise<number> {
+    const waitInterval = 1000;
+    let waited = 0;
+
+    while (waited < timeoutMs) {
+      const count = await this.getPeerCount(0, 5000);
+      if (count >= minPeers) {
+        this.logger.info(`Connectivity check passed: ${count}/${minPeers} peers connected`);
+        return count;
+      }
+      this.logger.debug(`Waiting for connectivity: ${count}/${minPeers} (waited ${waited}ms)`);
+      await sleep(waitInterval);
+      waited += waitInterval;
+    }
+
+    const finalCount = await this.getPeerCount(0, 5000);
+    this.logger.warn(`Connectivity check: only ${finalCount}/${minPeers} peers after ${timeoutMs}ms`);
+    return finalCount;
+  }
+
+  private getPeerCount(clientIndex: number, timeoutMs: number): Promise<number> {
+    return new Promise<number>(resolve => {
+      let resolved = false;
+
+      const handler = (msg: any) => {
+        if (resolved) {
+          return;
+        }
+        if (msg.type === 'PEER_COUNT') {
+          resolved = true;
+          clearTimeout(timeout);
+          this.processes[clientIndex].off('message', handler);
+          resolve(msg.count as number);
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        this.processes[clientIndex].off('message', handler);
+        resolve(0);
+      }, timeoutMs);
+
+      this.processes[clientIndex].on('message', handler);
+      this.processes[clientIndex].send({ type: 'GET_PEER_COUNT' });
+    });
+  }
+
   /**
    * Run a req/resp benchmark across all worker clients.
    *
@@ -444,9 +490,7 @@ class WorkerClientManager {
     const blockNumber = config.blockNumber ?? 1;
     const pinnedPeerId = config.pinnedPeerIndex !== undefined ? this.peerIds[config.pinnedPeerIndex] : undefined;
 
-    this.logger.info(
-      `Starting req/resp benchmark: txCount=${config.txCount}, distribution=${config.distribution}, collector=${config.collectorType}`,
-    );
+    this.logger.info(`Starting req/resp benchmark: txCount=${config.txCount}, distribution=${config.distribution}`);
 
     const readyPromises: Promise<void>[] = [];
 
@@ -456,7 +500,6 @@ class WorkerClientManager {
         txCount: config.txCount,
         peerCount,
         distribution: config.distribution,
-        collectorType: config.collectorType,
         timeoutMs: config.timeoutMs,
         isAggregator: false,
         peerIndex: i,
@@ -478,7 +521,6 @@ class WorkerClientManager {
       txCount: config.txCount,
       peerCount,
       distribution: config.distribution,
-      collectorType: config.collectorType,
       timeoutMs: config.timeoutMs,
       isAggregator: true,
       peerIndex: 0,
@@ -499,7 +541,6 @@ class WorkerClientManager {
     return {
       txCount: config.txCount,
       distribution: config.distribution,
-      collector: config.collectorType,
       durationMs: result.durationMs,
       fetchedCount: result.fetchedCount,
       success: result.success,
@@ -577,5 +618,4 @@ class WorkerClientManager {
 }
 
 export { WorkerClientManager, testChainConfig };
-export type { DistributionPattern, CollectorType } from './p2p_client_testbench_worker.js';
-export { COLLECTOR_DISPLAY_NAMES } from './p2p_client_testbench_worker.js';
+export type { DistributionPattern } from './p2p_client_testbench_worker.js';

package/src/util.ts

@@ -1,5 +1,5 @@
 import { SecretValue } from '@aztec/foundation/config';
-import type { Logger } from '@aztec/foundation/log';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncSingleton } from '@aztec/kv-store';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
@@ -15,7 +15,7 @@ import type { Libp2p } from 'libp2p';
 import net from 'net';
 import path from 'path';
 
-import type { P2PConfig } from './config.js';
+import { DEFAULT_PUBLIC_IP_SERVICES, type P2PConfig } from './config.js';
 
 const PEER_ID_DATA_DIR_FILE = 'p2p-private-key';
 
@@ -32,8 +32,7 @@ export interface PubSubLibp2p extends Pick<Libp2p, 'status' | 'start' | 'stop' |
       | 'getMeshPeers'
     > & { score: Pick<GossipSub['score'], 'score'> };
     components: {
-      connectionManager: ConnectionManager;
-      addressManager: AddressManager;
+      addressManager: Pick<AddressManager, 'addObservedAddr' | 'confirmObservedAddr' | 'removeObservedAddr'>;
     };
   };
 }
@@ -65,16 +64,25 @@ export function convertToMultiaddr(address: string, port: number, protocol: 'tcp
 }
 
 /**
- * Queries the public IP address of the machine.
+ * Queries the public IP address of the machine, trying multiple services in order.
+ * @param services - HTTPS URLs to try; defaults to {@link DEFAULT_PUBLIC_IP_SERVICES}.
  */
-export async function getPublicIp(): Promise<string> {
-  const resp = await fetch('https://checkip.amazonaws.com/');
-  const text = await resp.text();
-  const address = text.trim();
-  if (!isValidIpAddress(address)) {
-    throw new Error(`Received invalid IP address from checkip service: ${address}`);
+export async function getPublicIp(services: string[] = DEFAULT_PUBLIC_IP_SERVICES): Promise<string> {
+  const errors: string[] = [];
+  for (const url of services) {
+    try {
+      const resp = await fetch(url, { signal: AbortSignal.timeout(5000) });
+      const text = await resp.text();
+      const address = text.trim();
+      if (isValidIpAddress(address)) {
+        return address;
+      }
+      errors.push(`${url}: invalid IP "${address}"`);
+    } catch (err: any) {
+      errors.push(`${url}: ${err.message ?? err}`);
+    }
   }
-  return address;
+  throw new Error(`Failed to determine public IP from all services:\n${errors.join('\n')}`);
 }
 
 export function isValidIpAddress(address: string): boolean {
@@ -107,15 +115,26 @@ function addressToMultiAddressType(address: string): 'ip4' | 'ip6' | 'dns' {
   }
 }
 
-export function configureP2PClientAddresses(_config: P2PConfig & DataStoreConfig): P2PConfig & DataStoreConfig {
+export async function configureP2PClientAddresses(
+  _config: P2PConfig & DataStoreConfig,
+): Promise<P2PConfig & DataStoreConfig> {
   const config = { ..._config };
-  const { p2pBroadcastPort, p2pPort } = config;
+  const { p2pIp, queryForIp, p2pBroadcastPort, p2pPort } = config;
+  const logger = createLogger('p2p:config');
 
   // If no broadcast port is provided, use the given p2p port as the broadcast port
   if (!p2pBroadcastPort) {
     config.p2pBroadcastPort = p2pPort;
   }
 
+  // Resolve the initial public IP so the ENR and announce address are set at startup.
+  // If queryForIp is enabled, discv5 will also track IP changes at runtime via enrUpdate.
+  if (!p2pIp && queryForIp) {
+    config.p2pIp = await getPublicIp(config.publicIpServices);
+    logger.info('Resolved initial public IP for P2P', { ip: config.p2pIp, queryForIp });
+  } else if (p2pIp) {
+    logger.info('Using configured static P2P IP', { ip: p2pIp, queryForIp });
+  }
   // TODO(md): guard against setting a local ip address as the announce ip
 
   return config;

package/src/versioning.ts

@@ -1,33 +1,21 @@
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ChainConfig } from '@aztec/stdlib/config';
-import {
-  type ComponentsVersions,
-  checkCompressedComponentVersion,
-  compressComponentVersions,
-  getComponentsVersionsFromConfig,
-} from '@aztec/stdlib/versioning';
+import { compressComponentVersions, getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 
 import type { SignableENR } from '@nethermindeth/enr';
-import xxhashFactory from 'xxhash-wasm';
 
 import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from './types/index.js';
 
-const USE_XX_HASH = false; // Enable to reduce the size of the ENR record for production
-const XX_HASH_LEN = 8;
-const xxhash = await xxhashFactory();
-
 /** Returns the component versions based on config and this build. */
 export function getVersions(config: ChainConfig) {
   return getComponentsVersionsFromConfig(config, protocolContractsHash, getVKTreeRoot());
 }
 
 /** Sets the aztec key on the ENR record with versioning info. */
-export function setAztecEnrKey(enr: SignableENR, config: ChainConfig, useXxHash = USE_XX_HASH) {
+export function setAztecEnrKey(enr: SignableENR, config: ChainConfig) {
   const versions = getVersions(config);
-  const value = versionsToEnrValue(versions, useXxHash);
-  enr.set(AZTEC_ENR_KEY, value);
+  enr.set(AZTEC_ENR_KEY, Buffer.from(compressComponentVersions(versions)));
   return versions;
 }
 
@@ -37,21 +25,3 @@ export function setAztecClientVersionEnrKey(enr: SignableENR, clientVersion: str
     enr.set(AZTEC_ENR_CLIENT_VERSION_KEY, Buffer.from(clientVersion));
   }
 }
-
-/** Checks the given value from an ENR record against the expected versions. */
-export function checkAztecEnrVersion(enrValue: Buffer, expectedVersions: ComponentsVersions) {
-  if (enrValue.length === XX_HASH_LEN) {
-    const expected = versionsToEnrValue(expectedVersions, true);
-    if (!Buffer.from(enrValue).equals(expected)) {
-      throw new Error(`Expected ENR version ${expected.toString('hex')} but received ${enrValue.toString('hex')}`);
-    }
-  } else {
-    const actual = Buffer.from(enrValue).toString();
-    checkCompressedComponentVersion(actual, expectedVersions);
-  }
-}
-
-function versionsToEnrValue(versions: ComponentsVersions, useXxHash: boolean) {
-  const compressed = compressComponentVersions(versions);
-  return useXxHash ? toBufferBE(xxhash.h64(compressed), XX_HASH_LEN) : Buffer.from(compressed);
-}

package/dest/client/test/tx_proposal_collector/proposal_tx_collector_worker.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcG9zYWxfdHhfY29sbGVjdG9yX3dvcmtlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NsaWVudC90ZXN0L3R4X3Byb3Bvc2FsX2NvbGxlY3Rvci9wcm9wb3NhbF90eF9jb2xsZWN0b3Jfd29ya2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dest/client/test/tx_proposal_collector/proposal_tx_collector_worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proposal_tx_collector_worker.d.ts","sourceRoot":"","sources":["../../../../src/client/test/tx_proposal_collector/proposal_tx_collector_worker.ts"],"names":[],"mappings":""}