@aztec/p2p 0.71.0 → 0.72.1

package/src/services/reqresp/metrics.ts

@@ -0,0 +1,57 @@
+// Request response metrics
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { type TelemetryClient, type Tracer, type UpDownCounter } from '@aztec/telemetry-client';
+
+export class ReqRespMetrics {
+  public readonly tracer: Tracer;
+
+  private readonly sentRequests: UpDownCounter;
+  private readonly receivedRequests: UpDownCounter;
+
+  private readonly failedOutboundRequests: UpDownCounter;
+  private readonly failedInboundRequests: UpDownCounter;
+
+  constructor(readonly telemetryClient: TelemetryClient, name = 'ReqResp') {
+    this.tracer = telemetryClient.getTracer(name);
+
+    const meter = telemetryClient.getMeter(name);
+    this.sentRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_SENT_REQUESTS, {
+      description: 'Number of requests sent to peers',
+      unit: 'requests',
+      valueType: ValueType.INT,
+    });
+    this.receivedRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_RECEIVED_REQUESTS, {
+      description: 'Number of requests received from peers',
+      unit: 'requests',
+      valueType: ValueType.INT,
+    });
+
+    this.failedOutboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_OUTBOUND_REQUESTS, {
+      description: 'Number of failed outbound requests - nodes not getting valid responses',
+      unit: 'requests',
+      valueType: ValueType.INT,
+    });
+
+    this.failedInboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_INBOUND_REQUESTS, {
+      description: 'Number of failed inbound requests - node failing to respond to requests',
+      unit: 'requests',
+      valueType: ValueType.INT,
+    });
+  }
+
+  public recordRequestSent(protocol: string) {
+    this.sentRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
+  }
+
+  public recordRequestReceived(protocol: string) {
+    this.receivedRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
+  }
+
+  public recordRequestError(protocol: string) {
+    this.failedOutboundRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
+  }
+
+  public recordResponseError(protocol: string) {
+    this.failedInboundRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
+  }
+}

package/src/services/reqresp/protocols/block.ts

@@ -0,0 +1,15 @@
+import { type L2BlockSource } from '@aztec/circuit-types';
+import { Fr } from '@aztec/foundation/fields';
+
+import { type PeerId } from '@libp2p/interface';
+
+import { type ReqRespSubProtocolHandler } from '../interface.js';
+
+export function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler {
+  return async (_peerId: PeerId, msg: Buffer) => {
+    const blockNumber = Fr.fromBuffer(msg);
+
+    const foundBlock = await l2BlockSource.getBlock(Number(blockNumber));
+    return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
+  };
+}

package/src/services/reqresp/protocols/goodbye.ts

@@ -0,0 +1,101 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import { type PeerId } from '@libp2p/interface';
+
+import { type PeerManager } from '../../peer-manager/peer_manager.js';
+import { ReqRespSubProtocol, type ReqRespSubProtocolHandler } from '../interface.js';
+import { type ReqResp } from '../reqresp.js';
+
+/**
+ * Enum defining the possible reasons for a goodbye message.
+ */
+export enum GoodByeReason {
+  /** The peer has shutdown, will be received whenever a peer's node is routinely stopped */
+  SHUTDOWN = 0x1,
+  /** Whenever the peer must disconnect due to maintaining max peers */
+  DISCONNECTED = 0x2,
+  /** The peer has a low score, will be received whenever a peer's score is low */
+  LOW_SCORE = 0x3,
+  /** The peer has been banned, will be received whenever a peer is banned */
+  BANNED = 0x4,
+  /** Wrong network / fork */
+  WRONG_NETWORK = 0x5,
+  /** Unknown reason */
+  UNKNOWN = 0x6,
+}
+
+export function encodeGoodbyeReason(reason: GoodByeReason): Buffer {
+  return Buffer.from([reason]);
+}
+
+export function decodeGoodbyeReason(buffer: Buffer): GoodByeReason {
+  try {
+    if (buffer.length !== 1) {
+      throw new Error('Invalid goodbye reason buffer length');
+    }
+    return buffer[0] as GoodByeReason;
+  } catch (error) {
+    return GoodByeReason.UNKNOWN;
+  }
+}
+
+/**
+ * Pretty prints the goodbye reason.
+ * @param reason - The goodbye reason.
+ * @returns The pretty printed goodbye reason.
+ */
+export function prettyGoodbyeReason(reason: GoodByeReason): string {
+  switch (reason) {
+    case GoodByeReason.SHUTDOWN:
+      return 'shutdown';
+    case GoodByeReason.DISCONNECTED:
+      return 'disconnected';
+    case GoodByeReason.LOW_SCORE:
+      return 'low_score';
+    case GoodByeReason.BANNED:
+      return 'banned';
+    // TODO(#11328): implement
+    case GoodByeReason.WRONG_NETWORK:
+      return 'wrong_network';
+    case GoodByeReason.UNKNOWN:
+      return 'unknown';
+  }
+}
+
+/**
+ * Handles a goodbye message request
+ */
+export class GoodbyeProtocolHandler {
+  private logger = createLogger('p2p:goodbye-protocol');
+
+  constructor(private reqresp: ReqResp) {}
+
+  public async sendGoodbye(peerId: PeerId, reason: GoodByeReason): Promise<void> {
+    try {
+      await this.reqresp.sendRequestToPeer(peerId, ReqRespSubProtocol.GOODBYE, Buffer.from([reason]));
+      this.logger.debug(`Sent goodbye to peer ${peerId.toString()} with reason ${reason}`);
+    } catch (error) {
+      this.logger.debug(`Failed to send goodbye to peer ${peerId.toString()}: ${error}`);
+    }
+  }
+}
+
+/**
+ * Handles the goodbye request. In request response, the goodbye request is handled by the peer manager.
+ *
+ * @dev Implemented as returning a function as the function is bound in the libp2p service, however
+ *      its implementation is here to keep functionality together.
+ *
+ * @param peerManager - The peer manager.
+ * @returns A resolved promise with the goodbye response.
+ */
+export function reqGoodbyeHandler(peerManager: PeerManager): ReqRespSubProtocolHandler {
+  return (peerId: PeerId, _msg: Buffer) => {
+    const reason = decodeGoodbyeReason(_msg);
+
+    peerManager.goodbyeReceived(peerId, reason);
+
+    // Return a buffer of length 1 as an acknowledgement
+    return Promise.resolve(Buffer.from([0x0]));
+  };
+}

package/src/services/reqresp/protocols/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Request Response protocol handlers
+ */
+export * from './ping.js';
+export * from './status.js';
+export * from './tx.js';
+export * from './goodbye.js';
+export * from './block.js';

package/src/services/reqresp/protocols/ping.ts

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

package/src/services/reqresp/{handlers.ts → protocols/status.ts}

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

package/src/services/reqresp/protocols/tx.ts

@@ -0,0 +1,29 @@
+import { type P2PClientType } from '@aztec/circuit-types';
+import { TxHash } from '@aztec/circuit-types/tx_hash';
+
+import { type PeerId } from '@libp2p/interface';
+
+import { type MemPools } from '../../../mem_pools/interface.js';
+import { type ReqRespSubProtocolHandler } from '../interface.js';
+
+/**
+ * We want to keep the logic of the req resp handler in this file, but we do not have a reference to the mempools here
+ * so we need to pass it in as a parameter.
+ *
+ * Handler for tx requests
+ * @param mempools - the mempools
+ * @returns the tx response message
+ */
+export function reqRespTxHandler<T extends P2PClientType>(mempools: MemPools<T>): ReqRespSubProtocolHandler {
+  /**
+   * Handler for tx requests
+   * @param msg - the tx request message
+   * @returns the tx response message
+   */
+  return (_peerId: PeerId, msg: Buffer) => {
+    const txHash = TxHash.fromBuffer(msg);
+    const foundTx = mempools.txPool.getTxByHash(txHash);
+    const buf = foundTx ? foundTx.toBuffer() : Buffer.alloc(0);
+    return Promise.resolve(buf);
+  };
+}

package/src/services/reqresp/{rate_limiter → rate-limiter}/rate_limiter.ts

@@ -7,7 +7,7 @@ import { PeerErrorSeverity } from '@aztec/circuit-types';
 
 import { type PeerId } from '@libp2p/interface';
 
-import { type PeerManager } from '../../peer_manager.js';
+import { type PeerScoring } from '../../peer-manager/peer_scoring.js';
 import { type ReqRespSubProtocol, type ReqRespSubProtocolRateLimits } from '../interface.js';
 import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
 
@@ -169,7 +169,7 @@ export class RequestResponseRateLimiter {
 
   private cleanupInterval: NodeJS.Timeout | undefined = undefined;
 
-  constructor(private peerManager: PeerManager, rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS) {
+  constructor(private peerScoring: PeerScoring, rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS) {
     this.subProtocolRateLimiters = new Map();
 
     for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)) {
@@ -200,7 +200,7 @@ export class RequestResponseRateLimiter {
 
     switch (rateLimitStatus) {
       case RateLimitStatus.DeniedPeer:
-        this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
+        this.peerScoring.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
         return false;
       case RateLimitStatus.DeniedGlobal:
         return false;

package/src/services/reqresp/{rate_limiter → rate-limiter}/rate_limits.ts

@@ -1,8 +1,8 @@
-import { PING_PROTOCOL, type ReqRespSubProtocolRateLimits, STATUS_PROTOCOL, TX_REQ_PROTOCOL } from '../interface.js';
+import { ReqRespSubProtocol, type ReqRespSubProtocolRateLimits } from '../interface.js';
 
 // TODO(md): these defaults need to be tuned
 export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
-  [PING_PROTOCOL]: {
+  [ReqRespSubProtocol.PING]: {
     peerLimit: {
       quotaTimeMs: 1000,
       quotaCount: 5,
@@ -12,7 +12,7 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
-  [STATUS_PROTOCOL]: {
+  [ReqRespSubProtocol.STATUS]: {
     peerLimit: {
       quotaTimeMs: 1000,
       quotaCount: 5,
@@ -22,7 +22,27 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
-  [TX_REQ_PROTOCOL]: {
+  [ReqRespSubProtocol.TX]: {
+    peerLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 5,
+    },
+    globalLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 10,
+    },
+  },
+  [ReqRespSubProtocol.BLOCK]: {
+    peerLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 2,
+    },
+    globalLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 5,
+    },
+  },
+  [ReqRespSubProtocol.GOODBYE]: {
     peerLimit: {
       quotaTimeMs: 1000,
       quotaCount: 5,