@aztec/p2p 0.51.0 → 0.52.0

package/src/service/libp2p_service.ts

@@ -6,6 +6,7 @@ import {
   TopicType,
   TopicTypeMap,
   Tx,
+  TxHash,
 } from '@aztec/circuit-types';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
@@ -30,6 +31,18 @@ import { type TxPool } from '../tx_pool/index.js';
 import { convertToMultiaddr } from '../util.js';
 import { AztecDatastore } from './data_store.js';
 import { PeerManager } from './peer_manager.js';
+import { pingHandler, statusHandler } from './reqresp/handlers.js';
+import {
+  DEFAULT_SUB_PROTOCOL_HANDLERS,
+  PING_PROTOCOL,
+  type ReqRespSubProtocol,
+  type ReqRespSubProtocolHandlers,
+  STATUS_PROTOCOL,
+  type SubProtocolMap,
+  TX_REQ_PROTOCOL,
+  subProtocolMap,
+} from './reqresp/interface.js';
+import { ReqResp } from './reqresp/reqresp.js';
 import type { P2PService, PeerDiscoveryService } from './service.js';
 
 export interface PubSubLibp2p extends Libp2p {
@@ -61,6 +74,14 @@ export class LibP2PService implements P2PService {
   private peerManager: PeerManager;
   private discoveryRunningPromise?: RunningPromise;
 
+  // Request and response sub service
+  private reqresp: ReqResp;
+
+  /**
+   * Callback for when a block is received from a peer.
+   * @param block - The block received from the peer.
+   * @returns The attestation for the block, if any.
+   */
   private blockReceivedCallback: (block: BlockProposal) => Promise<BlockAttestation | undefined>;
 
   constructor(
@@ -69,9 +90,11 @@ export class LibP2PService implements P2PService {
     private peerDiscoveryService: PeerDiscoveryService,
     private txPool: TxPool,
     private attestationPool: AttestationPool,
+    private requestResponseHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS,
     private logger = createDebugLogger('aztec:libp2p_service'),
   ) {
     this.peerManager = new PeerManager(node, peerDiscoveryService, config, logger);
+    this.reqresp = new ReqResp(node);
 
     this.blockReceivedCallback = (block: BlockProposal): Promise<BlockAttestation | undefined> => {
       this.logger.verbose(
@@ -124,6 +147,7 @@ export class LibP2PService implements P2PService {
       this.peerManager.discover();
     }, this.config.peerCheckIntervalMS);
     this.discoveryRunningPromise.start();
+    await this.reqresp.start(this.requestResponseHandlers);
   }
 
   /**
@@ -140,6 +164,9 @@ export class LibP2PService implements P2PService {
     this.logger.debug('Stopping LibP2P...');
     await this.stopLibP2P();
     this.logger.info('LibP2P service stopped');
+    this.logger.debug('Stopping request response service...');
+    await this.reqresp.stop();
+    this.logger.debug('Request response service stopped...');
   }
 
   /**
@@ -206,9 +233,56 @@ export class LibP2PService implements P2PService {
       },
     });
 
-    return new LibP2PService(config, node, peerDiscoveryService, txPool, attestationPool);
+    // Create request response protocol handlers
+    /**
+     * Handler for tx requests
+     * @param msg - the tx request message
+     * @returns the tx response message
+     */
+    const txHandler = (msg: Buffer): Promise<Uint8Array> => {
+      const txHash = TxHash.fromBuffer(msg);
+      const foundTx = txPool.getTxByHash(txHash);
+      const asUint8Array = Uint8Array.from(foundTx ? foundTx.toBuffer() : Buffer.alloc(0));
+      return Promise.resolve(asUint8Array);
+    };
+
+    const requestResponseHandlers = {
+      [PING_PROTOCOL]: pingHandler,
+      [STATUS_PROTOCOL]: statusHandler,
+      [TX_REQ_PROTOCOL]: txHandler,
+    };
+
+    return new LibP2PService(config, node, peerDiscoveryService, txPool, attestationPool, requestResponseHandlers);
+  }
+
+  /**
+   * Send Request via the ReqResp service
+   * The subprotocol defined will determine the request and response types
+   *
+   * See the subProtocolMap for the mapping of subprotocols to request/response types in `interface.ts`
+   *
+   * @param protocol The request response protocol to use
+   * @param request The request type to send
+   * @returns
+   */
+  async sendRequest<SubProtocol extends ReqRespSubProtocol>(
+    protocol: SubProtocol,
+    request: InstanceType<SubProtocolMap[SubProtocol]['request']>,
+  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
+    const pair = subProtocolMap[protocol];
+
+    const res = await this.reqresp.sendRequest(protocol, request.toBuffer());
+    if (!res) {
+      return undefined;
+    }
+
+    return pair.response.fromBuffer(res!);
   }
 
+  /**
+   * Get the ENR of the node
+   * @returns The ENR of the node
+   */
   public getEnr(): ENR | undefined {
     return this.peerDiscoveryService.getEnr();
   }

package/src/service/reqresp/handlers.ts

@@ -1,7 +1,17 @@
-export function pingHandler(_msg: any) {
-  return Uint8Array.from(Buffer.from('pong'));
+/**
+ * Handles the ping request.
+ * @param _msg - The ping request message.
+ * @returns A resolved promise with the pong response.
+ */
+export function pingHandler(_msg: any): Promise<Uint8Array> {
+  return Promise.resolve(Uint8Array.from(Buffer.from('pong')));
 }
 
-export function statusHandler(_msg: any) {
-  return Uint8Array.from(Buffer.from('ok'));
+/**
+ * Handles the status request.
+ * @param _msg - The status request message.
+ * @returns A resolved promise with the ok response.
+ */
+export function statusHandler(_msg: any): Promise<Uint8Array> {
+  return Promise.resolve(Uint8Array.from(Buffer.from('ok')));
 }

package/src/service/reqresp/interface.ts

@@ -1,13 +1,100 @@
-export enum ReqRespType {
-  Status = 'status',
-  Ping = 'ping',
-  /** Ask peers for specific transactions */
-  TxsByHash = 'txs_by_hash',
-}
+import { Tx, TxHash } from '@aztec/circuit-types';
 
+/*
+ * Request Response Sub Protocols
+ */
 export const PING_PROTOCOL = '/aztec/ping/0.1.0';
 export const STATUS_PROTOCOL = '/aztec/status/0.1.0';
+export const TX_REQ_PROTOCOL = '/aztec/tx_req/0.1.0';
+
+// Sum type for sub protocols
+export type ReqRespSubProtocol = typeof PING_PROTOCOL | typeof STATUS_PROTOCOL | typeof TX_REQ_PROTOCOL;
+
+/**
+ * A handler for a sub protocol
+ * The message will arrive as a buffer, and the handler must return a buffer
+ */
+export type ReqRespSubProtocolHandler = (msg: Buffer) => Promise<Uint8Array>;
+
+/**
+ * A type mapping from supprotocol to it's handling funciton
+ */
+export type ReqRespSubProtocolHandlers = Record<ReqRespSubProtocol, ReqRespSubProtocolHandler>;
+
+/**
+ * Sub protocol map determines the request and response types for each
+ * Req Resp protocol
+ */
+export type SubProtocolMap = {
+  [S in ReqRespSubProtocol]: RequestResponsePair<any, any>;
+};
+
+/**
+ * Default handler for unimplemented sub protocols, this SHOULD be overwritten
+ * by the service, but is provided as a fallback
+ */
+const defaultHandler = (_msg: any): Promise<Uint8Array> => {
+  return Promise.resolve(Uint8Array.from(Buffer.from('unimplemented')));
+};
 
-export type SubProtocol = typeof PING_PROTOCOL | typeof STATUS_PROTOCOL;
+/**
+ * Default sub protocol handlers - this SHOULD be overwritten by the service,
+ */
+export const DEFAULT_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
+  [PING_PROTOCOL]: defaultHandler,
+  [STATUS_PROTOCOL]: defaultHandler,
+  [TX_REQ_PROTOCOL]: defaultHandler,
+};
+
+/**
+ * The Request Response Pair interface defines the methods that each
+ * request response pair must implement
+ */
+interface RequestResponsePair<Req, Res> {
+  request: new (...args: any[]) => Req;
+  /**
+   * The response must implement the static fromBuffer method (generic serialisation)
+   */
+  response: {
+    new (...args: any[]): Res;
+    fromBuffer(buffer: Buffer): Res;
+  };
+}
+
+/**
+ * RequestableBuffer is a wrapper around a buffer that allows it to be
+ * used in generic request response protocols
+ *
+ * An instance of the RequestResponsePair defined above
+ */
+export class RequestableBuffer {
+  constructor(public buffer: Buffer) {}
+
+  toBuffer() {
+    return this.buffer;
+  }
+
+  static fromBuffer(buffer: Buffer) {
+    return new RequestableBuffer(buffer);
+  }
+}
 
-export type SubProtocolHandler = (msg: string) => Uint8Array;
+/**
+ * A mapping from each protocol to their request and response types
+ * This defines the request and response types for each sub protocol, used primarily
+ * as a type rather than an object
+ */
+export const subProtocolMap: SubProtocolMap = {
+  [PING_PROTOCOL]: {
+    request: RequestableBuffer,
+    response: RequestableBuffer,
+  },
+  [STATUS_PROTOCOL]: {
+    request: RequestableBuffer,
+    response: RequestableBuffer,
+  },
+  [TX_REQ_PROTOCOL]: {
+    request: TxHash,
+    response: Tx,
+  },
+};

package/src/service/reqresp/reqresp.ts

@@ -6,22 +6,30 @@ 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';
+import {
+  DEFAULT_SUB_PROTOCOL_HANDLERS,
+  type ReqRespSubProtocol,
+  type ReqRespSubProtocolHandlers,
+} from './interface.js';
 
 /**
- * A mapping from a protocol to a handler function
+ * The Request Response Service
+ *
+ * It allows nodes to request specific information from their peers, its use case covers recovering
+ * information that was missed during a syncronisation or a gossip event.
+ *
+ * This service implements the request response sub protocol, it is heavily inspired from
+ * ethereum implementations of the same name.
+ *
+ * see: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#the-reqresp-domain
  */
-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();
 
+  private subProtocolHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
+
   constructor(protected readonly libp2p: Libp2p) {
     this.logger = createDebugLogger('aztec:p2p:reqresp');
   }
@@ -29,10 +37,11 @@ export class ReqResp {
   /**
    * Start the reqresp service
    */
-  async start() {
+  async start(subProtocolHandlers: ReqRespSubProtocolHandlers) {
+    this.subProtocolHandlers = subProtocolHandlers;
     // 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));
+    for (const subProtocol of Object.keys(this.subProtocolHandlers)) {
+      await this.libp2p.handle(subProtocol, this.streamHandler.bind(this, subProtocol as ReqRespSubProtocol));
     }
   }
 
@@ -41,7 +50,7 @@ export class ReqResp {
    */
   async stop() {
     // Unregister all handlers
-    for (const protocol of Object.keys(SUB_PROTOCOL_HANDLERS)) {
+    for (const protocol of Object.keys(this.subProtocolHandlers)) {
       await this.libp2p.unhandle(protocol);
     }
     await this.libp2p.stop();
@@ -55,7 +64,7 @@ export class ReqResp {
    * @param payload - The payload to send
    * @returns - The response from the peer, otherwise undefined
    */
-  async sendRequest(subProtocol: SubProtocol, payload: Buffer): Promise<Buffer | undefined> {
+  async sendRequest(subProtocol: ReqRespSubProtocol, payload: Buffer): Promise<Buffer | undefined> {
     // Get active peers
     const peers = this.libp2p.getPeers();
 
@@ -64,7 +73,8 @@ export class ReqResp {
       const response = await this.sendRequestToPeer(peer, subProtocol, payload);
 
       // If we get a response, return it, otherwise we iterate onto the next peer
-      if (response) {
+      // We do not consider it a success if we have an empty buffer
+      if (response && response.length > 0) {
         return response;
       }
     }
@@ -79,7 +89,11 @@ export class ReqResp {
    * @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> {
+  async sendRequestToPeer(
+    peerId: PeerId,
+    subProtocol: ReqRespSubProtocol,
+    payload: Buffer,
+  ): Promise<Buffer | undefined> {
     try {
       const stream = await this.libp2p.dialProtocol(peerId, subProtocol);
 
@@ -109,14 +123,17 @@ export class ReqResp {
    *
    * @param param0 - The incoming stream data
    */
-  private async streamHandler(protocol: SubProtocol, { stream }: IncomingStreamData) {
+  private async streamHandler(protocol: ReqRespSubProtocol, { stream }: IncomingStreamData) {
+    // Store a reference to from this for the async generator
+    const handler = this.subProtocolHandlers[protocol];
+
     try {
       await pipe(
         stream,
-        async function* (source) {
+        async function* (source: any) {
           for await (const chunkList of source) {
-            const msg = Buffer.from(chunkList.subarray()).toString();
-            yield SUB_PROTOCOL_HANDLERS[protocol](msg);
+            const msg = Buffer.from(chunkList.subarray());
+            yield handler(msg);
           }
         },
         stream,

package/src/service/service.ts

@@ -4,6 +4,8 @@ import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import type EventEmitter from 'events';
 
+import { type ReqRespSubProtocol, type SubProtocolMap } from './reqresp/interface.js';
+
 export enum PeerDiscoveryState {
   RUNNING = 'running',
   STOPPED = 'stopped',
@@ -31,6 +33,18 @@ export interface P2PService {
    */
   propagate<T extends Gossipable>(message: T): void;
 
+  /**
+   * Request information from peers via the request response protocol.
+   *
+   * @param protocol - The request response protocol to use
+   * @param request - The request type, corresponding to the protocol
+   * @returns The response type, corresponding to the protocol
+   */
+  sendRequest<Protocol extends ReqRespSubProtocol>(
+    protocol: Protocol,
+    request: InstanceType<SubProtocolMap[Protocol]['request']>,
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
+
   // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
   registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation>): void;