@aztec/p2p 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

package/src/services/reqresp/reqresp.ts

@@ -1,5 +1,4 @@
 // @attribution: lodestar impl for inspiration
-import { compactArray } from '@aztec/foundation/collection';
 import { AbortError, TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { executeTimeout } from '@aztec/foundation/timer';
@@ -11,31 +10,25 @@ import type { Libp2p } from 'libp2p';
 import { pipeline } from 'node:stream/promises';
 import type { Uint8ArrayList } from 'uint8arraylist';
 
-import {
-  CollectiveReqRespTimeoutError,
-  IndividualReqRespTimeoutError,
-  InvalidResponseError,
-} from '../../errors/reqresp.error.js';
-import { SnappyTransform } from '../encoding.js';
+import { IndividualReqRespTimeoutError } from '../../errors/reqresp.error.js';
+import { OversizedSnappyResponseError, SnappyTransform } from '../encoding.js';
 import type { PeerScoring } from '../peer-manager/peer_scoring.js';
 import {
   DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS,
   DEFAULT_REQRESP_DIAL_TIMEOUT_MS,
   type P2PReqRespConfig,
 } from './config.js';
-import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
 import { ConnectionSampler, RandomSampler } from './connection-sampler/connection_sampler.js';
 import {
-  DEFAULT_SUB_PROTOCOL_VALIDATORS,
   type ReqRespInterface,
   type ReqRespResponse,
   ReqRespSubProtocol,
   type ReqRespSubProtocolHandler,
   type ReqRespSubProtocolHandlers,
   type ReqRespSubProtocolRateLimits,
-  type ReqRespSubProtocolValidators,
-  type SubProtocolMap,
-  responseFromBuffer,
+  type ShouldRejectPeer,
+  UNAUTHENTICATED_ALLOWED_PROTOCOLS,
+  subProtocolSizeCalculators,
 } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
 import {
@@ -43,13 +36,13 @@ import {
   RequestResponseRateLimiter,
   prettyPrintRateLimitStatus,
 } from './rate-limiter/rate_limiter.js';
-import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.js';
+import { ReqRespStatus, ReqRespStatusError, parseStatusChunk } from './status.js';
 
 /**
  * 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.
+ * information that was missed during a synchronisation or a gossip event.
  *
  * This service implements the request response sub protocol, it is heavily inspired from
  * ethereum implementations of the same name.
@@ -64,13 +57,14 @@ export class ReqResp implements ReqRespInterface {
   private dialTimeoutMs: number = DEFAULT_REQRESP_DIAL_TIMEOUT_MS;
 
   private subProtocolHandlers: Partial<ReqRespSubProtocolHandlers> = {};
-  private subProtocolValidators: Partial<ReqRespSubProtocolValidators> = {};
 
   private connectionSampler: ConnectionSampler;
   private rateLimiter: RequestResponseRateLimiter;
 
   private snappyTransform: SnappyTransform;
 
+  private shouldRejectPeer: ShouldRejectPeer | undefined;
+
   private metrics: ReqRespMetrics;
 
   constructor(
@@ -107,18 +101,29 @@ export class ReqResp implements ReqRespInterface {
     }
   }
 
+  public setShouldRejectPeer(checker: ShouldRejectPeer): void {
+    this.shouldRejectPeer = checker;
+  }
+
   get tracer() {
     return this.metrics.tracer;
   }
 
+  /**
+   * Get the connection sampler instance
+   */
+  getConnectionSampler(): Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'> {
+    return this.connectionSampler;
+  }
+
   /**
    * Start the reqresp service
    */
-  async start(subProtocolHandlers: ReqRespSubProtocolHandlers, subProtocolValidators: ReqRespSubProtocolValidators) {
+  async start(subProtocolHandlers: ReqRespSubProtocolHandlers) {
     Object.assign(this.subProtocolHandlers, subProtocolHandlers);
-    Object.assign(this.subProtocolValidators, subProtocolValidators);
 
-    // Register all protocol handlers
+    // Register streamHandler with libp2p.
+    // The streamHandler is responsible for reading the incoming stream, determining the protocol, then triggering the appropriate handler.
     for (const subProtocol of Object.keys(subProtocolHandlers)) {
       this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
       await this.libp2p.handle(
@@ -132,13 +137,8 @@ export class ReqResp implements ReqRespInterface {
     this.rateLimiter.start();
   }
 
-  async addSubProtocol(
-    subProtocol: ReqRespSubProtocol,
-    handler: ReqRespSubProtocolHandler,
-    validator: ReqRespSubProtocolValidators[ReqRespSubProtocol] = DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol],
-  ): Promise<void> {
+  async addSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler): Promise<void> {
     this.subProtocolHandlers[subProtocol] = handler;
-    this.subProtocolValidators[subProtocol] = validator;
     this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
     await this.libp2p.handle(
       subProtocol,
@@ -172,186 +172,6 @@ export class ReqResp implements ReqRespInterface {
     // NOTE: We assume libp2p instance is managed by the caller
   }
 
-  /**
-   * Request multiple messages over the same sub protocol, balancing the requests across peers.
-   *
-   * @devnote
-   * - The function prioritizes sending requests to free peers using a batch sampling strategy.
-   * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
-   * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
-   * - Responses are validated using a custom validator for the sub-protocol.*
-   *
-   * Requests are sent in parallel to each peer, but multiple requests are sent to the same peer in series
-   * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
-   * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
-   * - Responses are validated using a custom validator for the sub-protocol.*
-   *
-   * @param subProtocol
-   * @param requests
-   * @param timeoutMs
-   * @param maxPeers
-   * @returns
-   *
-   * @throws {CollectiveReqRespTimeoutError} - If the request batch exceeds the specified timeout (`timeoutMs`).
-   */
-  @trackSpan(
-    'ReqResp.sendBatchRequest',
-    (subProtocol: ReqRespSubProtocol, requests: InstanceType<SubProtocolMap[ReqRespSubProtocol]['request']>[]) => ({
-      [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol,
-      [Attributes.P2P_REQ_RESP_BATCH_REQUESTS_COUNT]: requests.length,
-    }),
-  )
-  async sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
-    subProtocol: SubProtocol,
-    requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
-    pinnedPeer: PeerId | undefined,
-    timeoutMs = 10000,
-    maxPeers = Math.max(10, Math.ceil(requests.length / 3)),
-    maxRetryAttempts = 3,
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
-    const responseValidator = this.subProtocolValidators[subProtocol] ?? DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol];
-    const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = new Array(requests.length);
-    const requestBuffers = requests.map(req => req.toBuffer());
-
-    const requestFunction = async (signal: AbortSignal) => {
-      // Track which requests still need to be processed
-      const pendingRequestIndices = new Set(requestBuffers.map((_, i) => i));
-
-      // Create batch sampler with the total number of requests and max peers
-      const batchSampler = new BatchConnectionSampler(
-        this.connectionSampler,
-        requests.length,
-        maxPeers,
-        compactArray([pinnedPeer]), // Exclude pinned peer from sampling, we will forcefully send all requests to it
-        createLogger(`${this.logger.module}:batch-connection-sampler`),
-      );
-
-      if (batchSampler.activePeerCount === 0 && !pinnedPeer) {
-        this.logger.warn('No active peers to send requests to');
-        return [];
-      }
-
-      // This is where it gets fun
-      // The outer loop is the retry loop, we will continue to retry until we process all indices we have
-      // not received a response for, or we have reached the max retry attempts
-
-      // The inner loop is the batch loop, we will process all requests for each peer in parallel
-      // We will then process the results of the requests, and resample any peers that failed to respond
-      // We will continue to retry until we have processed all indices, or we have reached the max retry attempts
-
-      let retryAttempts = 0;
-      while (pendingRequestIndices.size > 0 && batchSampler.activePeerCount > 0 && retryAttempts < maxRetryAttempts) {
-        if (signal.aborted) {
-          throw new AbortError('Batch request aborted');
-        }
-        // Process requests in parallel for each available peer
-        type BatchEntry = { peerId: PeerId; indices: number[] };
-        const requestBatches = new Map<string, BatchEntry>();
-
-        // Group requests by peer
-        for (const requestIndex of pendingRequestIndices) {
-          const peer = batchSampler.getPeerForRequest(requestIndex);
-          if (!peer) {
-            break;
-          }
-          const peerAsString = peer.toString();
-          if (!requestBatches.has(peerAsString)) {
-            requestBatches.set(peerAsString, { peerId: peer, indices: [] });
-          }
-          requestBatches.get(peerAsString)!.indices.push(requestIndex);
-        }
-
-        // If there is a pinned peer, we will always send every request to that peer
-        // We use the default limits for the subprotocol to avoid hitting the rate limiter
-        if (pinnedPeer) {
-          const limit = this.rateLimiter.getRateLimits(subProtocol).peerLimit.quotaCount;
-          requestBatches.set(pinnedPeer.toString(), {
-            peerId: pinnedPeer,
-            indices: Array.from(pendingRequestIndices.values()).slice(0, limit),
-          });
-        }
-
-        // Make parallel requests for each peer's batch
-        // A batch entry will look something like this:
-        // PeerId0: [0, 1, 2, 3]
-        // PeerId1: [4, 5, 6, 7]
-
-        // Peer Id 0 will send requests 0, 1, 2, 3 in serial
-        // while simultaneously Peer Id 1 will send requests 4, 5, 6, 7 in serial
-
-        const batchResults = await Promise.all(
-          Array.from(requestBatches.entries()).map(async ([peerAsString, { peerId: peer, indices }]) => {
-            try {
-              // Requests all going to the same peer are sent synchronously
-              const peerResults: { index: number; response: InstanceType<SubProtocolMap[SubProtocol]['response']> }[] =
-                [];
-              for (const index of indices) {
-                this.logger.trace(`Sending request ${index} to peer ${peerAsString}`);
-                const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
-
-                // Check the status of the response buffer
-                if (response.status !== ReqRespStatus.SUCCESS) {
-                  this.logger.debug(
-                    `Request to peer ${peerAsString} failed with status ${prettyPrintReqRespStatus(response.status)}`,
-                  );
-
-                  // If we hit a rate limit or some failure, we remove the peer and return the results,
-                  // they will be split among remaining peers and the new sampled peer
-                  batchSampler.removePeerAndReplace(peer);
-                  return { peer, results: peerResults };
-                }
-
-                if (response && response.data.length > 0) {
-                  const object = responseFromBuffer(subProtocol, response.data);
-                  const isValid = await responseValidator(requests[index], object, peer);
-
-                  if (isValid) {
-                    peerResults.push({ index, response: object });
-                  }
-                }
-              }
-
-              return { peer, results: peerResults };
-            } catch (error) {
-              this.logger.debug(`Failed batch request to peer ${peerAsString}:`, error);
-              batchSampler.removePeerAndReplace(peer);
-              return { peer, results: [] };
-            }
-          }),
-        );
-
-        // Process results
-        for (const { results } of batchResults) {
-          for (const { index, response } of results) {
-            if (response) {
-              responses[index] = response;
-              pendingRequestIndices.delete(index);
-            }
-          }
-        }
-
-        retryAttempts++;
-      }
-
-      if (retryAttempts >= maxRetryAttempts) {
-        this.logger.debug(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
-      }
-
-      return responses;
-    };
-
-    try {
-      return await executeTimeout<InstanceType<SubProtocolMap[SubProtocol]['response']>[]>(
-        requestFunction,
-        timeoutMs,
-        () => new CollectiveReqRespTimeoutError(),
-      );
-    } catch (e: any) {
-      this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
-      return [];
-    }
-  }
-
   /**
    * Sends a request to a specific peer
    *
@@ -391,6 +211,9 @@ export class ReqResp implements ReqRespInterface {
     try {
       this.metrics.recordRequestSent(subProtocol);
 
+      // Calculate expected response size based on the request payload
+      const expectedSizeKb = subProtocolSizeCalculators[subProtocol](payload);
+
       this.logger.trace(`Sending request to peer ${peerId.toString()} on sub protocol ${subProtocol}`);
       stream = await this.connectionSampler.dialProtocol(peerId, subProtocol, dialTimeout);
       this.logger.trace(
@@ -398,17 +221,21 @@ export class ReqResp implements ReqRespInterface {
       );
 
       const timeoutErr = new IndividualReqRespTimeoutError();
+      // Create a wrapper to pass the expected size to readMessage
+      const readMessageWithSizeLimit = (source: AsyncIterable<Uint8ArrayList>) =>
+        this.readMessage(source, expectedSizeKb);
       const [_, resp] = await executeTimeout(
         signal =>
           Promise.all([
             pipeline([payload], stream!.sink, { signal }),
-            pipeline(stream!.source, this.readMessage.bind(this), { signal }),
+            pipeline(stream!.source, readMessageWithSizeLimit, { signal }),
           ]),
         this.individualRequestTimeoutMs,
         () => timeoutErr,
       );
       return resp;
     } catch (e: any) {
+      this.logger.debug(`SUBPROTOCOL: ${subProtocol}\n`, e);
       // On error we immediately abort the stream, this is preferred way,
       // because it signals to the sender that error happened, whereas
       // closing the stream only closes our side and is much slower
@@ -463,8 +290,11 @@ export class ReqResp implements ReqRespInterface {
    * The message is split into two components
    * - The first chunk should contain a control byte, indicating the status of the response see `ReqRespStatus`
    * - The second chunk should contain the response data
+   *
+   * @param source - The async iterable source of data chunks
+   * @param maxSizeKb - Optional maximum expected size in KB for the decompressed response
    */
-  private async readMessage(source: AsyncIterable<Uint8ArrayList>): Promise<ReqRespResponse> {
+  private async readMessage(source: AsyncIterable<Uint8ArrayList>, maxSizeKb?: number): Promise<ReqRespResponse> {
     let status: ReqRespStatus | undefined;
     const chunks: Uint8Array[] = [];
 
@@ -489,23 +319,17 @@ export class ReqResp implements ReqRespInterface {
       }
 
       const messageData = Buffer.concat(chunks);
-      const message: Buffer = this.snappyTransform.inboundTransformData(messageData);
+      const message: Buffer = this.snappyTransform.inboundTransformData(messageData, undefined, maxSizeKb);
 
       return {
         status: status ?? ReqRespStatus.UNKNOWN,
         data: message,
       };
     } catch (e: any) {
+      // All errors (invalid status bytes, oversized snappy responses, corrupt data, etc.)
+      // are re-thrown so the caller can penalize the peer via handleResponseError.
       this.logger.debug(`Reading message failed: ${e.message}`);
-
-      let status = ReqRespStatus.UNKNOWN;
-      if (e instanceof ReqRespStatusError) {
-        status = e.status;
-      }
-
-      return {
-        status,
-      };
+      throw e;
     }
   }
 
@@ -545,6 +369,15 @@ export class ReqResp implements ReqRespInterface {
         throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
       }
 
+      // When p2pAllowOnlyValidators is enabled, reject unauthenticated peers on data protocols
+      if (
+        !UNAUTHENTICATED_ALLOWED_PROTOCOLS.has(protocol) &&
+        (this.shouldRejectPeer?.(connection.remotePeer.toString()) ?? false)
+      ) {
+        this.logger.debug(`Rejecting unauthenticated peer ${connection.remotePeer} on gated protocol ${protocol}`);
+        throw new ReqRespStatusError(ReqRespStatus.FAILURE);
+      }
+
       await this.processStream(protocol, incomingStream);
     } catch (err: any) {
       this.metrics.recordResponseError(protocol);
@@ -570,7 +403,9 @@ export class ReqResp implements ReqRespInterface {
         // and that this stream should be dropped
         const isMessageToNotWarn =
           err instanceof Error &&
-          ['stream reset', 'Cannot push value onto an ended pushable'].some(msg => err.message.includes(msg));
+          ['stream reset', 'Cannot push value onto an ended pushable', 'read ECONNRESET'].some(msg =>
+            err.message.includes(msg),
+          );
         const level = isMessageToNotWarn ? 'debug' : 'warn';
         this.logger[level]('Unknown stream error while handling the stream, aborting', {
           protocol,
@@ -687,13 +522,13 @@ export class ReqResp implements ReqRespInterface {
   ): PeerErrorSeverity | undefined {
     const logTags = { peerId: peerId.toString(), subProtocol };
 
-    //Punishable error - peer should never send badly formed request
+    // Punishable error - peer should never send badly formed request
     if (e instanceof ReqRespStatusError && e.status === ReqRespStatus.BADLY_FORMED_REQUEST) {
       this.logger.debug(`Punishable error in ${subProtocol}: ${e.cause}`, logTags);
       return PeerErrorSeverity.LowToleranceError;
     }
 
-    //TODO: (mralj): think if we should penalize peer here based on connection errors
+    // TODO: (mralj): think if we should penalize peer here based on connection errors
     return undefined;
   }
 
@@ -715,10 +550,18 @@ export class ReqResp implements ReqRespInterface {
       return undefined;
     }
 
-    // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
-    if (e instanceof CollectiveReqRespTimeoutError || e instanceof InvalidResponseError) {
-      this.logger.debug(`Non-punishable error in ${subProtocol}: ${e.message}`, logTags);
-      return undefined;
+    // Invalid status byte: the peer sent a status byte that doesn't match any known status code.
+    // This is a protocol violation, penalize harshly.
+    if (e instanceof ReqRespStatusError) {
+      this.logger.warn(`Invalid status byte from peer ${peerId.toString()} in ${subProtocol}: ${e.message}`, logTags);
+      return PeerErrorSeverity.LowToleranceError;
+    }
+
+    // Oversized snappy response: the peer is sending data that exceeds the allowed size.
+    // This is a protocol violation that wastes bandwidth, so penalize harshly.
+    if (e instanceof OversizedSnappyResponseError) {
+      this.logger.warn(`Oversized response from peer ${peerId.toString()} in ${subProtocol}: ${e.message}`, logTags);
+      return PeerErrorSeverity.LowToleranceError;
     }
 
     return this.categorizeConnectionErrors(e, peerId, subProtocol);
@@ -726,7 +569,8 @@ export class ReqResp implements ReqRespInterface {
 
   /*
    * Errors specific to connection  handling
-   * These can happen  both when sending request and response*/
+   * These can happen  both when sending request and response.
+   */
   private categorizeConnectionErrors(
     e: any,
     peerId: PeerId,

package/src/services/service.ts

@@ -1,20 +1,23 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
-import type { BlockProposal, CheckpointAttestation, CheckpointProposalCore, Gossipable } from '@aztec/stdlib/p2p';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposalCore,
+  Gossipable,
+  TopicType,
+} from '@aztec/stdlib/p2p';
 import type { Tx } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 import type { ENR } from '@nethermindeth/enr';
 import type EventEmitter from 'events';
 
+import type { BatchTxRequesterLibP2PService } from './reqresp/batch-tx-requester/interface.js';
 import type { P2PReqRespConfig } from './reqresp/config.js';
 import type { StatusMessage } from './reqresp/index.js';
-import type {
-  ReqRespSubProtocol,
-  ReqRespSubProtocolHandler,
-  ReqRespSubProtocolValidators,
-  SubProtocolMap,
-} from './reqresp/interface.js';
+import type { ReqRespSubProtocol, ReqRespSubProtocolHandler } from './reqresp/interface.js';
 import type { AuthRequest, AuthResponse } from './reqresp/protocols/auth.js';
 
 export enum PeerDiscoveryState {
@@ -42,6 +45,34 @@ export type P2PCheckpointReceivedCallback = (
 
 export type AuthReceivedCallback = (peerId: PeerId, authRequest: AuthRequest) => Promise<AuthResponse | undefined>;
 
+/** Minimal info passed to the duplicate proposal callback. */
+export type DuplicateProposalInfo = {
+  slot: SlotNumber;
+  proposer: EthAddress;
+  type: 'checkpoint' | 'block';
+};
+
+/**
+ * Callback for when a duplicate proposal is detected (equivocation).
+ * Invoked on the first duplicate (when count goes from 1 to 2).
+ */
+export type P2PDuplicateProposalCallback = (info: DuplicateProposalInfo) => void;
+
+/** Minimal info passed to the duplicate attestation callback. */
+export type DuplicateAttestationInfo = {
+  slot: SlotNumber;
+  attester: EthAddress;
+};
+
+/**
+ * Callback for when a duplicate attestation is detected (equivocation).
+ * A validator signing attestations for different proposals at the same slot.
+ * Invoked on the first duplicate (when count goes from 1 to 2).
+ */
+export type P2PDuplicateAttestationCallback = (info: DuplicateAttestationInfo) => void;
+
+export type P2PCheckpointAttestationCallback = (attestation: CheckpointAttestation) => void;
+
 /**
  * The interface for a P2P service implementation.
  */
@@ -64,38 +95,38 @@ export interface P2PService {
    */
   propagate<T extends Gossipable>(message: T): Promise<void>;
 
+  // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
+  registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
+
+  registerValidatorCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+
+  registerAllNodesCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+
   /**
-   * Send a batch of requests to peers, and return the responses
-   *
-   * @param protocol - The request response protocol to use
-   * @param requests - The requests to send to the peers
-   * @returns The responses to the requests
+   * Registers a callback invoked when a duplicate proposal is detected (equivocation).
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
    */
-  sendBatchRequest<Protocol extends ReqRespSubProtocol>(
-    protocol: Protocol,
-    requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-    pinnedPeerId?: PeerId,
-    timeoutMs?: number,
-    maxPeers?: number,
-    maxRetryAttempts?: number,
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]>;
+  registerDuplicateProposalCallback(callback: P2PDuplicateProposalCallback): void;
 
-  // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
-  registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
+  /**
+   * Registers a callback invoked when a duplicate attestation is detected (equivocation).
+   * A validator signing attestations for different proposals at the same slot.
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   */
+  registerDuplicateAttestationCallback(callback: P2PDuplicateAttestationCallback): void;
 
-  registerCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+  registerCheckpointAttestationCallback(callback: P2PCheckpointAttestationCallback): void;
 
   getEnr(): ENR | undefined;
 
   getPeers(includePending?: boolean): PeerInfo[];
 
-  validate(txs: Tx[]): Promise<void>;
+  /** Returns the number of peers in the GossipSub mesh for a given topic type. */
+  getGossipMeshPeerCount(topicType: TopicType): number;
+
+  validateTxsReceivedInBlockProposal(txs: Tx[]): Promise<void>;
 
-  addReqRespSubProtocol(
-    subProtocol: ReqRespSubProtocol,
-    handler: ReqRespSubProtocolHandler,
-    validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
-  ): Promise<void>;
+  addReqRespSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler): Promise<void>;
 
   handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
 
@@ -103,6 +134,9 @@ export interface P2PService {
 
   /** If node running this P2P stack is validator, passes in validator address to P2P layer */
   registerThisValidatorAddresses(address: EthAddress[]): void;
+
+  /** Get BatchTxRequester service dependencies */
+  getBatchTxRequesterService(): BatchTxRequesterLibP2PService;
 }
 
 /**
@@ -143,6 +177,9 @@ export interface PeerDiscoveryService extends EventEmitter {
   on(event: 'peer:discovered', listener: (enr: ENR) => void): this;
   emit(event: 'peer:discovered', enr: ENR): boolean;
 
+  on(event: 'ip:changed', listener: (ip: string) => void): this;
+  emit(event: 'ip:changed', ip: string): boolean;
+
   getStatus(): PeerDiscoveryState;
 
   getEnr(): ENR | undefined;