@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/testbench/p2p_client_testbench_worker.ts

@@ -12,42 +12,40 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 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 BlockProposal, P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
+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';
 import { TopicValidatorResult } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 
-import type { P2PClient } from '../client/p2p_client.js';
+import type { P2PClient } from '../client/index.js';
 import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
-import type { MemPools } from '../mem_pools/interface.js';
-import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import type { MemPools } from '../mem_pools/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';
-import {
-  BatchTxRequesterCollector,
-  SendBatchRequestCollector,
-} from '../services/tx_collection/proposal_tx_collector.js';
-import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+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,18 +53,16 @@ import {
   createMockEpochCache,
   createMockWorldStateSynchronizer,
   filterTxsByDistribution,
-} from '../test-helpers/testbench-utils.js';
+} 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;
@@ -89,12 +85,30 @@ export interface BenchReadyMessage {
 }
 const txCache = new Map<number, Tx[]>();
 
-class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends LibP2PService<T> {
+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;
 
   constructor(
-    clientType: T,
     config: P2PConfig,
     node: PubSubLibp2p,
     peerDiscoveryService: PeerDiscoveryService,
@@ -110,7 +124,6 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
     disableTxValidation = true,
   ) {
     super(
-      clientType,
       config,
       node,
       peerDiscoveryService,
@@ -121,6 +134,7 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
       epochCache,
       proofVerifier,
       worldStateSynchronizer,
+      { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
       telemetry,
       logger,
     );
@@ -144,7 +158,7 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
       const txHash = tx.getTxHash();
       const txHashString = txHash.toString();
       this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
-      await this.mempools.txPool.addTxs([tx]);
+      await this.mempools.txPool.addPendingTxs([tx]);
     } else {
       await super.handleGossipedTx(payload, msgId, source);
     }
@@ -166,7 +180,7 @@ async function generateDeterministicTxs(txCount: number, seed: number, config: P
     return cached.slice(0, txCount);
   }
 
-  const includeByTimestampBase = BigInt(seed);
+  const expirationTimestampBase = BigInt(seed);
   for (let i = cached.length; i < txCount; i++) {
     const txSeed = seed * 10000 + i;
     const tx = await mockTx(txSeed, {
@@ -182,7 +196,7 @@ async function generateDeterministicTxs(txCount: number, seed: number, config: P
       hasPublicTeardownCallRequest: false,
       publicCalldataSize: 0,
     });
-    tx.data.includeByTimestamp = includeByTimestampBase + BigInt(i);
+    tx.data.expirationTimestamp = expirationTimestampBase + BigInt(i);
     await tx.recomputeHash();
     cached.push(tx);
   }
@@ -209,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,
@@ -263,36 +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(txHashes, blockProposal, pinnedPeer, timeoutMs);
-      const durationMs = timer.ms();
-      return {
-        type: 'BENCH_RESULT',
-        durationMs,
-        fetchedCount: fetchedTxs.length,
-        success: fetchedTxs.length === txHashes.length,
-      };
-    }
-
-    const collector = new SendBatchRequestCollector(
+    const tracker = RequestTracker.create(txHashes, new Date(Date.now() + timeoutMs));
+    const batchRequester = new BatchTxRequester(
+      tracker,
+      blockProposal,
+      pinnedPeer,
       batchTxRequesterService,
-      BENCHMARK_CONSTANTS.FIXED_MAX_PEERS,
-      BENCHMARK_CONSTANTS.FIXED_MAX_RETRY_ATTEMPTS,
+      logger,
+      new DateProvider(),
+      { txValidator: noopTxValidator },
     );
-    const fetchedTxs = await collector.collectTxs(txHashes, blockProposal, pinnedPeer, timeoutMs);
+    const fetchedTxs = await BatchTxRequester.collectAllTxs(batchRequester.run());
     const durationMs = timer.ms();
     return {
       type: 'BENCH_RESULT',
@@ -318,6 +336,37 @@ let workerConfig: P2PConfig | null = null;
 let workerLogger: Logger | null = null;
 let kvStore: Awaited<ReturnType<typeof openTmpStore>> | null = null;
 
+async function stopWorker() {
+  try {
+    if (workerClient) {
+      await workerClient.stop();
+      workerClient = null;
+    }
+  } catch (e) {
+    workerLogger?.error('Error stopping worker client', e);
+  }
+  try {
+    if (kvStore?.close) {
+      await kvStore.close();
+      kvStore = null;
+    }
+  } catch (e) {
+    workerLogger?.error('Error closing kv store', e);
+  }
+}
+
+function gracefulExit(code: number = 0) {
+  try {
+    if (process.connected) {
+      process.disconnect();
+    }
+  } catch {
+    // IPC channel already closed
+  }
+  // Safety fallback if lingering handles prevent the event loop from draining
+  setTimeout(() => process.exit(code), 5000).unref();
+}
+
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 process.on('message', async msg => {
   const {
@@ -335,14 +384,15 @@ process.on('message', async msg => {
       const config: P2PConfig = {
         ...rawConfig,
         peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
+        priceBumpPercentage: 10n,
       } as P2PConfig;
 
       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);
@@ -358,20 +408,20 @@ process.on('message', async msg => {
       };
 
       const client = await createP2PClient(
-        P2PClientType.Full,
         config as P2PConfig & DataStoreConfig,
         l2BlockSource,
         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(
-        P2PClientType.Full,
         config,
         (client as any).p2pService.node,
         (client as any).p2pService.peerDiscoveryService,
@@ -408,13 +458,8 @@ process.on('message', async msg => {
     const cmd = msg as any;
     switch (cmd.type) {
       case 'STOP':
-        if (workerClient) {
-          await workerClient.stop();
-        }
-        if (kvStore?.close) {
-          await kvStore.close();
-        }
-        process.exit(0);
+        await stopWorker();
+        gracefulExit(0);
         break;
 
       case 'SEND_TX':
@@ -424,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) {
@@ -440,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);
 
@@ -456,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,
@@ -491,7 +543,12 @@ process.on('message', async msg => {
       }
     }
   } catch (err: any) {
-    process.send!({ type: 'ERROR', error: err.message });
-    process.exit(1);
+    try {
+      process.send!({ type: 'ERROR', error: err.message });
+    } catch {
+      // IPC channel may be closed
+    }
+    await stopWorker();
+    gracefulExit(1);
   }
 });

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;
@@ -72,7 +63,6 @@ class WorkerClientManager {
   destroy() {
     this.cleanup().catch((error: Error) => {
       this.logger.error('Failed to cleanup worker client manager', error);
-      process.exit(1);
     });
   }
 
@@ -81,13 +71,15 @@ class WorkerClientManager {
    * Note: We send the raw peerIdPrivateKey string instead of SecretValue
    * because SecretValue.toJSON() returns '[Redacted]', losing the value.
    * The worker must re-wrap it in SecretValue.
+   * We also omit priceBumpPercentage since it's a bigint and can't be
+   * serialized over IPC (which uses JSON under the hood).
    */
   private createClientConfig(
     clientIndex: number,
     port: number,
     otherNodes: string[],
-  ): Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey: string } & Partial<ChainConfig> {
-    return {
+  ): Omit<P2PConfig, 'peerIdPrivateKey' | 'priceBumpPercentage'> & { peerIdPrivateKey: string } & Partial<ChainConfig> {
+    const { priceBumpPercentage: _, ...config } = {
       ...getP2PDefaultConfig(),
       p2pEnabled: true,
       peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
@@ -96,7 +88,10 @@ class WorkerClientManager {
       p2pPort: port,
       bootstrapNodes: [...otherNodes],
       ...this.p2pConfig,
-    } as Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey: string } & Partial<ChainConfig>;
+    };
+    return config as Omit<P2PConfig, 'peerIdPrivateKey' | 'priceBumpPercentage'> & {
+      peerIdPrivateKey: string;
+    } & Partial<ChainConfig>;
   }
 
   /**
@@ -104,7 +99,9 @@ class WorkerClientManager {
    * Config uses raw string for peerIdPrivateKey (not SecretValue) for IPC serialization.
    */
   private spawnWorkerProcess(
-    config: Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey: string } & Partial<ChainConfig>,
+    config: Omit<P2PConfig, 'peerIdPrivateKey' | 'priceBumpPercentage'> & {
+      peerIdPrivateKey: string;
+    } & Partial<ChainConfig>,
     clientIndex: number,
   ): [ChildProcess, Promise<void>] {
     const useCompiled = existsSync(workerJsPath);
@@ -418,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.
    *
@@ -438,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>[] = [];
 
@@ -450,7 +500,6 @@ class WorkerClientManager {
         txCount: config.txCount,
         peerCount,
         distribution: config.distribution,
-        collectorType: config.collectorType,
         timeoutMs: config.timeoutMs,
         isAggregator: false,
         peerIndex: i,
@@ -472,7 +521,6 @@ class WorkerClientManager {
       txCount: config.txCount,
       peerCount,
       distribution: config.distribution,
-      collectorType: config.collectorType,
       timeoutMs: config.timeoutMs,
       isAggregator: true,
       peerIndex: 0,
@@ -483,7 +531,8 @@ class WorkerClientManager {
     };
 
     this.processes[0].send(aggregatorCmd);
-    const result = await this.waitForBenchResult(0, config.timeoutMs + 30000);
+    const aggregatorBudgetMs = config.timeoutMs + BENCHMARK_CONSTANTS.MAX_PEER_WAIT_MS + 30000;
+    const result = await this.waitForBenchResult(0, aggregatorBudgetMs);
 
     this.logger.info(
       `Benchmark complete: fetched=${result.fetchedCount}/${config.txCount}, duration=${result.durationMs.toFixed(0)}ms, success=${result.success}`,
@@ -492,7 +541,6 @@ class WorkerClientManager {
     return {
       txCount: config.txCount,
       distribution: config.distribution,
-      collector: config.collectorType,
       durationMs: result.durationMs,
       fetchedCount: result.fetchedCount,
       success: result.success,
@@ -570,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,13 +1,13 @@
 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/kv-store/config';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
 import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
 import { generateKeyPair, marshalPrivateKey, unmarshalPrivateKey } from '@libp2p/crypto/keys';
 import type { Identify } from '@libp2p/identify';
 import type { PeerId, PrivateKey } from '@libp2p/interface';
-import type { ConnectionManager } from '@libp2p/interface-internal';
+import type { AddressManager, ConnectionManager } from '@libp2p/interface-internal';
 import { createFromPrivKey } from '@libp2p/peer-id-factory';
 import { resolve } from 'dns/promises';
 import { promises as fs } from 'fs';
@@ -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';
 
@@ -23,8 +23,17 @@ export interface PubSubLibp2p extends Pick<Libp2p, 'status' | 'start' | 'stop' |
   services: {
     pubsub: Pick<
       GossipSub,
-      'addEventListener' | 'removeEventListener' | 'publish' | 'subscribe' | 'reportMessageValidationResult' | 'direct'
+      | 'addEventListener'
+      | 'removeEventListener'
+      | 'publish'
+      | 'subscribe'
+      | 'reportMessageValidationResult'
+      | 'direct'
+      | 'getMeshPeers'
     > & { score: Pick<GossipSub['score'], 'score'> };
+    components: {
+      addressManager: Pick<AddressManager, 'addObservedAddr' | 'confirmObservedAddr' | 'removeObservedAddr'>;
+    };
   };
 }
 
@@ -33,6 +42,7 @@ export type FullLibp2p = Libp2p<{
   pubsub: GossipSub;
   components: {
     connectionManager: ConnectionManager;
+    addressManager: AddressManager;
   };
 }>;
 
@@ -54,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 {
@@ -101,18 +120,20 @@ export async function configureP2PClientAddresses(
 ): Promise<P2PConfig & DataStoreConfig> {
   const config = { ..._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;
   }
 
-  // check if no announce IP was provided
-  if (!p2pIp) {
-    if (queryForIp) {
-      const publicIp = await getPublicIp();
-      config.p2pIp = publicIp;
-    }
+  // 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