@aztec/p2p 0.42.0 → 0.44.0

package/src/service/discV5_service.ts

@@ -1,17 +1,20 @@
 import { createDebugLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
+import { sleep } from '@aztec/foundation/sleep';
 
 import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
-import { type ENR, SignableENR } from '@chainsafe/enr';
+import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { multiaddr } from '@multiformats/multiaddr';
 import EventEmitter from 'events';
 
 import type { P2PConfig } from '../config.js';
+import { convertToMultiaddr } from '../util.js';
 import { type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
 
 export const AZTEC_ENR_KEY = 'aztec_network';
 
+const delayBeforeStart = 2000; // 2sec
+
 export enum AztecENR {
   devnet = 0x01,
   testnet = 0x02,
@@ -31,26 +34,33 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   /** This instance's ENR */
   private enr: SignableENR;
 
-  private runningPromise: RunningPromise;
-
   private currentState = PeerDiscoveryState.STOPPED;
 
   private bootstrapNodes: string[];
+  private bootstrapNodePeerIds: PeerId[] = [];
+
+  private startTime = 0;
 
   constructor(private peerId: PeerId, config: P2PConfig, private logger = createDebugLogger('aztec:discv5_service')) {
     super();
-    const { announceUdpHostname, announceTcpHostname, tcpListenPort, udpListenIp, udpListenPort, bootstrapNodes } =
-      config;
+    const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
     this.bootstrapNodes = bootstrapNodes;
     // create ENR from PeerId
     this.enr = SignableENR.createFromPeerId(peerId);
     // Add aztec identification to ENR
     this.enr.set(AZTEC_ENR_KEY, Uint8Array.from([AZTEC_NET]));
 
-    const multiAddrUdp = multiaddr(`${announceUdpHostname}/udp/${udpListenPort}/p2p/${peerId.toString()}`);
-    const multiAddrTcp = multiaddr(`${announceTcpHostname}/tcp/${tcpListenPort}/p2p/${peerId.toString()}`);
+    if (!tcpAnnounceAddress) {
+      throw new Error('You need to provide at least a TCP announce address.');
+    }
+
+    const multiAddrTcp = multiaddr(`${convertToMultiaddr(tcpAnnounceAddress, 'tcp')}/p2p/${peerId.toString()}`);
+    // if no udp announce address is provided, use the tcp announce address
+    const multiAddrUdp = multiaddr(
+      `${convertToMultiaddr(udpAnnounceAddress || tcpAnnounceAddress, 'udp')}/p2p/${peerId.toString()}`,
+    );
 
-    const listenMultiAddrUdp = multiaddr(`/ip4/${udpListenIp}/udp/${udpListenPort}`);
+    const listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
 
     // set location multiaddr in ENR record
     this.enr.setLocationMultiaddr(multiAddrUdp);
@@ -75,18 +85,18 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       const multiAddrUdp = await enr.getFullMultiaddr('udp');
       this.logger.debug(`ENR multiaddr: ${multiAddrTcp?.toString()}, ${multiAddrUdp?.toString()}`);
     });
-
-    this.runningPromise = new RunningPromise(async () => {
-      await this.discv5.findRandomNode();
-    }, config.p2pPeerCheckIntervalMS);
   }
 
   public async start(): Promise<void> {
+    // Do this conversion once since it involves an async function call
+    this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodes.map(enr => ENR.decodeTxt(enr).peerId()));
     if (this.currentState === PeerDiscoveryState.RUNNING) {
       throw new Error('DiscV5Service already started');
     }
     this.logger.info('Starting DiscV5');
     await this.discv5.start();
+    this.startTime = Date.now();
+
     this.logger.info('DiscV5 started');
     this.currentState = PeerDiscoveryState.RUNNING;
 
@@ -101,8 +111,25 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
         this.logger.error(`Error adding bootnode ENRs: ${e}`);
       }
     }
+  }
 
-    this.runningPromise.start();
+  public async runRandomNodesQuery(): Promise<void> {
+    if (this.currentState !== PeerDiscoveryState.RUNNING) {
+      throw new Error('DiscV5Service not running');
+    }
+
+    // First, wait some time before starting the peer discovery
+    // reference: https://github.com/ChainSafe/lodestar/issues/3423
+    const msSinceStart = Date.now() - this.startTime;
+    if (Date.now() - this.startTime <= delayBeforeStart) {
+      await sleep(delayBeforeStart - msSinceStart);
+    }
+
+    try {
+      await this.discv5.findRandomNode();
+    } catch (err) {
+      this.logger.error(`Error running discV5 random node query: ${err}`);
+    }
   }
 
   public getAllPeers(): ENR[] {
@@ -121,8 +148,11 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     return this.currentState;
   }
 
+  public isBootstrapPeer(peerId: PeerId): boolean {
+    return this.bootstrapNodePeerIds.some(node => node.equals(peerId));
+  }
+
   public async stop(): Promise<void> {
-    await this.runningPromise.stop();
     await this.discv5.stop();
     this.currentState = PeerDiscoveryState.STOPPED;
   }

package/src/service/dummy_service.ts

@@ -1,5 +1,6 @@
-import { type Tx, type TxHash } from '@aztec/circuit-types';
+import type { Tx, TxHash } from '@aztec/circuit-types';
 
+import type { PeerId } from '@libp2p/interface';
 import EventEmitter from 'events';
 
 import { type P2PService, type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
@@ -66,6 +67,14 @@ export class DummyPeerDiscoveryService extends EventEmitter implements PeerDisco
     return [];
   }
 
+  public runRandomNodesQuery(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public isBootstrapPeer(_: PeerId): boolean {
+    return false;
+  }
+
   public getStatus(): PeerDiscoveryState {
     return this.currentState;
   }

package/src/service/libp2p_service.ts

@@ -1,25 +1,24 @@
-import { type Tx, type TxHash } from '@aztec/circuit-types';
+import { type Tx } from '@aztec/circuit-types';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { type AztecKVStore } from '@aztec/kv-store';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import type { AztecKVStore } from '@aztec/kv-store';
 
-import { ENR } from '@chainsafe/enr';
 import { type GossipsubEvents, gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { identify } from '@libp2p/identify';
-import type { PeerId, PubSub, Stream } from '@libp2p/interface';
+import type { PeerId, PubSub } from '@libp2p/interface';
 import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
-import { peerIdFromString } from '@libp2p/peer-id';
 import { createFromJSON, createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { type Libp2p, createLibp2p } from 'libp2p';
 
 import { type P2PConfig } from '../config.js';
 import { type TxPool } from '../tx_pool/index.js';
+import { convertToMultiaddr } from '../util.js';
 import { AztecDatastore } from './data_store.js';
-import { KnownTxLookup } from './known_txs.js';
 import { PeerManager } from './peer_manager.js';
 import type { P2PService, PeerDiscoveryService } from './service.js';
 import { AztecTxMessageCreator, fromTxMessage } from './tx_messages.js';
@@ -29,7 +28,6 @@ export interface PubSubLibp2p extends Libp2p {
     pubsub: PubSub<GossipsubEvents>;
   };
 }
-
 /**
  * Create a libp2p peer ID from the private key if provided, otherwise creates a new random ID.
  * @param privateKey - Optional peer ID private key as hex string
@@ -51,16 +49,14 @@ export async function createLibP2PPeerId(privateKey?: string): Promise<PeerId> {
  */
 export class LibP2PService implements P2PService {
   private jobQueue: SerialQueue = new SerialQueue();
-  private knownTxLookup: KnownTxLookup = new KnownTxLookup();
   private messageCreator: AztecTxMessageCreator;
   private peerManager: PeerManager;
+  private discoveryRunningPromise?: RunningPromise;
   constructor(
     private config: P2PConfig,
     private node: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
-    private protocolId: string,
     private txPool: TxPool,
-    private bootstrapPeerIds: PeerId[] = [],
     private logger = createDebugLogger('aztec:libp2p_service'),
   ) {
     this.messageCreator = new AztecTxMessageCreator(config.txGossipVersion);
@@ -72,53 +68,42 @@ export class LibP2PService implements P2PService {
    * @returns An empty promise.
    */
   public async start() {
+    // Check if service is already started
     if (this.node.status === 'started') {
       throw new Error('P2P service already started');
     }
-    const { enableNat, tcpListenIp, tcpListenPort, announceTcpHostname, announcePort } = this.config;
-    this.logger.info(`Starting P2P node on ${tcpListenIp}:${tcpListenPort}`);
-    if (announceTcpHostname) {
-      this.logger.info(`Announcing at ${announceTcpHostname}/tcp/${announcePort ?? tcpListenPort}`);
-    }
-    if (enableNat) {
-      this.logger.info(`Enabling NAT in libp2p module`);
-    }
-
-    // handle discovered peers from external discovery service
-    this.peerDiscoveryService.on('peer:discovered', async (enr: ENR) => {
-      await this.addPeer(enr);
-    });
 
-    this.node.addEventListener('peer:connect', async evt => {
-      const peerId = evt.detail;
-      await this.handleNewConnection(peerId as PeerId);
-    });
-
-    this.node.addEventListener('peer:disconnect', async evt => {
-      const peerId = evt.detail;
-      if (this.isBootstrapPeer(peerId)) {
-        this.logger.verbose(`Disconnect from bootstrap peer ${peerId.toString()}`);
-      } else {
-        this.logger.verbose(`Disconnected from transaction peer ${peerId.toString()}`);
-        await this.peerManager.updateDiscoveryService();
-      }
-    });
+    // Log listen & announce addresses
+    const { tcpListenAddress, tcpAnnounceAddress } = this.config;
+    this.logger.info(`Starting P2P node on ${tcpListenAddress}`);
+    if (!tcpAnnounceAddress) {
+      throw new Error('Announce address not provided.');
+    }
+    const announceTcpMultiaddr = convertToMultiaddr(tcpAnnounceAddress, 'tcp');
+    this.logger.info(`Announcing at ${announceTcpMultiaddr}`);
 
+    // Start job queue, peer discovery service and libp2p node
     this.jobQueue.start();
     await this.peerDiscoveryService.start();
     await this.node.start();
     this.logger.info(`Started P2P client with Peer ID ${this.node.peerId.toString()}`);
 
-    // Subscribe to standard topics by default
+    // Subscribe to standard GossipSub topics by default
     this.subscribeToTopic(this.messageCreator.getTopic());
 
-    // add gossipsub listener
+    // add GossipSub listener
     this.node.services.pubsub.addEventListener('gossipsub:message', async e => {
       const { msg } = e.detail;
       this.logger.debug(`Received PUBSUB message.`);
 
       await this.jobQueue.put(() => this.handleNewGossipMessage(msg.topic, msg.data));
     });
+
+    // Start running promise for peer discovery
+    this.discoveryRunningPromise = new RunningPromise(() => {
+      this.peerManager.discover();
+    }, this.config.p2pPeerCheckIntervalMS);
+    this.discoveryRunningPromise.start();
   }
 
   /**
@@ -128,8 +113,12 @@ export class LibP2PService implements P2PService {
   public async stop() {
     this.logger.debug('Stopping job queue...');
     await this.jobQueue.end();
+    this.logger.debug('Stopping running promise...');
+    await this.discoveryRunningPromise?.stop();
+    this.logger.debug('Stopping peer discovery service...');
+    await this.peerDiscoveryService.stop();
     this.logger.debug('Stopping LibP2P...');
-    await this.node.stop();
+    await this.stopLibP2P();
     this.logger.info('LibP2P service stopped');
   }
 
@@ -146,8 +135,12 @@ export class LibP2PService implements P2PService {
     txPool: TxPool,
     store: AztecKVStore,
   ) {
-    const { tcpListenIp, tcpListenPort, minPeerCount, maxPeerCount, transactionProtocol: protocolId } = config;
-    const bindAddrTcp = `/ip4/${tcpListenIp}/tcp/${tcpListenPort}`;
+    const { tcpListenAddress, tcpAnnounceAddress, minPeerCount, maxPeerCount } = config;
+    const bindAddrTcp = convertToMultiaddr(tcpListenAddress, 'tcp');
+    // We know tcpAnnounceAddress cannot be null here because we set it or throw when setting up the service.
+    const announceAddrTcp = convertToMultiaddr(tcpAnnounceAddress!, 'tcp');
+
+    const datastore = new AztecDatastore(store);
 
     // The autonat service seems quite problematic in that using it seems to cause a lot of attempts
     // to dial ephemeral ports. I suspect that it works better if you can get the uPNPnat service to
@@ -163,17 +156,24 @@ export class LibP2PService implements P2PService {
     //   services.uPnPNAT = uPnPNATService();
     // }
 
-    const datastore = new AztecDatastore(store);
-
     const node = await createLibp2p({
       start: false,
       peerId,
       addresses: {
         listen: [bindAddrTcp],
+        announce: [announceAddrTcp],
       },
       transports: [
         tcp({
           maxConnections: config.maxPeerCount,
+          // socket option: the maximum length of the queue of pending connections
+          // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
+          // it's not safe if we increase this number
+          backlog: 5,
+          closeServerOnMaxConnections: {
+            closeAbove: maxPeerCount ?? Infinity,
+            listenBelow: maxPeerCount ?? Infinity,
+          },
         }),
       ],
       datastore,
@@ -199,15 +199,7 @@ export class LibP2PService implements P2PService {
       },
     });
 
-    // extract bootstrap node peer IDs
-    let bootstrapPeerIds: PeerId[] = [];
-    if (config.bootstrapNodes.length) {
-      bootstrapPeerIds = await Promise.all(
-        config.bootstrapNodes.map(bootnodeEnr => ENR.decodeTxt(bootnodeEnr).peerId()),
-      );
-    }
-
-    return new LibP2PService(config, node, peerDiscoveryService, protocolId, txPool, bootstrapPeerIds);
+    return new LibP2PService(config, node, peerDiscoveryService, txPool);
   }
 
   /**
@@ -259,71 +251,31 @@ export class LibP2PService implements P2PService {
     void this.jobQueue.put(() => Promise.resolve(this.sendTxToPeers(tx)));
   }
 
-  /**
-   * Handles the settling of a new batch of transactions.
-   * @param txHashes - The hashes of the newly settled transactions.
-   */
-  public settledTxs(txHashes: TxHash[]): void {
-    this.knownTxLookup.handleSettledTxs(txHashes.map(x => x.toString()));
-  }
-
-  private async addPeer(enr: ENR) {
-    const peerMultiAddr = await enr.getFullMultiaddr('tcp');
-    if (!peerMultiAddr) {
-      // No TCP address, can't connect
-      return;
-    }
-    const peerIdStr = peerMultiAddr.getPeerId();
-
-    if (!peerIdStr) {
-      this.logger.debug(`Peer ID not found in discovered node's multiaddr: ${peerMultiAddr}`);
-      return;
-    }
-
-    // check if peer is already known
-    const peerId = peerIdFromString(peerIdStr);
-    const hasPeer = await this.node.peerStore.has(peerId);
-
-    // add to peer store if not already known
-    if (!hasPeer) {
-      this.logger.info(`Discovered peer ${peerIdStr}. Adding to libp2p peer list`);
-      let stream: Stream | undefined;
-      try {
-        stream = await this.node.dialProtocol(peerMultiAddr, this.protocolId);
-      } catch (err) {
-        this.logger.error(`Failed to dial peer ${peerIdStr}`, err);
-      } finally {
-        if (stream) {
-          await stream.close();
-        }
-      }
-    }
-  }
-
-  private async handleNewConnection(peerId: PeerId) {
-    if (this.isBootstrapPeer(peerId)) {
-      this.logger.verbose(`Connected to bootstrap peer ${peerId.toString()}`);
-    } else {
-      this.logger.verbose(`Connected to transaction peer ${peerId.toString()}`);
-      await this.peerManager.updateDiscoveryService();
-    }
-  }
-
   private async processTxFromPeer(tx: Tx): Promise<void> {
     const txHash = tx.getTxHash();
     const txHashString = txHash.toString();
-    this.logger.debug(`Received tx ${txHashString} from external peer.`);
+    this.logger.verbose(`Received tx ${txHashString} from external peer.`);
     await this.txPool.addTxs([tx]);
   }
 
   private async sendTxToPeers(tx: Tx) {
     const { data: txData } = this.messageCreator.createTxMessage(tx);
-    this.logger.debug(`Sending tx ${tx.getTxHash().toString()} to peers`);
+    this.logger.verbose(`Sending tx ${tx.getTxHash().toString()} to peers`);
     const recipientsNum = await this.publishToTopic(this.messageCreator.getTopic(), txData);
-    this.logger.debug(`Sent tx ${tx.getTxHash().toString()} to ${recipientsNum} peers`);
+    this.logger.verbose(`Sent tx ${tx.getTxHash().toString()} to ${recipientsNum} peers`);
   }
 
-  private isBootstrapPeer(peer: PeerId) {
-    return this.bootstrapPeerIds.some(bootstrapPeer => bootstrapPeer.equals(peer));
+  // Libp2p seems to hang sometimes if new peers are initiating connections.
+  private async stopLibP2P() {
+    const TIMEOUT_MS = 5000; // 5 seconds timeout
+    const timeout = new Promise((resolve, reject) => {
+      setTimeout(() => reject(new Error('Timeout during libp2p.stop()')), TIMEOUT_MS);
+    });
+    try {
+      await Promise.race([this.node.stop(), timeout]);
+      this.logger.debug('Libp2p stopped');
+    } catch (error) {
+      this.logger.error('Error during stop or timeout:', error);
+    }
   }
 }

package/src/service/peer_manager.ts

@@ -1,26 +1,201 @@
 import { createDebugLogger } from '@aztec/foundation/log';
 
+import { type ENR } from '@chainsafe/enr';
+import { type PeerId } from '@libp2p/interface';
+import { type Multiaddr } from '@multiformats/multiaddr';
 import { type Libp2p } from 'libp2p';
 
 import { type P2PConfig } from '../config.js';
-import { type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
+import { type PeerDiscoveryService } from './service.js';
+
+const MAX_DIAL_ATTEMPTS = 3;
+const MAX_CACHED_PEERS = 100;
+
+type CachedPeer = {
+  peerId: PeerId;
+  enr: ENR;
+  multiaddrTcp: Multiaddr;
+  dialAttempts: number;
+};
 
 export class PeerManager {
+  private cachedPeers: Map<string, CachedPeer> = new Map();
   constructor(
     private libP2PNode: Libp2p,
-    private discV5Node: PeerDiscoveryService,
+    private peerDiscoveryService: PeerDiscoveryService,
     private config: P2PConfig,
     private logger = createDebugLogger('aztec:p2p:peer_manager'),
-  ) {}
-
-  async updateDiscoveryService() {
-    const peerCount = this.libP2PNode.getPeers().length;
-    if (peerCount >= this.config.maxPeerCount && this.discV5Node.getStatus() === PeerDiscoveryState.RUNNING) {
-      this.logger.debug('Max peer count reached, stopping discovery service');
-      await this.discV5Node.stop();
-    } else if (peerCount <= this.config.minPeerCount && this.discV5Node.getStatus() === PeerDiscoveryState.STOPPED) {
-      this.logger.debug('Min peer count reached, starting discovery service');
-      await this.discV5Node.start();
+  ) {
+    // Handle new established connections
+    this.libP2PNode.addEventListener('peer:connect', evt => {
+      const peerId = evt.detail;
+      if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
+        this.logger.debug(`Connected to bootstrap peer ${peerId.toString()}`);
+      } else {
+        this.logger.debug(`Connected to transaction peer ${peerId.toString()}`);
+      }
+    });
+
+    // Handle lost connections
+    this.libP2PNode.addEventListener('peer:disconnect', evt => {
+      const peerId = evt.detail;
+      if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
+        this.logger.debug(`Disconnected from bootstrap peer ${peerId.toString()}`);
+      } else {
+        this.logger.debug(`Disconnected from transaction peer ${peerId.toString()}`);
+      }
+    });
+
+    // Handle Discovered peers
+    this.peerDiscoveryService.on('peer:discovered', async (enr: ENR) => {
+      await this.handleDiscoveredPeer(enr);
+    });
+  }
+
+  /**
+   * Discovers peers.
+   */
+  public discover() {
+    // Get current connections
+    const connections = this.libP2PNode.getConnections();
+
+    // Calculate how many connections we're looking to make
+    const peersToConnect = this.config.maxPeerCount - connections.length;
+
+    this.logger.debug(
+      `Connections: ${connections.length}, Peers to connect: ${peersToConnect}, maxPeerCount: ${this.config.maxPeerCount}, cachedPeers: ${this.cachedPeers.size}`,
+    );
+
+    // Exit if no peers to connect
+    if (peersToConnect <= 0) {
+      return;
+    }
+
+    const cachedPeersToDial: CachedPeer[] = [];
+
+    const pendingDials = new Set(
+      this.libP2PNode
+        .getDialQueue()
+        .map(pendingDial => pendingDial.peerId?.toString())
+        .filter(Boolean) as string[],
+    );
+
+    for (const [id, peerData] of this.cachedPeers.entries()) {
+      // if already dialling or connected to, remove from cache
+      if (pendingDials.has(id) || connections.some(conn => conn.remotePeer.equals(peerData.peerId))) {
+        this.cachedPeers.delete(id);
+      } else {
+        // cachedPeersToDial.set(id, enr);
+        cachedPeersToDial.push(peerData);
+      }
+    }
+
+    // reverse to dial older entries first
+    cachedPeersToDial.reverse();
+
+    for (const peer of cachedPeersToDial) {
+      this.cachedPeers.delete(peer.peerId.toString());
+      void this.dialPeer(peer);
+    }
+
+    // if we need more peers, start randomNodesQuery
+    if (peersToConnect > 0) {
+      this.logger.debug('Running random nodes query');
+      void this.peerDiscoveryService.runRandomNodesQuery();
+    }
+  }
+
+  /**
+   *  Handles a discovered peer.
+   * @param enr - The discovered peer's ENR.
+   */
+  private async handleDiscoveredPeer(enr: ENR) {
+    // TODO: Will be handling peer scoring here
+
+    // check if peer is already connected
+    const [peerId, multiaddrTcp] = await Promise.all([enr.peerId(), enr.getFullMultiaddr('tcp')]);
+
+    this.logger.debug(`Handling discovered peer ${peerId.toString()}, ${multiaddrTcp?.toString()}`);
+
+    // throw if no tcp addr in multiaddr
+    if (!multiaddrTcp) {
+      this.logger.debug(`No TCP address in discovered node's multiaddr: ${enr.toString()}`);
+      return;
+    }
+    const connections = this.libP2PNode.getConnections();
+    if (connections.some(conn => conn.remotePeer.equals(peerId))) {
+      this.logger.debug(`Already connected to peer ${peerId.toString()}`);
+      return;
+    }
+
+    // check if peer is already in cache
+    const id = peerId.toString();
+    if (this.cachedPeers.has(id)) {
+      this.logger.debug(`Already in cache ${id}`);
+      return;
+    }
+
+    // create cached peer object
+    const cachedPeer: CachedPeer = {
+      peerId,
+      enr,
+      multiaddrTcp,
+      dialAttempts: 0,
+    };
+
+    // Determine if we should dial immediately or not
+    if (this.shouldDialPeer()) {
+      this.logger.debug(`Dialing peer ${id}`);
+      void this.dialPeer(cachedPeer);
+    } else {
+      this.logger.debug(`Caching peer ${id}`);
+      this.cachedPeers.set(id, cachedPeer);
+      // Prune set of cached peers
+      this.pruneCachedPeers();
+    }
+  }
+
+  async dialPeer(peer: CachedPeer) {
+    const id = peer.peerId.toString();
+    await this.libP2PNode.peerStore.merge(peer.peerId, { multiaddrs: [peer.multiaddrTcp] });
+
+    this.logger.debug(`Dialing peer ${id}`);
+    try {
+      await this.libP2PNode.dial(peer.multiaddrTcp);
+    } catch {
+      this.logger.debug(`Failed to dial peer ${id}`);
+      peer.dialAttempts++;
+      if (peer.dialAttempts < MAX_DIAL_ATTEMPTS) {
+        this.cachedPeers.set(id, peer);
+      } else {
+        this.cachedPeers.delete(id);
+      }
+    }
+  }
+
+  private shouldDialPeer(): boolean {
+    const connections = this.libP2PNode.getConnections().length;
+    this.logger.debug(`Connections: ${connections}, maxPeerCount: ${this.config.maxPeerCount}`);
+    if (connections >= this.config.maxPeerCount) {
+      this.logger.debug('Not dialing peer, maxPeerCount reached');
+      return false;
+    }
+    return true;
+  }
+
+  private pruneCachedPeers() {
+    let peersToDelete = this.cachedPeers.size - MAX_CACHED_PEERS;
+    if (peersToDelete <= 0) {
+      return;
+    }
+
+    // Remove the oldest peers
+    for (const key of this.cachedPeers.keys()) {
+      this.cachedPeers.delete(key);
+      peersToDelete--;
+      if (peersToDelete <= 0) {
+        break;
+      }
     }
   }
 }

package/src/service/service.ts

@@ -1,6 +1,7 @@
-import type { Tx, TxHash } from '@aztec/circuit-types';
+import type { Tx } from '@aztec/circuit-types';
 
 import type { ENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
 import type EventEmitter from 'events';
 
 export enum PeerDiscoveryState {
@@ -29,12 +30,6 @@ export interface P2PService {
    * @param tx - The transaction to be propagated.
    */
   propagateTx(tx: Tx): void;
-
-  /**
-   * Called upon receipt of settled transactions.
-   * @param txHashes - The hashes of the settled transactions.
-   */
-  settledTxs(txHashes: TxHash[]): void;
 }
 
 /**
@@ -57,6 +52,18 @@ export interface PeerDiscoveryService extends EventEmitter {
    */
   getAllPeers(): ENR[];
 
+  /**
+   * Runs findRandomNode query.
+   */
+  runRandomNodesQuery(): Promise<void>;
+
+  /**
+   * Checks if the given peer is a bootstrap peer.
+   * @param peerId - The peer ID to check.
+   * @returns True if the peer is a bootstrap peer.
+   */
+  isBootstrapPeer(peerId: PeerId): boolean;
+
   /**
    * Event emitted when a new peer is discovered.
    */