@aztec/p2p 0.0.0-test.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,
+  /** The max peer count has been reached, will be received whenever a low scoring peer is disconnected to satisfy the max peer count */
+  MAX_PEERS = 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.MAX_PEERS:
+      return 'max_peers';
+    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: this is allowed to fail
+    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/protocols/status.ts

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

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

@@ -0,0 +1,29 @@
+import type { P2PClientType } from '@aztec/stdlib/p2p';
+import { TxHash } from '@aztec/stdlib/tx';
+
+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 async (_peerId: PeerId, msg: Buffer) => {
+    const txHash = TxHash.fromBuffer(msg);
+    const foundTx = await mempools.txPool.getTxByHash(txHash);
+    const buf = foundTx ? foundTx.toBuffer() : Buffer.alloc(0);
+    return buf;
+  };
+}

package/src/services/reqresp/rate-limiter/index.ts

@@ -0,0 +1 @@
+export { RequestResponseRateLimiter } from './rate_limiter.js';

package/src/services/reqresp/rate-limiter/rate_limiter.ts

@@ -0,0 +1,228 @@
+/**
+ * @attribution Rate limiter approach implemented in the lodestar ethereum 2 client.
+ * Rationale is that if it was good enough for them, then it should be good enough for us.
+ * https://github.com/ChainSafe/lodestar
+ */
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+
+import type { PeerId } from '@libp2p/interface';
+
+import type { PeerScoring } from '../../peer-manager/peer_scoring.js';
+import type { ReqRespSubProtocol, ReqRespSubProtocolRateLimits } from '../interface.js';
+import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
+
+// Check for disconnected peers every 10 minutes
+const CHECK_DISCONNECTED_PEERS_INTERVAL_MS = 10 * 60 * 1000;
+
+/**
+ * GCRARateLimiter: A Generic Cell Rate Algorithm (GCRA) based rate limiter.
+ *
+ * How it works:
+ * 1. The rate limiter allows a certain number of operations (quotaCount) within a specified
+ *    time interval (quotaTimeMs).
+ * 2. It uses a "virtual scheduling time" (VST) to determine when the next operation should be allowed.
+ * 3. When an operation is requested, the limiter checks if enough time has passed since the last
+ *    allowed operation.
+ * 4. If sufficient time has passed, the operation is allowed, and the VST is updated.
+ * 5. If not enough time has passed, the operation is denied.
+ *
+ * The limiter also allows for short bursts of activity, as long as the overall rate doesn't exceed
+ * the specified quota over time.
+ *
+ * Usage example:
+ * ```
+ * const limiter = new GCRARateLimiter(100, 60000); // 100 operations per minute
+ * ```
+ */
+export class GCRARateLimiter {
+  // Virtual scheduling time: i.e. the time at which we should allow the next request
+  private vst: number;
+  // The interval at which we emit a new token
+  private readonly emissionInterval: number;
+  // The interval over which we limit the number of requests
+  private readonly limitInterval: number;
+
+  /**
+   * @param quotaCount - The number of requests to allow over the limit interval
+   * @param quotaTimeMs - The time interval over which the quotaCount applies
+   */
+  constructor(quotaCount: number, quotaTimeMs: number) {
+    this.emissionInterval = quotaTimeMs / quotaCount;
+    this.limitInterval = quotaTimeMs;
+    this.vst = Date.now();
+  }
+
+  allow(): boolean {
+    const now = Date.now();
+
+    const newVst = Math.max(this.vst, now) + this.emissionInterval;
+    if (newVst - now <= this.limitInterval) {
+      this.vst = newVst;
+      return true;
+    }
+
+    return false;
+  }
+}
+
+interface PeerRateLimiter {
+  // The rate limiter for this peer
+  limiter: GCRARateLimiter;
+  // The last time the peer was accessed - used to determine if the peer is still connected
+  lastAccess: number;
+}
+
+export enum RateLimitStatus {
+  DeniedGlobal,
+  DeniedPeer,
+  Allowed, // Note: allowed last to prevent enum evaluating to 0 for success
+}
+
+export function prettyPrintRateLimitStatus(status: RateLimitStatus) {
+  switch (status) {
+    case RateLimitStatus.DeniedGlobal:
+      return 'DeniedGlobal';
+    case RateLimitStatus.DeniedPeer:
+      return 'DeniedPeer';
+    case RateLimitStatus.Allowed:
+      return 'Allowed';
+  }
+}
+
+/**
+ * SubProtocolRateLimiter: A rate limiter for managing request rates on a per-peer and global basis for a specific subprotocol.
+ *
+ * This class provides a two-tier rate limiting system:
+ * 1. A global rate limit for all requests across all peers for this subprotocol.
+ * 2. Individual rate limits for each peer.
+ *
+ * How it works:
+ * - When a request comes in, it first checks against the global rate limit.
+ * - If the global limit allows, it then checks against the specific peer's rate limit.
+ * - The request is only allowed if both the global and peer-specific limits allow it.
+ * - It automatically creates and manages rate limiters for new peers as they make requests.
+ * - It periodically cleans up rate limiters for inactive peers to conserve memory.
+ *
+ * Note: Remember to call `start()` to begin the cleanup process and `stop()` when shutting down to clear the cleanup interval.
+ */
+export class SubProtocolRateLimiter {
+  private peerLimiters: Map<string, PeerRateLimiter> = new Map();
+  private globalLimiter: GCRARateLimiter;
+  private readonly peerQuotaCount: number;
+  private readonly peerQuotaTimeMs: number;
+
+  constructor(peerQuotaCount: number, peerQuotaTimeMs: number, globalQuotaCount: number, globalQuotaTimeMs: number) {
+    this.peerLimiters = new Map();
+    this.globalLimiter = new GCRARateLimiter(globalQuotaCount, globalQuotaTimeMs);
+    this.peerQuotaCount = peerQuotaCount;
+    this.peerQuotaTimeMs = peerQuotaTimeMs;
+  }
+
+  allow(peerId: PeerId): RateLimitStatus {
+    if (!this.globalLimiter.allow()) {
+      return RateLimitStatus.DeniedGlobal;
+    }
+
+    const peerIdStr = peerId.toString();
+    let peerLimiter: PeerRateLimiter | undefined = this.peerLimiters.get(peerIdStr);
+    if (!peerLimiter) {
+      // Create a limiter for this peer
+      peerLimiter = {
+        limiter: new GCRARateLimiter(this.peerQuotaCount, this.peerQuotaTimeMs),
+        lastAccess: Date.now(),
+      };
+      this.peerLimiters.set(peerIdStr, peerLimiter);
+    } else {
+      peerLimiter.lastAccess = Date.now();
+    }
+    const peerLimitAllowed = peerLimiter.limiter.allow();
+    if (!peerLimitAllowed) {
+      return RateLimitStatus.DeniedPeer;
+    }
+    return RateLimitStatus.Allowed;
+  }
+
+  cleanupInactivePeers() {
+    const now = Date.now();
+    this.peerLimiters.forEach((peerLimiter, peerId) => {
+      if (now - peerLimiter.lastAccess > CHECK_DISCONNECTED_PEERS_INTERVAL_MS) {
+        this.peerLimiters.delete(peerId);
+      }
+    });
+  }
+}
+
+/**
+ * RequestResponseRateLimiter.
+ *
+ * A rate limiter that is protocol aware, then peer aware.
+ * SubProtocols can have their own global / peer level rate limits.
+ *
+ * How it works:
+ * - Initializes with a set of rate limit configurations for different subprotocols.
+ * - Creates a separate SubProtocolRateLimiter for each configured subprotocol.
+ * - When a request comes in, it routes the rate limiting decision to the appropriate subprotocol limiter.
+ * - Peers who exceed their peer rate limits will be penalised by the peer manager.
+ *
+ * Usage:
+ * ```
+ * const peerManager = new PeerManager(...);
+ * const rateLimits = {
+ *   subprotocol1: { peerLimit: { quotaCount: 10, quotaTimeMs: 1000 }, globalLimit: { quotaCount: 100, quotaTimeMs: 1000 } },
+ *   subprotocol2: { peerLimit: { quotaCount: 5, quotaTimeMs: 1000 }, globalLimit: { quotaCount: 50, quotaTimeMs: 1000 } }
+ * };
+ * const limiter = new RequestResponseRateLimiter(peerManager, rateLimits);
+ *
+ * Note: Ensure to call `stop()` when shutting down to properly clean up all subprotocol limiters.
+ */
+export class RequestResponseRateLimiter {
+  private subProtocolRateLimiters: Map<ReqRespSubProtocol, SubProtocolRateLimiter>;
+
+  private cleanupInterval: NodeJS.Timeout | undefined = undefined;
+
+  constructor(private peerScoring: PeerScoring, rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS) {
+    this.subProtocolRateLimiters = new Map();
+
+    for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)) {
+      this.subProtocolRateLimiters.set(
+        subProtocol as ReqRespSubProtocol,
+        new SubProtocolRateLimiter(
+          protocolLimits.peerLimit.quotaCount,
+          protocolLimits.peerLimit.quotaTimeMs,
+          protocolLimits.globalLimit.quotaCount,
+          protocolLimits.globalLimit.quotaTimeMs,
+        ),
+      );
+    }
+  }
+
+  start() {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupInactivePeers();
+    }, CHECK_DISCONNECTED_PEERS_INTERVAL_MS);
+  }
+
+  allow(subProtocol: ReqRespSubProtocol, peerId: PeerId): RateLimitStatus {
+    const limiter = this.subProtocolRateLimiters.get(subProtocol);
+    if (!limiter) {
+      return RateLimitStatus.Allowed;
+    }
+    const rateLimitStatus = limiter.allow(peerId);
+
+    if (rateLimitStatus === RateLimitStatus.DeniedPeer) {
+      this.peerScoring.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
+    }
+    return rateLimitStatus;
+  }
+
+  cleanupInactivePeers() {
+    this.subProtocolRateLimiters.forEach(limiter => limiter.cleanupInactivePeers());
+  }
+
+  /**
+   * Make sure to call destroy on each of the sub protocol rate limiters when cleaning up
+   */
+  stop() {
+    clearInterval(this.cleanupInterval);
+  }
+}

package/src/services/reqresp/rate-limiter/rate_limits.ts

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