@aztec/p2p 0.35.1 → 0.37.0

package/src/config.ts

@@ -8,10 +8,15 @@ export interface P2PConfig {
   p2pEnabled: boolean;
 
   /**
-   * The frequency in which to check.
+   * The frequency in which to check for new L2 blocks.
    */
   p2pBlockCheckIntervalMS: number;
 
+  /**
+   * The frequency in which to check for new peers.
+   */
+  p2pPeerCheckIntervalMS: number;
+
   /**
    * Size of queue of L2 blocks to store.
    */
@@ -27,6 +32,16 @@ export interface P2PConfig {
    */
   tcpListenIp: string;
 
+  /**
+   * The udp port on which the P2P service should listen for connections. Used for Discv5 peer discovery.
+   */
+  udpListenPort: number;
+
+  /**
+   * The udp IP on which the P2P service should listen for connections. Used for Discv5 peer discovery.
+   */
+  udpListenIp: string;
+
   /**
    * An optional peer id private key. If blank, will generate a random key.
    */
@@ -52,11 +67,6 @@ export interface P2PConfig {
    */
   announcePort?: number;
 
-  /**
-   * Optional specification to run as a client in the Kademlia routing protocol.
-   */
-  clientKADRouting: boolean;
-
   /**
    * Whether to enable NAT from libp2p (ignored for bootstrap node).
    */
@@ -71,6 +81,11 @@ export interface P2PConfig {
    * The maximum number of peers (a peer count above this will cause the node to refuse connection attempts)
    */
   maxPeerCount: number;
+
+  /**
+   * Data directory for peer & tx databases.
+   */
+  dataDirectory?: string;
 }
 
 /**
@@ -81,33 +96,39 @@ export function getP2PConfigEnvVars(): P2PConfig {
   const {
     P2P_ENABLED,
     P2P_BLOCK_CHECK_INTERVAL_MS,
+    P2P_PEER_CHECK_INTERVAL_MS,
     P2P_L2_BLOCK_QUEUE_SIZE,
     P2P_TCP_LISTEN_PORT,
     P2P_TCP_LISTEN_IP,
+    P2P_UDP_LISTEN_PORT,
+    P2P_UDP_LISTEN_IP,
     PEER_ID_PRIVATE_KEY,
     BOOTSTRAP_NODES,
     P2P_ANNOUNCE_HOSTNAME,
     P2P_ANNOUNCE_PORT,
-    P2P_KAD_CLIENT,
     P2P_NAT_ENABLED,
     P2P_MIN_PEERS,
     P2P_MAX_PEERS,
+    DATA_DIRECTORY,
   } = process.env;
   const envVars: P2PConfig = {
     p2pEnabled: P2P_ENABLED === 'true',
     p2pBlockCheckIntervalMS: P2P_BLOCK_CHECK_INTERVAL_MS ? +P2P_BLOCK_CHECK_INTERVAL_MS : 100,
+    p2pPeerCheckIntervalMS: P2P_PEER_CHECK_INTERVAL_MS ? +P2P_PEER_CHECK_INTERVAL_MS : 1000,
     p2pL2QueueSize: P2P_L2_BLOCK_QUEUE_SIZE ? +P2P_L2_BLOCK_QUEUE_SIZE : 1000,
     tcpListenPort: P2P_TCP_LISTEN_PORT ? +P2P_TCP_LISTEN_PORT : 40400,
     tcpListenIp: P2P_TCP_LISTEN_IP ? P2P_TCP_LISTEN_IP : '0.0.0.0',
+    udpListenPort: P2P_UDP_LISTEN_PORT ? +P2P_UDP_LISTEN_PORT : 40400,
+    udpListenIp: P2P_UDP_LISTEN_IP ? P2P_UDP_LISTEN_IP : '0.0.0.0',
     peerIdPrivateKey: PEER_ID_PRIVATE_KEY,
     bootstrapNodes: BOOTSTRAP_NODES ? BOOTSTRAP_NODES.split(',') : [],
     transactionProtocol: '',
     announceHostname: P2P_ANNOUNCE_HOSTNAME,
     announcePort: P2P_ANNOUNCE_PORT ? +P2P_ANNOUNCE_PORT : undefined,
-    clientKADRouting: P2P_KAD_CLIENT === 'true',
     enableNat: P2P_NAT_ENABLED === 'true',
     minPeerCount: P2P_MIN_PEERS ? +P2P_MIN_PEERS : 10,
     maxPeerCount: P2P_MAX_PEERS ? +P2P_MAX_PEERS : 100,
+    dataDirectory: DATA_DIRECTORY,
   };
   return envVars;
 }

package/src/service/discV5_service.ts

@@ -0,0 +1,122 @@
+import { createDebugLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+
+import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
+import { type 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 type { PeerDiscoveryService } from './service.js';
+
+export enum PeerDiscoveryState {
+  RUNNING = 'running',
+  STOPPED = 'stopped',
+}
+
+/**
+ * Peer discovery service using Discv5.
+ */
+export class DiscV5Service extends EventEmitter implements PeerDiscoveryService {
+  /** The Discv5 instance */
+  private discv5: Discv5;
+
+  /** This instance's ENR */
+  private enr: SignableENR;
+
+  /** The interval for checking for new peers */
+  private discoveryInterval: NodeJS.Timeout | null = null;
+
+  private runningPromise: RunningPromise;
+
+  private currentState = PeerDiscoveryState.STOPPED;
+
+  constructor(private peerId: PeerId, config: P2PConfig, private logger = createDebugLogger('aztec:discv5_service')) {
+    super();
+    const { announceHostname, tcpListenPort, udpListenIp, udpListenPort, bootstrapNodes } = config;
+    // create ENR from PeerId
+    this.enr = SignableENR.createFromPeerId(peerId);
+
+    const multiAddrUdp = multiaddr(`${announceHostname}/udp/${udpListenPort}/p2p/${peerId.toString()}`);
+    const multiAddrTcp = multiaddr(`${announceHostname}/tcp/${tcpListenPort}/p2p/${peerId.toString()}`);
+
+    const listenMultiAddrUdp = multiaddr(`/ip4/${udpListenIp}/udp/${udpListenPort}`);
+
+    // set location multiaddr in ENR record
+    this.enr.setLocationMultiaddr(multiAddrUdp);
+    this.enr.setLocationMultiaddr(multiAddrTcp);
+
+    this.discv5 = Discv5.create({
+      enr: this.enr,
+      peerId,
+      bindAddrs: { ip4: listenMultiAddrUdp },
+      config: {
+        lookupTimeout: 2000,
+      },
+    });
+
+    this.logger.info(`ENR NodeId: ${this.enr.nodeId}`);
+    this.logger.info(`ENR UDP: ${multiAddrUdp.toString()}`);
+
+    (this.discv5 as Discv5EventEmitter).on('discovered', (enr: ENR) => this.onDiscovered(enr));
+    (this.discv5 as Discv5EventEmitter).on('enrAdded', async (enr: ENR) => {
+      const multiAddrTcp = await enr.getFullMultiaddr('tcp');
+      const multiAddrUdp = await enr.getFullMultiaddr('udp');
+      this.logger.debug(`ENR multiaddr: ${multiAddrTcp?.toString()}, ${multiAddrUdp?.toString()}`);
+    });
+
+    // Add bootnode ENR if provided
+    if (bootstrapNodes?.length) {
+      this.logger.info(`Adding bootstrap ENRs: ${bootstrapNodes.join(', ')}`);
+      try {
+        bootstrapNodes.forEach(enr => {
+          this.discv5.addEnr(enr);
+        });
+      } catch (e) {
+        this.logger.error(`Error adding bootnode ENRs: ${e}`);
+      }
+    }
+
+    this.runningPromise = new RunningPromise(async () => {
+      await this.discv5.findRandomNode();
+    }, config.p2pPeerCheckIntervalMS);
+  }
+
+  public async start(): Promise<void> {
+    if (this.currentState === PeerDiscoveryState.RUNNING) {
+      throw new Error('DiscV5Service already started');
+    }
+    this.logger.info('Starting DiscV5');
+    await this.discv5.start();
+    this.logger.info('DiscV5 started');
+    this.currentState = PeerDiscoveryState.RUNNING;
+    this.runningPromise.start();
+  }
+
+  public getAllPeers(): ENR[] {
+    return this.discv5.kadValues();
+  }
+
+  public getEnr(): ENR {
+    return this.enr.toENR();
+  }
+
+  public getPeerId(): PeerId {
+    return this.peerId;
+  }
+
+  public getStatus(): PeerDiscoveryState {
+    return this.currentState;
+  }
+
+  public async stop(): Promise<void> {
+    await this.runningPromise.stop();
+    await this.discv5.stop();
+    this.currentState = PeerDiscoveryState.STOPPED;
+  }
+
+  private onDiscovered(enr: ENR) {
+    this.emit('peer:discovered', enr);
+  }
+}

package/src/service/dummy_service.ts

@@ -1,6 +1,8 @@
 import { type Tx, type TxHash } from '@aztec/circuit-types';
 
-import { type P2PService } from './service.js';
+import EventEmitter from 'events';
+
+import type { P2PService, PeerDiscoveryService } from './service.js';
 
 /**
  * A dummy implementation of the P2P Service.
@@ -34,3 +36,30 @@ export class DummyP2PService implements P2PService {
    */
   public settledTxs(_: TxHash[]) {}
 }
+
+/**
+ * A dummy implementation of the Peer Discovery Service.
+ */
+export class DummyPeerDiscoveryService extends EventEmitter implements PeerDiscoveryService {
+  /**
+   * Starts the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public start() {
+    return Promise.resolve();
+  }
+  /**
+   * Stops the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public stop() {
+    return Promise.resolve();
+  }
+  /**
+   * Called to discover peers in the network.
+   * @returns An array of discovered peer addresses.
+   */
+  public getAllPeers() {
+    return [];
+  }
+}

package/src/service/known_txs.ts

@@ -1,4 +1,4 @@
-import { type PeerId } from '@libp2p/interface-peer-id';
+import { type PeerId } from '@libp2p/interface';
 
 /**
  * Keeps a record of which Peers have 'seen' which transactions.

package/src/service/libp2p_service.ts

@@ -1,25 +1,27 @@
 import { type Tx, type TxHash } from '@aztec/circuit-types';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { type AztecKVStore } from '@aztec/kv-store';
 
+import { ENR } from '@chainsafe/enr';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
-import { bootstrap } from '@libp2p/bootstrap';
+import { identify } from '@libp2p/identify';
+import type { IncomingStreamData, PeerId, Stream } from '@libp2p/interface';
 import type { ServiceMap } from '@libp2p/interface-libp2p';
-import { type PeerId } from '@libp2p/interface-peer-id';
-import { type IncomingStreamData } from '@libp2p/interface/stream-handler';
-import { type DualKadDHT, kadDHT } from '@libp2p/kad-dht';
+import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
+import { peerIdFromString } from '@libp2p/peer-id';
 import { createFromJSON, createSecp256k1PeerId, exportToProtobuf } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { pipe } from 'it-pipe';
 import { type Libp2p, type Libp2pOptions, type ServiceFactoryMap, createLibp2p } from 'libp2p';
-import { identifyService } from 'libp2p/identify';
 
 import { type P2PConfig } from '../config.js';
 import { type TxPool } from '../tx_pool/index.js';
 import { KnownTxLookup } from './known_txs.js';
-import { type P2PService } from './service.js';
+import { AztecPeerDb, type AztecPeerStore } from './peer_store.js';
+import type { P2PService, PeerDiscoveryService } from './service.js';
 import {
   Messages,
   createGetTransactionsRequestMessage,
@@ -65,8 +67,11 @@ export class LibP2PService implements P2PService {
   constructor(
     private config: P2PConfig,
     private node: Libp2p,
+    private peerDiscoveryService: PeerDiscoveryService,
+    private peerStore: AztecPeerStore,
     private protocolId: string,
     private txPool: TxPool,
+    private bootstrapPeerIds: PeerId[] = [],
     private logger = createDebugLogger('aztec:libp2p_service'),
   ) {}
 
@@ -75,7 +80,7 @@ export class LibP2PService implements P2PService {
    * @returns An empty promise.
    */
   public async start() {
-    if (this.node.isStarted()) {
+    if (this.node.status === 'started') {
       throw new Error('P2P service already started');
     }
     const { enableNat, tcpListenIp, tcpListenPort, announceHostname, announcePort } = this.config;
@@ -87,6 +92,11 @@ export class LibP2PService implements P2PService {
       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:discovery', evt => {
       const peerId = evt.detail.id;
       if (this.isBootstrapPeer(peerId)) {
@@ -109,12 +119,12 @@ export class LibP2PService implements P2PService {
     });
 
     this.jobQueue.start();
+    await this.peerDiscoveryService.start();
     await this.node.start();
     await this.node.handle(this.protocolId, (incoming: IncomingStreamData) =>
       this.jobQueue.put(() => Promise.resolve(this.handleProtocolDial(incoming))),
     );
-    const dht = this.node.services['kadDHT'] as DualKadDHT;
-    this.logger.info(`Started P2P client as ${await dht.getMode()} with Peer ID ${this.node.peerId.toString()}`);
+    this.logger.info(`Started P2P client with Peer ID ${this.node.peerId.toString()}`);
   }
 
   /**
@@ -135,25 +145,19 @@ export class LibP2PService implements P2PService {
    * @param txPool - The transaction pool to be accessed by the service.
    * @returns The new service.
    */
-  public static async new(config: P2PConfig, txPool: TxPool) {
-    const {
-      tcpListenIp,
-      tcpListenPort,
-      announceHostname,
-      announcePort,
-      clientKADRouting,
-      minPeerCount,
-      maxPeerCount,
-      peerIdPrivateKey,
-    } = config;
-    const peerId = await createLibP2PPeerId(peerIdPrivateKey);
-
+  public static async new(
+    config: P2PConfig,
+    peerDiscoveryService: PeerDiscoveryService,
+    peerId: PeerId,
+    txPool: TxPool,
+    store: AztecKVStore,
+  ) {
+    const { tcpListenIp, tcpListenPort, minPeerCount, maxPeerCount } = config;
     const opts: Libp2pOptions<ServiceMap> = {
       start: false,
       peerId,
       addresses: {
         listen: [`/ip4/${tcpListenIp}/tcp/${tcpListenPort}`],
-        announce: announceHostname ? [`${announceHostname}/tcp/${announcePort ?? tcpListenPort}`] : [],
       },
       transports: [tcp()],
       streamMuxers: [yamux(), mplex()],
@@ -162,21 +166,12 @@ export class LibP2PService implements P2PService {
         minConnections: minPeerCount,
         maxConnections: maxPeerCount,
       },
-      peerDiscovery: [
-        bootstrap({
-          list: config.bootstrapNodes,
-        }),
-      ],
     };
 
     const services: ServiceFactoryMap = {
-      identify: identifyService({
+      identify: identify({
         protocolPrefix: 'aztec',
       }),
-      kadDHT: kadDHT({
-        protocolPrefix: 'aztec',
-        clientMode: clientKADRouting,
-      }),
     };
 
     // The autonat service seems quite problematic in that using it seems to cause a lot of attempts
@@ -198,7 +193,19 @@ export class LibP2PService implements P2PService {
       services,
     });
     const protocolId = config.transactionProtocol;
-    return new LibP2PService(config, node, protocolId, txPool);
+
+    // Create an LMDB peer store
+    const peerDb = new AztecPeerDb(store);
+
+    // 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, peerDb, protocolId, txPool, bootstrapPeerIds);
   }
 
   /**
@@ -217,6 +224,44 @@ export class LibP2PService implements P2PService {
     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 ${enr.peerId().toString()}. Adding to libp2p peer list`);
+      let stream: Stream | undefined;
+      try {
+        stream = await this.node.dialProtocol(peerMultiAddr, this.protocolId);
+
+        // dial successful, add to DB as well
+        if (!this.peerStore.getPeer(peerIdStr)) {
+          await this.peerStore.addPeer(peerIdStr, enr);
+        }
+      } catch (err) {
+        this.logger.error(`Failed to dial peer ${peerIdStr}`, err);
+      } finally {
+        if (stream) {
+          await stream.close();
+        }
+      }
+    }
+  }
+
   private async handleProtocolDial(incomingStreamData: IncomingStreamData) {
     try {
       const { message, peer } = await this.consumeInboundStream(incomingStreamData);
@@ -392,6 +437,6 @@ export class LibP2PService implements P2PService {
   }
 
   private isBootstrapPeer(peer: PeerId) {
-    return this.config.bootstrapNodes.findIndex(bootstrap => bootstrap.includes(peer.toString())) != -1;
+    return this.bootstrapPeerIds.some(bootstrapPeer => bootstrapPeer.equals(peer));
   }
 }

package/src/service/peer_store.ts

@@ -0,0 +1,36 @@
+import type { AztecKVStore, AztecMap } from '@aztec/kv-store';
+
+import type { ENR } from '@chainsafe/enr';
+
+export interface AztecPeerStore {
+  addPeer(peerId: string, enr: ENR): Promise<void>;
+  removePeer(peerId: string): Promise<void>;
+  getPeer(peerId: string): ENR | undefined;
+  getAllPeers(): IterableIterator<ENR>;
+}
+
+export class AztecPeerDb implements AztecPeerStore {
+  #peers: AztecMap<string, ENR>;
+
+  constructor(private db: AztecKVStore) {
+    this.#peers = db.openMap('p2p_peers');
+  }
+
+  async addPeer(peerId: string, enr: ENR): Promise<void> {
+    void (await this.#peers.set(peerId, enr));
+  }
+
+  async removePeer(peerId: string): Promise<void> {
+    void (await this.#peers.delete(peerId));
+  }
+
+  getPeer(peerId: string): ENR | undefined {
+    return this.#peers.get(peerId);
+  }
+
+  *getAllPeers(): IterableIterator<ENR> {
+    for (const enr of this.#peers.values()) {
+      yield enr;
+    }
+  }
+}

package/src/service/service.ts

@@ -1,4 +1,7 @@
-import { type Tx, type TxHash } from '@aztec/circuit-types';
+import type { Tx, TxHash } from '@aztec/circuit-types';
+
+import type { ENR } from '@chainsafe/enr';
+import type EventEmitter from 'events';
 
 /**
  * The interface for a P2P service implementation.
@@ -28,3 +31,30 @@ export interface P2PService {
    */
   settledTxs(txHashes: TxHash[]): void;
 }
+
+/**
+ * The interface for a peer discovery service implementation.
+ */
+export interface PeerDiscoveryService extends EventEmitter {
+  /**
+   * Starts the service.
+   * */
+  start(): Promise<void>;
+
+  /**
+   * Stops the service.
+   * */
+  stop(): Promise<void>;
+
+  /**
+   * Gets all peers.
+   * @returns An array of peer ENRs.
+   */
+  getAllPeers(): ENR[];
+
+  /**
+   * Event emitted when a new peer is discovered.
+   */
+  on(event: 'peer:discovered', listener: (enr: ENR) => void): this;
+  emit(event: 'peer:discovered', enr: ENR): boolean;
+}