@aztec/p2p 0.71.0 → 0.72.1

package/src/services/peer-manager/metrics.ts

@@ -0,0 +1,41 @@
+import {
+  Attributes,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import { type GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
+
+export class PeerManagerMetrics {
+  private sentGoodbyes: UpDownCounter;
+  private receivedGoodbyes: UpDownCounter;
+
+  public readonly tracer: Tracer;
+
+  constructor(public readonly telemetryClient: TelemetryClient, name = 'PeerManager') {
+    this.tracer = telemetryClient.getTracer(name);
+
+    const meter = telemetryClient.getMeter(name);
+    this.sentGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_SENT, {
+      description: 'Number of goodbyes sent to peers',
+      unit: 'peers',
+      valueType: ValueType.INT,
+    });
+    this.receivedGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_RECEIVED, {
+      description: 'Number of goodbyes received from peers',
+      unit: 'peers',
+      valueType: ValueType.INT,
+    });
+  }
+
+  public recordGoodbyeSent(reason: GoodByeReason) {
+    this.sentGoodbyes.add(1, { [Attributes.P2P_GOODBYE_REASON]: prettyGoodbyeReason(reason) });
+  }
+
+  public recordGoodbyeReceived(reason: GoodByeReason) {
+    this.receivedGoodbyes.add(1, { [Attributes.P2P_GOODBYE_REASON]: prettyGoodbyeReason(reason) });
+  }
+}

package/src/services/{peer_manager.ts → peer-manager/peer_manager.ts}

@@ -1,17 +1,21 @@
 import { type PeerErrorSeverity, type PeerInfo } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
-import { type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
+import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { type ENR } from '@chainsafe/enr';
 import { type Connection, type PeerId } from '@libp2p/interface';
 import { type Multiaddr } from '@multiformats/multiaddr';
 import { inspect } from 'util';
 
-import { type P2PConfig } from '../config.js';
-import { type PubSubLibp2p } from '../util.js';
-import { PeerScoreState, PeerScoring } from './peer-scoring/peer_scoring.js';
-import { type PeerDiscoveryService } from './service.js';
-import { PeerEvent } from './types.js';
+import { type P2PConfig } from '../../config.js';
+import { type PubSubLibp2p } from '../../util.js';
+import { ReqRespSubProtocol } from '../reqresp/interface.js';
+import { GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/goodbye.js';
+import { type ReqResp } from '../reqresp/reqresp.js';
+import { type PeerDiscoveryService } from '../service.js';
+import { PeerEvent } from '../types.js';
+import { PeerManagerMetrics } from './metrics.js';
+import { PeerScoreState, type PeerScoring } from './peer_scoring.js';
 
 const MAX_DIAL_ATTEMPTS = 3;
 const MAX_CACHED_PEERS = 100;
@@ -31,23 +35,25 @@ type TimedOutPeer = {
   timeoutUntilMs: number;
 };
 
-export class PeerManager extends WithTracer {
+export class PeerManager {
   private cachedPeers: Map<string, CachedPeer> = new Map();
-  private peerScoring: PeerScoring;
   private heartbeatCounter: number = 0;
   private displayPeerCountsPeerHeartbeat: number = 0;
   private timedOutPeers: Map<string, TimedOutPeer> = new Map();
 
+  private metrics: PeerManagerMetrics;
+
   constructor(
     private libP2PNode: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
     private config: P2PConfig,
     telemetryClient: TelemetryClient,
     private logger = createLogger('p2p:peer-manager'),
+    private peerScoring: PeerScoring,
+    private reqresp: ReqResp,
   ) {
-    super(telemetryClient, 'PeerManager');
+    this.metrics = new PeerManagerMetrics(telemetryClient, 'PeerManager');
 
-    this.peerScoring = new PeerScoring(config);
     // Handle new established connections
     this.libP2PNode.addEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent.bind(this));
     // Handle lost connections
@@ -60,6 +66,10 @@ export class PeerManager extends WithTracer {
     this.displayPeerCountsPeerHeartbeat = Math.floor(60_000 / this.config.peerCheckIntervalMS);
   }
 
+  get tracer() {
+    return this.metrics.tracer;
+  }
+
   @trackSpan('PeerManager.heartbeat')
   public heartbeat() {
     this.heartbeatCounter++;
@@ -113,11 +123,23 @@ export class PeerManager extends WithTracer {
     }
   }
 
+  /**
+   * Handles a goodbye received from a peer.
+   *
+   * Used as the reqresp handler when a peer sends us goodbye message.
+   * @param peerId - The peer ID.
+   * @param reason - The reason for the goodbye.
+   */
+  public goodbyeReceived(peerId: PeerId, reason: GoodByeReason) {
+    this.logger.debug(`Goodbye received from peer ${peerId.toString()} with reason ${prettyGoodbyeReason(reason)}`);
+
+    this.metrics.recordGoodbyeReceived(reason);
+
+    void this.disconnectPeer(peerId);
+  }
+
   public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {
-    const id = peerId.toString();
-    const penaltyValue = this.peerScoring.peerPenalties[penalty];
-    const newScore = this.peerScoring.updateScore(id, -penaltyValue);
-    this.logger.verbose(`Penalizing peer ${id} with ${penalty} (new score is ${newScore})`);
+    this.peerScoring.penalizePeer(peerId, penalty);
   }
 
   public getPeerScore(peerId: string): number {
@@ -227,10 +249,11 @@ export class PeerManager extends WithTracer {
     for (const peer of connections) {
       const score = this.peerScoring.getScoreState(peer.remotePeer.toString());
       switch (score) {
-        // TODO: add goodbye and give reasons
         case PeerScoreState.Banned:
+          void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.BANNED);
+          break;
         case PeerScoreState.Disconnect:
-          void this.disconnectPeer(peer.remotePeer);
+          void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.DISCONNECTED);
           break;
         case PeerScoreState.Healthy:
           connectedHealthyPeers.push(peer);
@@ -240,10 +263,26 @@ export class PeerManager extends WithTracer {
     return connectedHealthyPeers;
   }
 
-  // TODO: send a goodbye with a reason to the peer
+  private async goodbyeAndDisconnectPeer(peer: PeerId, reason: GoodByeReason) {
+    this.logger.debug(`Disconnecting peer ${peer.toString()} with reason ${prettyGoodbyeReason(reason)}`);
+
+    this.metrics.recordGoodbyeSent(reason);
+
+    try {
+      await this.reqresp.sendRequestToPeer(peer, ReqRespSubProtocol.GOODBYE, Buffer.from([reason]));
+    } catch (error) {
+      this.logger.debug(`Failed to send goodbye to peer ${peer.toString()}: ${error}`);
+    } finally {
+      await this.disconnectPeer(peer);
+    }
+  }
+
   private async disconnectPeer(peer: PeerId) {
-    this.logger.debug(`Disconnecting peer ${peer.toString()}`);
-    await this.libP2PNode.hangUp(peer);
+    try {
+      await this.libP2PNode.hangUp(peer);
+    } catch (error) {
+      this.logger.debug(`Failed to disconnect peer ${peer.toString()}`, { error: inspect(error) });
+    }
   }
 
   /**
@@ -281,7 +320,7 @@ export class PeerManager extends WithTracer {
     }
     // check if peer is already connected
     const connections = this.libP2PNode.getConnections();
-    if (connections.some(conn => conn.remotePeer.equals(peerId))) {
+    if (connections.some((conn: Connection) => conn.remotePeer.equals(peerId))) {
       this.logger.trace(`Already connected to peer ${peerId}`);
       return;
     }
@@ -371,10 +410,16 @@ export class PeerManager extends WithTracer {
    * Stops the peer manager.
    * Removing all event listeners.
    */
-  public stop() {
+  public async stop() {
+    this.peerDiscoveryService.off(PeerEvent.DISCOVERED, this.handleDiscoveredPeer);
+
+    // Send goodbyes to all peers
+    await Promise.all(
+      this.libP2PNode.getPeers().map(peer => this.goodbyeAndDisconnectPeer(peer, GoodByeReason.SHUTDOWN)),
+    );
+
     this.libP2PNode.removeEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent);
     this.libP2PNode.removeEventListener(PeerEvent.DISCONNECTED, this.handleDisconnectedPeerEvent);
-    this.peerDiscoveryService.off(PeerEvent.DISCOVERED, this.handleDiscoveredPeer);
   }
 }
 

package/src/services/{peer-scoring → peer-manager}/peer_scoring.ts

@@ -1,5 +1,8 @@
 import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { median } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+
+import { type PeerId } from '@libp2p/interface';
 
 import { type P2PConfig } from '../../config.js';
 
@@ -20,6 +23,7 @@ const MIN_SCORE_BEFORE_BAN = -100;
 const MIN_SCORE_BEFORE_DISCONNECT = -50;
 
 export class PeerScoring {
+  private logger = createLogger('p2p:peer-scoring');
   private scores: Map<string, number> = new Map();
   private lastUpdateTime: Map<string, number> = new Map();
   private decayInterval = 1000 * 60; // 1 minute
@@ -38,6 +42,14 @@ export class PeerScoring {
     };
   }
 
+  public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {
+    const id = peerId.toString();
+    const penaltyValue = this.peerPenalties[penalty];
+    const newScore = this.updateScore(id, -penaltyValue);
+    this.logger.verbose(`Penalizing peer ${id} with ${penalty} (new score is ${newScore})`);
+    return newScore;
+  }
+
   updateScore(peerId: string, scoreDelta: number): number {
     const currentTime = Date.now();
     const lastUpdate = this.lastUpdateTime.get(peerId) || currentTime;
@@ -75,12 +87,13 @@ export class PeerScoring {
     return this.scores.get(peerId) || 0;
   }
 
-  getScoreState(peerId: string) {
-    // TODO: permanently store banned peers???
+  public getScoreState(peerId: string): PeerScoreState {
+    // TODO(#11329): permanently store banned peers?
     const score = this.getScore(peerId);
     if (score < MIN_SCORE_BEFORE_BAN) {
       return PeerScoreState.Banned;
-    } else if (score < MIN_SCORE_BEFORE_DISCONNECT) {
+    }
+    if (score < MIN_SCORE_BEFORE_DISCONNECT) {
       return PeerScoreState.Disconnect;
     }
     return PeerScoreState.Healthy;

package/src/services/reqresp/connection-sampler/batch_connection_sampler.ts

@@ -0,0 +1,94 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import { type PeerId } from '@libp2p/interface';
+
+import { type ConnectionSampler } from './connection_sampler.js';
+
+/**
+ * Manages batches of peers for parallel request processing.
+ * Tracks active peers and provides deterministic peer assignment for requests.
+ *
+ * Example with 3 peers and 10 requests:
+ *
+ * Peers:    [P1]      [P2]     [P3]
+ *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
+ * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
+ *
+ * Each peer handles a bucket of consecutive requests.
+ * If a peer fails, it is replaced while maintaining the same bucket.
+ */
+export class BatchConnectionSampler {
+  private readonly logger = createLogger('p2p:reqresp:batch-connection-sampler');
+  private readonly batch: PeerId[] = [];
+  private readonly requestsPerPeer: number;
+
+  constructor(private readonly connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number) {
+    if (maxPeers <= 0) {
+      throw new Error('Max peers cannot be 0');
+    }
+    if (batchSize <= 0) {
+      throw new Error('Batch size cannot be 0');
+    }
+
+    // Calculate how many requests each peer should handle, cannot be 0
+    this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
+
+    // Sample initial peers
+    this.batch = this.connectionSampler.samplePeersBatch(maxPeers);
+  }
+
+  /**
+   * Gets the peer responsible for handling a specific request index
+   *
+   * @param index - The request index
+   * @returns The peer assigned to handle this request
+   */
+  getPeerForRequest(index: number): PeerId | undefined {
+    if (this.batch.length === 0) {
+      return undefined;
+    }
+
+    // Calculate which peer bucket this index belongs to
+    const peerIndex = Math.floor(index / this.requestsPerPeer) % this.batch.length;
+    return this.batch[peerIndex];
+  }
+
+  /**
+   * Removes a peer and replaces it with a new one, maintaining the same position
+   * in the batch array to keep request distribution consistent
+   *
+   * @param peerId - The peer to remove and replace
+   */
+  removePeerAndReplace(peerId: PeerId): void {
+    const index = this.batch.findIndex(p => p === peerId);
+    if (index === -1) {
+      return;
+    }
+
+    const excluding = new Map([[peerId.toString(), true]]);
+    const newPeer = this.connectionSampler.getPeer(excluding);
+
+    if (newPeer) {
+      this.batch[index] = newPeer;
+      this.logger.trace(`Replaced peer ${peerId} with ${newPeer}`, { peerId, newPeer });
+    } else {
+      // If we couldn't get a replacement, remove the peer and compact the array
+      this.batch.splice(index, 1);
+      this.logger.trace(`Removed peer ${peerId}`, { peerId });
+    }
+  }
+
+  /**
+   * Gets the number of active peers
+   */
+  get activePeerCount(): number {
+    return this.batch.length;
+  }
+
+  /**
+   * Gets the number of requests each peer is assigned to handle
+   */
+  get requestsPerBucket(): number {
+    return this.requestsPerPeer;
+  }
+}

package/src/services/reqresp/connection-sampler/connection_sampler.ts

@@ -0,0 +1,211 @@
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+
+import { type Libp2p, type PeerId, type Stream } from '@libp2p/interface';
+
+const MAX_SAMPLE_ATTEMPTS = 4;
+
+interface StreamAndPeerId {
+  stream: Stream;
+  peerId: PeerId;
+}
+
+export class RandomSampler {
+  random(max: number) {
+    return Math.floor(Math.random() * max);
+  }
+}
+
+/**
+ * A class that samples peers from the libp2p node and returns a peer that we don't already have a connection open to.
+ * If we already have a connection open, we try to sample a different peer.
+ * We do this MAX_SAMPLE_ATTEMPTS times, if we still don't find a peer we just go for it.
+ *
+ * @dev Close must always be called on connections, else memory leak
+ */
+export class ConnectionSampler {
+  private readonly logger = createLogger('p2p:reqresp:connection-sampler');
+  private cleanupInterval: NodeJS.Timeout;
+  private abortController: AbortController = new AbortController();
+
+  private readonly activeConnectionsCount: Map<PeerId, number> = new Map();
+  private readonly streams: Map<string, StreamAndPeerId> = new Map();
+
+  // Serial queue to ensure that we only dial one peer at a time
+  private dialQueue: SerialQueue = new SerialQueue();
+
+  constructor(
+    private readonly libp2p: Libp2p,
+    private readonly cleanupIntervalMs: number = 60000, // Default to 1 minute
+    private readonly sampler: RandomSampler = new RandomSampler(), // Allow randomness to be mocked for testing
+  ) {
+    this.cleanupInterval = setInterval(() => void this.cleanupStaleConnections(), this.cleanupIntervalMs);
+
+    this.dialQueue.start();
+  }
+
+  /**
+   * Stops the cleanup job and closes all active connections
+   */
+  async stop() {
+    this.logger.info('Stopping connection sampler');
+    clearInterval(this.cleanupInterval);
+
+    this.abortController.abort();
+    await this.dialQueue.end();
+
+    // Close all active streams
+    const closePromises = Array.from(this.streams.keys()).map(streamId => this.close(streamId));
+    await Promise.all(closePromises);
+    this.logger.info('Connection sampler stopped');
+  }
+
+  /**
+   *
+   * @param excluding - The peers to exclude from the sampling
+   *        This is to prevent sampling with replacement
+   * @returns
+   */
+  getPeer(excluding?: Map<string, boolean>): PeerId | undefined {
+    // In libp2p getPeers performs a shallow copy, so this array can be sliced from safetly
+    const peers = this.libp2p.getPeers();
+
+    if (peers.length === 0) {
+      return undefined;
+    }
+
+    let randomIndex = this.sampler.random(peers.length);
+    let attempts = 0;
+
+    // Keep sampling while:
+    // - we haven't exceeded max attempts AND
+    // - either the peer has active connections OR is in the exclusion list
+    while (
+      attempts < MAX_SAMPLE_ATTEMPTS &&
+      ((this.activeConnectionsCount.get(peers[randomIndex]) ?? 0) > 0 ||
+        (excluding?.get(peers[randomIndex]?.toString()) ?? false))
+    ) {
+      peers.splice(randomIndex, 1);
+      randomIndex = this.sampler.random(peers.length);
+      attempts++;
+    }
+
+    this.logger.trace(`Sampled peer in ${attempts} attempts`, {
+      attempts,
+      peer: peers[randomIndex]?.toString(),
+    });
+    return peers[randomIndex];
+  }
+
+  /**
+   * Samples a batch of unique peers from the libp2p node, prioritizing peers without active connections
+   *
+   * @param numberToSample - The number of peers to sample
+   * @returns Array of unique sampled peers, prioritizing those without active connections
+   */
+  samplePeersBatch(numberToSample: number): PeerId[] {
+    const peers = this.libp2p.getPeers();
+    const sampledPeers: PeerId[] = [];
+    const peersWithConnections: PeerId[] = []; // Hold onto peers with active connections incase we need to sample more
+
+    for (const peer of peers) {
+      const activeConnections = this.activeConnectionsCount.get(peer) ?? 0;
+      if (activeConnections === 0) {
+        if (sampledPeers.push(peer) === numberToSample) {
+          return sampledPeers;
+        }
+      } else {
+        peersWithConnections.push(peer);
+      }
+    }
+
+    // If we still need more peers, sample from those with connections
+    while (sampledPeers.length < numberToSample && peersWithConnections.length > 0) {
+      const randomIndex = this.sampler.random(peersWithConnections.length);
+      const [peer] = peersWithConnections.splice(randomIndex, 1);
+      sampledPeers.push(peer);
+    }
+
+    this.logger.trace(`Batch sampled ${sampledPeers.length} unique peers`, {
+      peers: sampledPeers,
+      withoutConnections: sampledPeers.length - peersWithConnections.length,
+      withConnections: peersWithConnections.length,
+    });
+
+    return sampledPeers;
+  }
+
+  // Set of passthrough functions to keep track of active connections
+
+  /**
+   * Dials a protocol and returns the stream
+   *
+   * @param peerId - The peer id
+   * @param protocol - The protocol
+   * @returns The stream
+   */
+  async dialProtocol(peerId: PeerId, protocol: string): Promise<Stream> {
+    // Dialling at the same time can cause race conditions where two different streams
+    // end up with the same id, hence a serial queue
+    const stream = await this.dialQueue.put(() =>
+      this.libp2p.dialProtocol(peerId, protocol, { signal: this.abortController.signal }),
+    );
+
+    this.streams.set(stream.id, { stream, peerId });
+    const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 0) + 1;
+    this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
+
+    this.logger.trace(`Dialed protocol ${protocol} with peer ${peerId.toString()}`, {
+      streamId: stream.id,
+      peerId: peerId.toString(),
+      activeConnectionsCount: updatedActiveConnectionsCount,
+    });
+    return stream;
+  }
+
+  /**
+   * Closes a stream and updates the active connections count
+   *
+   * @param streamId - The stream id
+   */
+  async close(streamId: string): Promise<void> {
+    try {
+      const { stream, peerId } = this.streams.get(streamId)!;
+
+      const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 1) - 1;
+      this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
+
+      this.logger.trace(`Closing connection to peer ${peerId.toString()}`, {
+        streamId,
+        peerId: peerId.toString(),
+        protocol: stream.protocol,
+        activeConnectionsCount: updatedActiveConnectionsCount,
+      });
+
+      await stream?.close();
+    } catch (error) {
+      this.logger.warn(`Failed to close connection to peer with stream id ${streamId}`);
+    } finally {
+      this.streams.delete(streamId);
+    }
+  }
+
+  /**
+   * Cleans up stale connections that we have lost accounting for
+   */
+  private async cleanupStaleConnections() {
+    // Look for streams without anything in the activeConnectionsCount
+    // If we find anything, close the stream
+    for (const [streamId, { peerId }] of this.streams.entries()) {
+      try {
+        // Check if we have lost track of accounting
+        if (this.activeConnectionsCount.get(peerId) === 0) {
+          await this.close(streamId);
+          this.logger.debug(`Cleaned up stale connection ${streamId} to peer ${peerId.toString()}`);
+        }
+      } catch (error) {
+        this.logger.error(`Error cleaning up stale connection ${streamId}`, { error });
+      }
+    }
+  }
+}

package/src/services/reqresp/interface.ts

@@ -1,4 +1,5 @@
-import { Tx, TxHash } from '@aztec/circuit-types';
+import { L2Block, Tx, TxHash } from '@aztec/circuit-types';
+import { Fr } from '@aztec/foundation/fields';
 
 import { type PeerId } from '@libp2p/interface';
 
@@ -7,16 +8,23 @@ import { type PeerId } from '@libp2p/interface';
  */
 export const PING_PROTOCOL = '/aztec/req/ping/0.1.0';
 export const STATUS_PROTOCOL = '/aztec/req/status/0.1.0';
+export const GOODBYE_PROTOCOL = '/aztec/req/goodbye/0.1.0';
 export const TX_REQ_PROTOCOL = '/aztec/req/tx/0.1.0';
-
-// Sum type for sub protocols
-export type ReqRespSubProtocol = typeof PING_PROTOCOL | typeof STATUS_PROTOCOL | typeof TX_REQ_PROTOCOL;
+export const BLOCK_REQ_PROTOCOL = '/aztec/req/block/0.1.0';
+
+export enum ReqRespSubProtocol {
+  PING = PING_PROTOCOL,
+  STATUS = STATUS_PROTOCOL,
+  GOODBYE = GOODBYE_PROTOCOL,
+  TX = TX_REQ_PROTOCOL,
+  BLOCK = BLOCK_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<Buffer>;
+export type ReqRespSubProtocolHandler = (peerId: PeerId, msg: Buffer) => Promise<Buffer>;
 
 /**
  * A type mapping from supprotocol to it's rate limits
@@ -51,7 +59,7 @@ export interface ProtocolRateLimitQuota {
 export const noopValidator = () => Promise.resolve(true);
 
 /**
- * A type mapping from supprotocol to it's handling funciton
+ * A type mapping from supprotocol to it's handling function
  */
 export type ReqRespSubProtocolHandlers = Record<ReqRespSubProtocol, ReqRespSubProtocolHandler>;
 
@@ -66,9 +74,11 @@ export type ReqRespSubProtocolValidators = {
 };
 
 export const DEFAULT_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
-  [PING_PROTOCOL]: noopValidator,
-  [STATUS_PROTOCOL]: noopValidator,
-  [TX_REQ_PROTOCOL]: noopValidator,
+  [ReqRespSubProtocol.PING]: noopValidator,
+  [ReqRespSubProtocol.STATUS]: noopValidator,
+  [ReqRespSubProtocol.TX]: noopValidator,
+  [ReqRespSubProtocol.GOODBYE]: noopValidator,
+  [ReqRespSubProtocol.BLOCK]: noopValidator,
 };
 
 /**
@@ -91,16 +101,21 @@ const defaultHandler = (_msg: any): Promise<Buffer> => {
  * 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,
+  [ReqRespSubProtocol.PING]: defaultHandler,
+  [ReqRespSubProtocol.STATUS]: defaultHandler,
+  [ReqRespSubProtocol.TX]: defaultHandler,
+  [ReqRespSubProtocol.GOODBYE]: defaultHandler,
+  [ReqRespSubProtocol.BLOCK]: defaultHandler,
 };
 
 /**
  * The Request Response Pair interface defines the methods that each
  * request response pair must implement
  */
-interface RequestResponsePair<Req, Res> {
+interface RequestResponsePair<Req extends { toBuffer(): Buffer }, Res> {
+  /**
+   * The request must implement the toBuffer method (generic serialisation)
+   */
   request: new (...args: any[]) => Req;
   /**
    * The response must implement the static fromBuffer method (generic serialisation)
@@ -135,16 +150,24 @@ export class RequestableBuffer {
  * as a type rather than an object
  */
 export const subProtocolMap: SubProtocolMap = {
-  [PING_PROTOCOL]: {
+  [ReqRespSubProtocol.PING]: {
     request: RequestableBuffer,
     response: RequestableBuffer,
   },
-  [STATUS_PROTOCOL]: {
+  [ReqRespSubProtocol.STATUS]: {
     request: RequestableBuffer,
     response: RequestableBuffer,
   },
-  [TX_REQ_PROTOCOL]: {
+  [ReqRespSubProtocol.TX]: {
     request: TxHash,
     response: Tx,
   },
+  [ReqRespSubProtocol.GOODBYE]: {
+    request: RequestableBuffer,
+    response: RequestableBuffer,
+  },
+  [ReqRespSubProtocol.BLOCK]: {
+    request: Fr, // block number
+    response: L2Block,
+  },
 };