@aztec/p2p 0.49.2 → 0.51.0

package/src/service/reqresp/reqresp.ts

@@ -0,0 +1,130 @@
+// @attribution: lodestar impl for inspiration
+import { type Logger, createDebugLogger } from '@aztec/foundation/log';
+
+import { type IncomingStreamData, type PeerId } from '@libp2p/interface';
+import { pipe } from 'it-pipe';
+import { type Libp2p } from 'libp2p';
+import { type Uint8ArrayList } from 'uint8arraylist';
+
+import { pingHandler, statusHandler } from './handlers.js';
+import { PING_PROTOCOL, STATUS_PROTOCOL, type SubProtocol, type SubProtocolHandler } from './interface.js';
+
+/**
+ * A mapping from a protocol to a handler function
+ */
+const SUB_PROTOCOL_HANDLERS: Record<SubProtocol, SubProtocolHandler> = {
+  [PING_PROTOCOL]: pingHandler,
+  [STATUS_PROTOCOL]: statusHandler,
+};
+
+export class ReqResp {
+  protected readonly logger: Logger;
+
+  private abortController: AbortController = new AbortController();
+
+  constructor(protected readonly libp2p: Libp2p) {
+    this.logger = createDebugLogger('aztec:p2p:reqresp');
+  }
+
+  /**
+   * Start the reqresp service
+   */
+  async start() {
+    // Register all protocol handlers
+    for (const subProtocol of Object.keys(SUB_PROTOCOL_HANDLERS)) {
+      await this.libp2p.handle(subProtocol, this.streamHandler.bind(this, subProtocol as SubProtocol));
+    }
+  }
+
+  /**
+   * Stop the reqresp service
+   */
+  async stop() {
+    // Unregister all handlers
+    for (const protocol of Object.keys(SUB_PROTOCOL_HANDLERS)) {
+      await this.libp2p.unhandle(protocol);
+    }
+    await this.libp2p.stop();
+    this.abortController.abort();
+  }
+
+  /**
+   * Send a request to peers, returns the first response
+   *
+   * @param subProtocol - The protocol being requested
+   * @param payload - The payload to send
+   * @returns - The response from the peer, otherwise undefined
+   */
+  async sendRequest(subProtocol: SubProtocol, payload: Buffer): Promise<Buffer | undefined> {
+    // Get active peers
+    const peers = this.libp2p.getPeers();
+
+    // Attempt to ask all of our peers
+    for (const peer of peers) {
+      const response = await this.sendRequestToPeer(peer, subProtocol, payload);
+
+      // If we get a response, return it, otherwise we iterate onto the next peer
+      if (response) {
+        return response;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Sends a request to a specific peer
+   *
+   * @param peerId - The peer to send the request to
+   * @param subProtocol - The protocol to use to request
+   * @param payload - The payload to send
+   * @returns If the request is successful, the response is returned, otherwise undefined
+   */
+  async sendRequestToPeer(peerId: PeerId, subProtocol: SubProtocol, payload: Buffer): Promise<Buffer | undefined> {
+    try {
+      const stream = await this.libp2p.dialProtocol(peerId, subProtocol);
+
+      const result = await pipe([payload], stream, this.readMessage);
+      return result;
+    } catch (e) {
+      this.logger.warn(`Failed to send request to peer ${peerId.publicKey}`);
+      return undefined;
+    }
+  }
+
+  /**
+   * Read a message returned from a stream into a single buffer
+   */
+  private async readMessage(source: AsyncIterable<Uint8ArrayList>): Promise<Buffer> {
+    const chunks: Uint8Array[] = [];
+    for await (const chunk of source) {
+      chunks.push(chunk.subarray());
+    }
+    const messageData = chunks.concat();
+    return Buffer.concat(messageData);
+  }
+
+  /**
+   * Stream Handler
+   * Reads the incoming stream, determines the protocol, then triggers the appropriate handler
+   *
+   * @param param0 - The incoming stream data
+   */
+  private async streamHandler(protocol: SubProtocol, { stream }: IncomingStreamData) {
+    try {
+      await pipe(
+        stream,
+        async function* (source) {
+          for await (const chunkList of source) {
+            const msg = Buffer.from(chunkList.subarray()).toString();
+            yield SUB_PROTOCOL_HANDLERS[protocol](msg);
+          }
+        },
+        stream,
+      );
+    } catch (e: any) {
+      this.logger.warn(e);
+    } finally {
+      await stream.close();
+    }
+  }
+}

package/src/service/service.ts

@@ -1,4 +1,4 @@
-import type { Tx } from '@aztec/circuit-types';
+import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/circuit-types';
 
 import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
@@ -27,9 +27,14 @@ export interface P2PService {
 
   /**
    * Called to have the given transaction propagated through the P2P network.
-   * @param tx - The transaction to be propagated.
+   * @param message - The message to be propagated.
    */
-  propagateTx(tx: Tx): void;
+  propagate<T extends Gossipable>(message: T): void;
+
+  // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
+  registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation>): void;
+
+  getEnr(): ENR | undefined;
 }
 
 /**
@@ -71,4 +76,6 @@ export interface PeerDiscoveryService extends EventEmitter {
   emit(event: 'peer:discovered', enr: ENR): boolean;
 
   getStatus(): PeerDiscoveryState;
+
+  getEnr(): ENR | undefined;
 }

package/src/util.ts

@@ -1,9 +1,10 @@
+import { resolve } from 'dns/promises';
+
 /**
  * Converts an address string to a multiaddr string.
  * Example usage:
  * const tcpAddr = '123.456.7.8:80' -> /ip4/123.456.7.8/tcp/80
  * const udpAddr = '[2001:db8::1]:8080' -> /ip6/2001:db8::1/udp/8080
- * const dnsAddr = 'example.com:443' -> /dns4/example.com/tcp/443
  * @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.
@@ -11,15 +12,8 @@
 export function convertToMultiaddr(address: string, protocol: 'tcp' | 'udp'): string {
   const [addr, port] = splitAddressPort(address, false);
 
-  let multiaddrPrefix: string;
-
-  if (addr.includes(':')) {
-    // IPv6 address
-    multiaddrPrefix = 'ip6';
-  } else if (addr.match(/^[\d.]+$/)) {
-    // IPv4 address
-    multiaddrPrefix = 'ip4';
-  } else {
+  const multiaddrPrefix = addressToMultiAddressType(addr);
+  if (multiaddrPrefix === 'dns') {
     throw new Error('Invalid address format. Expected an IPv4 or IPv6 address.');
   }
 
@@ -60,3 +54,29 @@ export async function getPublicIp(): Promise<string> {
   const text = await resp.text();
   return text.trim();
 }
+
+export async function resolveAddressIfNecessary(address: string): Promise<string> {
+  const [addr, port] = splitAddressPort(address, false);
+  const multiaddrPrefix = addressToMultiAddressType(addr);
+  if (multiaddrPrefix === 'dns') {
+    const resolvedAddresses = await resolve(addr);
+    if (resolvedAddresses.length === 0) {
+      throw new Error(`Could not resolve address: ${addr}`);
+    }
+    return `${resolvedAddresses[0]}:${port}`;
+  } else {
+    return address;
+  }
+}
+
+// Not public because it is not used outside of this file.
+// Plus, it relies on `splitAddressPort` being called on the address first.
+function addressToMultiAddressType(address: string): 'ip4' | 'ip6' | 'dns' {
+  if (address.includes(':')) {
+    return 'ip6';
+  } else if (address.match(/^[\d.]+$/)) {
+    return 'ip4';
+  } else {
+    return 'dns';
+  }
+}