@aztec/p2p 0.79.0 → 0.81.0

package/src/msg_validators/tx_validator/data_validator.ts

@@ -18,9 +18,11 @@ export class DataTxValidator implements TxValidator<Tx> {
     ];
     if (callRequests.length !== tx.enqueuedPublicFunctionCalls.length) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} because of mismatch number of execution requests for public calls. Expected ${
-          callRequests.length
-        }. Got ${tx.enqueuedPublicFunctionCalls.length}.`,
+        `Rejecting tx ${await Tx.getHash(
+          tx,
+        )} because of mismatch number of execution requests for public calls. Expected ${callRequests.length}. Got ${
+          tx.enqueuedPublicFunctionCalls.length
+        }.`,
       );
       return { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
     }
@@ -66,7 +68,7 @@ export class DataTxValidator implements TxValidator<Tx> {
     const hashedContractClasslogs = await Promise.all(tx.contractClassLogs.map(l => l.hash()));
     if (contractClassLogsHashes.length !== hashedContractClasslogs.length) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
+        `Rejecting tx ${await Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
           contractClassLogsHashes.length
         }. Got ${hashedContractClasslogs.length}.`,
       );
@@ -78,14 +80,14 @@ export class DataTxValidator implements TxValidator<Tx> {
         if (hashedContractClasslogs.some(l => logHash.value.equals(l))) {
           const matchingLogIndex = hashedContractClasslogs.findIndex(l => logHash.value.equals(l));
           this.#log.warn(
-            `Rejecting tx ${Tx.getHash(
+            `Rejecting tx ${await Tx.getHash(
               tx,
             )} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
           );
           return { result: 'invalid', reason: ['Incorrectly sorted contract class logs'] };
         } else {
           this.#log.warn(
-            `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
+            `Rejecting tx ${await Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
               logHash.value
             } from the kernels. Got ${hashedLog} in the tx.`,
           );
@@ -94,7 +96,7 @@ export class DataTxValidator implements TxValidator<Tx> {
       }
       if (logHash.logHash.length !== tx.contractClassLogs[i].getEmittedLength()) {
         this.#log.warn(
-          `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs length. Expected ${
+          `Rejecting tx ${await Tx.getHash(tx)} because of mismatched contract class logs length. Expected ${
             logHash.logHash.length
           } from the kernel's log hashes. Got ${tx.contractClassLogs[i].getEmittedLength()} in the tx.`,
         );

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -9,10 +9,10 @@ export class TxProofValidator implements TxValidator<Tx> {
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!(await this.verifier.verifyProof(tx))) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for invalid proof`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for invalid proof`);
       return { result: 'invalid', reason: ['Invalid proof'] };
     }
-    this.#log.trace(`Accepted ${Tx.getHash(tx)} with valid proof`);
+    this.#log.trace(`Accepted ${await Tx.getHash(tx)} with valid proof`);
     return { result: 'valid' };
   }
 }

package/src/services/discv5/discV5_service.ts

@@ -3,7 +3,7 @@ import { sleep } from '@aztec/foundation/sleep';
 import { type ComponentsVersions, checkCompressedComponentVersion } from '@aztec/stdlib/versioning';
 import { OtelMetricsAdapter, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
+import { Discv5, type Discv5EventEmitter, type IDiscv5CreateOptions } from '@chainsafe/discv5';
 import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
@@ -30,9 +30,6 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   /** Version identifiers. */
   private versions: ComponentsVersions;
 
-  /** UDP listen addr */
-  private listenMultiAddrUdp: Multiaddr;
-
   private currentState = PeerDiscoveryState.STOPPED;
 
   public readonly bootstrapNodes: string[] = [];
@@ -41,14 +38,21 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
 
   private startTime = 0;
 
+  private handlers = {
+    onMultiaddrUpdated: this.onMultiaddrUpdated.bind(this),
+    onDiscovered: this.onDiscovered.bind(this),
+    onEnrAdded: this.onEnrAdded.bind(this),
+  };
+
   constructor(
     private peerId: PeerId,
     private config: P2PConfig,
     telemetry: TelemetryClient = getTelemetryClient(),
     private logger = createLogger('p2p:discv5_service'),
+    configOverrides: Partial<IDiscv5CreateOptions> = {},
   ) {
     super();
-    const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
+    const { p2pIp, p2pPort, bootstrapNodes } = config;
     this.bootstrapNodes = bootstrapNodes ?? [];
     this.bootstrapNodeEnrs = this.bootstrapNodes.map(x => ENR.decodeTxt(x));
     // create ENR from PeerId
@@ -56,31 +60,31 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     // Add aztec identification to ENR
     this.versions = setAztecEnrKey(this.enr, config);
 
-    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 bindAddrs: any = {
+      ip4: multiaddr(convertToMultiaddr(config.listenAddress, p2pPort, 'udp')),
+    };
 
-    this.listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
+    if (p2pIp) {
+      const multiAddrTcp = multiaddr(`${convertToMultiaddr(p2pIp!, p2pPort, 'tcp')}/p2p/${peerId.toString()}`);
+      // if no udp announce address is provided, use the tcp announce address
+      const multiAddrUdp = multiaddr(`${convertToMultiaddr(p2pIp!, p2pPort, 'udp')}/p2p/${peerId.toString()}`);
 
-    // set location multiaddr in ENR record
-    this.enr.setLocationMultiaddr(multiAddrUdp);
-    this.enr.setLocationMultiaddr(multiAddrTcp);
+      // set location multiaddr in ENR record
+      this.enr.setLocationMultiaddr(multiAddrUdp);
+      this.enr.setLocationMultiaddr(multiAddrTcp);
+    }
 
     const metricsRegistry = new OtelMetricsAdapter(telemetry);
     this.discv5 = Discv5.create({
       enr: this.enr,
       peerId,
-      bindAddrs: { ip4: this.listenMultiAddrUdp },
+      bindAddrs,
       config: {
         lookupTimeout: 2000,
         requestTimeout: 2000,
         allowUnverifiedSessions: true,
+        enrUpdate: !p2pIp ? true : false, // If no p2p IP is set, enrUpdate can automatically resolve it
+        ...configOverrides.config,
       },
       metricsRegistry,
     });
@@ -104,8 +108,16 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       }
     };
 
-    this.discv5.on(Discv5Event.DISCOVERED, this.onDiscovered.bind(this));
-    this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
+    this.discv5.on(Discv5Event.DISCOVERED, this.handlers.onDiscovered);
+    this.discv5.on(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+    this.discv5.on(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
+  }
+
+  private onMultiaddrUpdated(m: Multiaddr) {
+    // We want to update our tcp port to match the udp port
+    const multiAddrTcp = multiaddr(convertToMultiaddr(m.nodeAddress().address, this.config.p2pPort, 'tcp'));
+    this.enr.setLocationMultiaddr(multiAddrTcp);
+    this.logger.info('Multiaddr updated', { multiaddr: multiaddr.toString() });
   }
 
   public async start(): Promise<void> {
@@ -187,8 +199,9 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   }
 
   public async stop(): Promise<void> {
-    await this.discv5.off(Discv5Event.DISCOVERED, this.onDiscovered);
-    await this.discv5.off(Discv5Event.ENR_ADDED, this.onEnrAdded);
+    await this.discv5.off(Discv5Event.DISCOVERED, this.handlers.onDiscovered);
+    await this.discv5.off(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+    await this.discv5.off(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
 
     await this.discv5.stop();
 

package/src/services/libp2p/libp2p_service.ts

@@ -168,10 +168,8 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     telemetry: TelemetryClient,
     logger = createLogger('p2p:libp2p_service'),
   ) {
-    const { tcpListenAddress, tcpAnnounceAddress, 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 { p2pPort, maxPeerCount, listenAddress } = config;
+    const bindAddrTcp = convertToMultiaddr(listenAddress, p2pPort, 'tcp');
 
     const datastore = new AztecDatastore(store);
 
@@ -193,7 +191,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       peerId,
       addresses: {
         listen: [bindAddrTcp],
-        announce: [announceAddrTcp],
+        announce: [], // announce is handled by the peer discovery service
       },
       transports: [
         tcp({
@@ -299,11 +297,11 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     }
 
     // Get listen & announce addresses for logging
-    const { tcpListenAddress, tcpAnnounceAddress } = this.config;
-    if (!tcpAnnounceAddress) {
+    const { p2pIp, p2pPort } = this.config;
+    if (!p2pIp) {
       throw new Error('Announce address not provided.');
     }
-    const announceTcpMultiaddr = convertToMultiaddr(tcpAnnounceAddress, 'tcp');
+    const announceTcpMultiaddr = convertToMultiaddr(p2pIp, p2pPort, 'tcp');
 
     // Start job queue, peer discovery service and libp2p node
     this.jobQueue.start();
@@ -349,7 +347,8 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     };
     await this.reqresp.start(requestResponseHandlers, reqrespSubProtocolValidators);
     this.logger.info(`Started P2P service`, {
-      listen: tcpListenAddress,
+      listen: this.config.listenAddress,
+      port: this.config.p2pPort,
       announce: announceTcpMultiaddr,
       peerId: this.node.peerId.toString(),
     });

package/src/test-helpers/make-enrs.ts

@@ -30,10 +30,9 @@ export async function makeEnr(p2pPrivateKey: string, port: number, config: Chain
   const peerId = await createLibP2PPeerIdFromPrivateKey(p2pPrivateKey);
   const enr = SignableENR.createFromPeerId(peerId);
 
-  const udpAnnounceAddress = `127.0.0.1:${port}`;
-  const tcpAnnounceAddress = `127.0.0.1:${port}`;
-  const udpPublicAddr = multiaddr(convertToMultiaddr(udpAnnounceAddress, 'udp'));
-  const tcpPublicAddr = multiaddr(convertToMultiaddr(tcpAnnounceAddress, 'tcp'));
+  const p2pIp = `127.0.0.1`;
+  const udpPublicAddr = multiaddr(convertToMultiaddr(p2pIp, port, 'udp'));
+  const tcpPublicAddr = multiaddr(convertToMultiaddr(p2pIp, port, 'tcp'));
 
   // ENRS must include the network and a discoverable address (udp for discv5)
   setAztecEnrKey(enr, config);

package/src/test-helpers/make-test-p2p-clients.ts

@@ -50,19 +50,14 @@ export async function makeTestP2PClient(
     logger = createLogger('p2p-test-client'),
   }: MakeTestP2PClientOptions,
 ) {
-  const addr = `127.0.0.1:${port}`;
-  const listenAddr = `0.0.0.0:${port}`;
-
   // Filter nodes so that we only dial active peers
 
   const config: P2PConfig & DataStoreConfig = {
     ...p2pBaseConfig,
     p2pEnabled: true,
     peerIdPrivateKey,
-    tcpListenAddress: listenAddr, // run on port 0
-    udpListenAddress: listenAddr,
-    tcpAnnounceAddress: addr,
-    udpAnnounceAddress: addr,
+    p2pIp: `127.0.0.1`,
+    p2pPort: port,
     bootstrapNodes: peers,
     peerCheckIntervalMS: 1000,
     maxPeerCount: 10,

package/src/test-helpers/reqresp-nodes.ts

@@ -109,10 +109,8 @@ export async function createTestLibP2PService<T extends P2PClientType>(
 ) {
   peerId = peerId ?? (await createSecp256k1PeerId());
   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}`,
+    p2pIp: `127.0.0.1`,
+    p2pPort: port,
     bootstrapNodes: boostrapAddrs,
     peerCheckIntervalMS: 1000,
     maxPeerCount: 5,
@@ -235,12 +233,13 @@ export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier
 export function createBootstrapNodeConfig(privateKey: string, port: number, chainConfig: ChainConfig): BootnodeConfig {
   return {
     l1ChainId: chainConfig.l1ChainId,
-    udpListenAddress: `0.0.0.0:${port}`,
-    udpAnnounceAddress: `127.0.0.1:${port}`,
+    p2pIp: '127.0.0.1',
+    p2pPort: port,
     peerIdPrivateKey: privateKey,
     dataDirectory: undefined,
     dataStoreMapSizeKB: 0,
     bootstrapNodes: [],
+    listenAddress: '0.0.0.0',
   };
 }
 
@@ -263,7 +262,7 @@ export function createBootstrapNodeFromPrivateKey(
 export async function getBootstrapNodeEnr(privateKey: string, port: number) {
   const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
   const enr = SignableENR.createFromPeerId(peerId);
-  const listenAddrUdp = multiaddr(convertToMultiaddr(`127.0.0.1:${port}`, 'udp'));
+  const listenAddrUdp = multiaddr(convertToMultiaddr('127.0.0.1', port, 'udp'));
   enr.setLocationMultiaddr(listenAddrUdp);
 
   return enr;

package/src/testbench/worker_client_manager.ts

@@ -44,30 +44,21 @@ class WorkerClientManager {
     });
   }
 
-  /**
-   * Creates address strings from a port
-   */
-  private getAddresses(port: number) {
-    return {
-      addr: `127.0.0.1:${port}`,
-      listenAddr: `0.0.0.0:${port}`,
-    };
-  }
-
   /**
    * Creates a client configuration object
    */
-  private createClientConfig(clientIndex: number, port: number, otherNodes: string[]) {
-    const { addr, listenAddr } = this.getAddresses(port);
-
+  private createClientConfig(
+    clientIndex: number,
+    port: number,
+    otherNodes: string[],
+  ): P2PConfig & Partial<ChainConfig> {
     return {
       ...getP2PDefaultConfig(),
       p2pEnabled: true,
       peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
-      tcpListenAddress: listenAddr,
-      udpListenAddress: listenAddr,
-      tcpAnnounceAddress: addr,
-      udpAnnounceAddress: addr,
+      listenAddress: '127.0.0.1',
+      p2pIp: '127.0.0.1',
+      p2pPort: port,
       bootstrapNodes: [...otherNodes],
       ...this.p2pConfig,
     };

package/src/types/index.ts

@@ -17,6 +17,7 @@ export enum PeerEvent {
 export enum Discv5Event {
   DISCOVERED = 'discovered',
   ENR_ADDED = 'enrAdded',
+  MULTIADDR_UPDATED = 'multiaddrUpdated',
 }
 
 /**

package/src/util.ts

@@ -28,41 +28,13 @@ export interface PubSubLibp2p extends Libp2p {
  * @param address - The address string to convert. Has to be in the format <addr>:<port>.
  * @param protocol - The protocol to use in the multiaddr string.
  * @returns A multiaddr compliant string.  */
-export function convertToMultiaddr(address: string, protocol: 'tcp' | 'udp'): string {
-  const [addr, port] = splitAddressPort(address, false);
-
-  const multiaddrPrefix = addressToMultiAddressType(addr);
+export function convertToMultiaddr(address: string, port: number, protocol: 'tcp' | 'udp'): string {
+  const multiaddrPrefix = addressToMultiAddressType(address);
   if (multiaddrPrefix === 'dns') {
     throw new Error('Invalid address format. Expected an IPv4 or IPv6 address.');
   }
 
-  return `/${multiaddrPrefix}/${addr}/${protocol}/${port}`;
-}
-
-/**
- * Splits an <address>:<port> string into its components.
- * @returns The ip6 or ip4 address & port separately
- */
-export function splitAddressPort(address: string, allowEmptyAddress: boolean): [string, string] {
-  let addr: string;
-  let port: string;
-
-  if (address.startsWith('[')) {
-    // IPv6 address enclosed in square brackets
-    const match = address.match(/^\[([^\]]+)\]:(\d+)$/);
-    if (!match) {
-      throw new Error(`Invalid IPv6 address format:${address}. Expected format: [<addr>]:<port>`);
-    }
-    [, addr, port] = match;
-  } else {
-    // IPv4 address
-    [addr, port] = address.split(':');
-    if ((!addr && !allowEmptyAddress) || !port) {
-      throw new Error(`Invalid address format: ${address}. Expected format: <addr>:<port>`);
-    }
-  }
-
-  return [addr, port];
+  return `/${multiaddrPrefix}/${address}/${protocol}/${port}`;
 }
 
 /**
@@ -74,13 +46,12 @@ export async function getPublicIp(): Promise<string> {
   return text.trim();
 }
 
-export async function resolveAddressIfNecessary(address: string): Promise<string> {
-  const [addr, port] = splitAddressPort(address, false);
-  const multiaddrPrefix = addressToMultiAddressType(addr);
+export async function resolveAddressIfNecessary(address: string, port: string): Promise<string> {
+  const multiaddrPrefix = addressToMultiAddressType(address);
   if (multiaddrPrefix === 'dns') {
-    const resolvedAddresses = await resolve(addr);
+    const resolvedAddresses = await resolve(address);
     if (resolvedAddresses.length === 0) {
-      throw new Error(`Could not resolve address: ${addr}`);
+      throw new Error(`Could not resolve address: ${address}`);
     }
     return `${resolvedAddresses[0]}:${port}`;
   } else {
@@ -104,47 +75,16 @@ 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;
+  const { p2pIp, queryForIp } = config;
 
   // check if no announce IP was provided
-  const splitTcpAnnounceAddress = splitAddressPort(configTcpAnnounceAddress || '', true);
-  if (splitTcpAnnounceAddress.length == 2 && splitTcpAnnounceAddress[0] === '') {
+  if (!p2pIp) {
     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;
+      const publicIp = await getPublicIp();
+      config.p2pIp = publicIp;
     }
   }
+  // TODO(md): guard against setting a local ip address as the announce ip
 
   return config;
 }