@aztec/p2p 0.60.0 → 0.62.0

package/src/mocks/index.ts

@@ -1,11 +1,27 @@
-import { type ClientProtocolCircuitVerifier, type Tx } from '@aztec/circuit-types';
+import {
+  type ClientProtocolCircuitVerifier,
+  type L2BlockSource,
+  type Tx,
+  type WorldStateSynchronizer,
+} from '@aztec/circuit-types';
+import { type DataStoreConfig } from '@aztec/kv-store/utils';
+import { type TelemetryClient } from '@aztec/telemetry-client';
 
+import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { bootstrap } from '@libp2p/bootstrap';
+import { identify } from '@libp2p/identify';
+import { type PeerId } from '@libp2p/interface';
 import { tcp } from '@libp2p/tcp';
+import getPort from 'get-port';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 
+import { BootstrapNode } from '../bootstrap/bootstrap.js';
+import { type BootnodeConfig, type P2PConfig } from '../config.js';
+import { type MemPools } from '../mem_pools/interface.js';
+import { DiscV5Service } from '../service/discV5_service.js';
+import { LibP2PService, createLibP2PPeerId } from '../service/libp2p_service.js';
 import { type PeerManager } from '../service/peer_manager.js';
 import { type P2PReqRespConfig } from '../service/reqresp/config.js';
 import { pingHandler, statusHandler } from '../service/reqresp/handlers.js';
@@ -18,20 +34,35 @@ import {
   noopValidator,
 } from '../service/reqresp/interface.js';
 import { ReqResp } from '../service/reqresp/reqresp.js';
+import { type PubSubLibp2p } from '../util.js';
 
 /**
  * Creates a libp2p node, pre configured.
  * @param boostrapAddrs - an optional list of bootstrap addresses
  * @returns Lip2p node
  */
-export async function createLibp2pNode(boostrapAddrs: string[] = []): Promise<Libp2p> {
+export async function createLibp2pNode(
+  boostrapAddrs: string[] = [],
+  peerId?: PeerId,
+  port?: number,
+  enableGossipSub: boolean = false,
+  start: boolean = true,
+): Promise<Libp2p> {
+  port = port ?? (await getPort());
   const options: Libp2pOptions = {
+    start,
     addresses: {
-      listen: ['/ip4/0.0.0.0/tcp/0'],
+      listen: [`/ip4/0.0.0.0/tcp/${port}`],
+      announce: [`/ip4/0.0.0.0/tcp/${port}`],
     },
     connectionEncryption: [noise()],
     streamMuxers: [yamux()],
     transports: [tcp()],
+    services: {
+      identify: identify({
+        protocolPrefix: 'aztec',
+      }),
+    },
   };
 
   if (boostrapAddrs.length > 0) {
@@ -42,9 +73,65 @@ export async function createLibp2pNode(boostrapAddrs: string[] = []): Promise<Li
     ];
   }
 
+  if (peerId) {
+    options.peerId = peerId;
+  }
+
+  if (enableGossipSub) {
+    options.services!.pubsub = gossipsub({
+      allowPublishToZeroTopicPeers: true,
+    });
+  }
+
   return await createLibp2p(options);
 }
 
+/**
+ * Test Libp2p service
+ * P2P functionality is operational, however everything else is default
+ *
+ * WORKTODO: more description
+ */
+export async function createTestLibP2PService(
+  boostrapAddrs: string[] = [],
+  l2BlockSource: L2BlockSource,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  mempools: MemPools,
+  telemetry: TelemetryClient,
+  port: number = 0,
+  peerId?: PeerId,
+) {
+  peerId = peerId ?? (await createLibP2PPeerId());
+  const config = {
+    tcpAnnounceAddress: `127.0.0.1:${port}`,
+    udpAnnounceAddress: `127.0.0.1:${port}`,
+    tcpListenAddress: `0.0.0.0:${port}`,
+    udpListenAddress: `0.0.0.0:${port}`,
+    bootstrapNodes: boostrapAddrs,
+    peerCheckIntervalMS: 1000,
+    minPeerCount: 1,
+    maxPeerCount: 5,
+    p2pEnabled: true,
+    peerIdPrivateKey: Buffer.from(peerId.privateKey!).toString('hex'),
+  } as P2PConfig & DataStoreConfig;
+  const discoveryService = new DiscV5Service(peerId, config);
+  const proofVerifier = new AlwaysTrueCircuitVerifier();
+
+  // No bootstrap nodes provided as the libp2p service will register them in the constructor
+  const p2pNode = await createLibp2pNode([], peerId, port, /*enable gossip */ true, /**start */ false);
+
+  return new LibP2PService(
+    config,
+    p2pNode as PubSubLibp2p,
+    discoveryService,
+    mempools,
+    l2BlockSource,
+    proofVerifier,
+    worldStateSynchronizer,
+    telemetry,
+  );
+}
+
 /**
  * A p2p / req resp node pairing the req node will always contain the p2p node.
  * they are provided as a pair to allow access the p2p node directly
@@ -88,10 +175,12 @@ export const startNodes = async (
 };
 
 export const stopNodes = async (nodes: ReqRespNode[]): Promise<void> => {
+  const stopPromises = [];
   for (const node of nodes) {
-    await node.req.stop();
-    await node.p2p.stop();
+    stopPromises.push(node.req.stop());
+    stopPromises.push(node.p2p.stop());
   }
+  await Promise.all(stopPromises);
 };
 
 // Create a req resp node, exposing the underlying p2p node
@@ -132,3 +221,32 @@ export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier
     return Promise.resolve(false);
   }
 }
+
+// Bootnodes
+export function createBootstrapNodeConfig(privateKey: string, port: number): BootnodeConfig {
+  return {
+    udpListenAddress: `0.0.0.0:${port}`,
+    udpAnnounceAddress: `127.0.0.1:${port}`,
+    peerIdPrivateKey: privateKey,
+    minPeerCount: 10,
+    maxPeerCount: 100,
+  };
+}
+
+export function createBootstrapNodeFromPrivateKey(privateKey: string, port: number): Promise<BootstrapNode> {
+  const config = createBootstrapNodeConfig(privateKey, port);
+  return startBootstrapNode(config);
+}
+
+export async function createBootstrapNode(port: number): Promise<BootstrapNode> {
+  const peerId = await createLibP2PPeerId();
+  const config = createBootstrapNodeConfig(Buffer.from(peerId.privateKey!).toString('hex'), port);
+
+  return startBootstrapNode(config);
+}
+
+async function startBootstrapNode(config: BootnodeConfig) {
+  const bootstrapNode = new BootstrapNode();
+  await bootstrapNode.start(config);
+  return bootstrapNode;
+}

package/src/service/peer_scoring.ts

@@ -32,14 +32,14 @@ export class PeerScoring {
   peerPenalties: { [key in PeerErrorSeverity]: number };
 
   constructor(config: P2PConfig) {
-    const orderedValues = config.peerPenaltyValues.sort((a, b) => a - b);
+    const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
     this.peerPenalties = {
       [PeerErrorSeverity.HighToleranceError]:
-        orderedValues[0] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
+        orderedValues?.[0] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
       [PeerErrorSeverity.MidToleranceError]:
-        orderedValues[1] ?? DefaultPeerPenalties[PeerErrorSeverity.MidToleranceError],
+        orderedValues?.[1] ?? DefaultPeerPenalties[PeerErrorSeverity.MidToleranceError],
       [PeerErrorSeverity.LowToleranceError]:
-        orderedValues[2] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
+        orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
     };
   }
 

package/src/util.ts

@@ -1,7 +1,11 @@
+import { type DataStoreConfig } from '@aztec/kv-store/utils';
+
 import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
 import { resolve } from 'dns/promises';
 import type { Libp2p } from 'libp2p';
 
+import { type P2PConfig } from './config.js';
+
 export interface PubSubLibp2p extends Libp2p {
   services: {
     pubsub: GossipSub;
@@ -88,3 +92,52 @@ function addressToMultiAddressType(address: string): 'ip4' | 'ip6' | 'dns' {
     return 'dns';
   }
 }
+
+export async function configureP2PClientAddresses(
+  _config: P2PConfig & DataStoreConfig,
+): Promise<P2PConfig & DataStoreConfig> {
+  const config = { ..._config };
+  const {
+    tcpAnnounceAddress: configTcpAnnounceAddress,
+    udpAnnounceAddress: configUdpAnnounceAddress,
+    queryForIp,
+  } = config;
+
+  config.tcpAnnounceAddress = configTcpAnnounceAddress
+    ? await resolveAddressIfNecessary(configTcpAnnounceAddress)
+    : undefined;
+  config.udpAnnounceAddress = configUdpAnnounceAddress
+    ? await resolveAddressIfNecessary(configUdpAnnounceAddress)
+    : undefined;
+
+  // create variable for re-use if needed
+  let publicIp;
+
+  // check if no announce IP was provided
+  const splitTcpAnnounceAddress = splitAddressPort(configTcpAnnounceAddress || '', true);
+  if (splitTcpAnnounceAddress.length == 2 && splitTcpAnnounceAddress[0] === '') {
+    if (queryForIp) {
+      publicIp = await getPublicIp();
+      const tcpAnnounceAddress = `${publicIp}:${splitTcpAnnounceAddress[1]}`;
+      config.tcpAnnounceAddress = tcpAnnounceAddress;
+    } else {
+      throw new Error(
+        `Invalid announceTcpAddress provided: ${configTcpAnnounceAddress}. Expected format: <addr>:<port>`,
+      );
+    }
+  }
+
+  const splitUdpAnnounceAddress = splitAddressPort(configUdpAnnounceAddress || '', true);
+  if (splitUdpAnnounceAddress.length == 2 && splitUdpAnnounceAddress[0] === '') {
+    // If announceUdpAddress is not provided, use announceTcpAddress
+    if (!queryForIp && config.tcpAnnounceAddress) {
+      config.udpAnnounceAddress = config.tcpAnnounceAddress;
+    } else if (queryForIp) {
+      const udpPublicIp = publicIp || (await getPublicIp());
+      const udpAnnounceAddress = `${udpPublicIp}:${splitUdpAnnounceAddress[1]}`;
+      config.udpAnnounceAddress = udpAnnounceAddress;
+    }
+  }
+
+  return config;
+}