@aztec/p2p 5.0.0-private.20260319 → 5.0.0-rc.2

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,11 +10,7 @@ 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 { IndividualReqRespTimeoutError } from '../../errors/reqresp.error.js';
 import { OversizedSnappyResponseError, SnappyTransform } from '../encoding.js';
 import type { PeerScoring } from '../peer-manager/peer_scoring.js';
 import {
@@ -23,19 +18,16 @@ import {
   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';
@@ -44,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.
@@ -65,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(
@@ -108,6 +101,10 @@ export class ReqResp implements ReqRespInterface {
     }
   }
 
+  public setShouldRejectPeer(checker: ShouldRejectPeer): void {
+    this.shouldRejectPeer = checker;
+  }
+
   get tracer() {
     return this.metrics.tracer;
   }
@@ -122,11 +119,11 @@ export class ReqResp implements ReqRespInterface {
   /**
    * 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(
@@ -140,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,
@@ -180,225 +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 isEmptyResponse = (value: unknown): boolean => {
-      // Some responses serialize to a non-empty buffer even when they contain no items (e.g., empty TxArray).
-      if (!value || typeof value !== 'object') {
-        return false;
-      }
-      const length = (value as { length?: number }).length;
-      return typeof length === 'number' && length === 0;
-    };
-
-    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) {
-            // No peer available for this specific index (all peers exhausted for it)
-            // Skip this index for now - it stays in pendingRequestIndices for retry
-            continue;
-          }
-          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),
-          });
-        }
-
-        // If no requests could be assigned (all peers exhausted for all indices), exit early
-        if (requestBatches.size === 0) {
-          this.logger.warn('No peers available for any pending request indices, stopping batch request');
-          break;
-        }
-
-        // 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 {
-              const markIndexFailed = (index: number) => batchSampler.markPeerFailedForIndex(peer, index);
-              // Requests all going to the same peer are sent synchronously
-              const peerResults: { index: number; response: InstanceType<SubProtocolMap[SubProtocol]['response']> }[] =
-                [];
-              let shouldReplacePeer = false;
-              const handleFailure = (status: ReqRespStatus, index: number) => {
-                this.logger.warn(
-                  `Request to peer ${peerAsString} failed with status ${prettyPrintReqRespStatus(status)}`,
-                );
-                markIndexFailed(index);
-                return status === ReqRespStatus.RATE_LIMIT_EXCEEDED;
-              };
-
-              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) {
-                  shouldReplacePeer = handleFailure(response.status, index);
-                  if (shouldReplacePeer) {
-                    break;
-                  }
-                  continue;
-                }
-
-                if (response.data.length === 0) {
-                  markIndexFailed(index);
-                  continue;
-                }
-
-                const object = responseFromBuffer(subProtocol, response.data);
-                if (isEmptyResponse(object)) {
-                  markIndexFailed(index);
-                  continue;
-                }
-
-                const isValid = await responseValidator(requests[index], object, peer);
-                if (!isValid) {
-                  markIndexFailed(index);
-                  continue;
-                }
-
-                peerResults.push({ index, response: object });
-              }
-
-              // If peer had a hard failure (rate limit), replace it for future iterations
-              if (shouldReplacePeer) {
-                this.logger.warn(`Peer ${peerAsString} hit a hard failure, removing from sampler`);
-                batchSampler.removePeerAndReplace(peer);
-              }
-
-              return { peer, results: peerResults };
-            } catch (error) {
-              this.logger.warn(`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.warn(`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.warn(`${e.message} | subProtocol: ${subProtocol}`);
-      return [];
-    }
-  }
-
   /**
    * Sends a request to a specific peer
    *
@@ -462,7 +235,7 @@ export class ReqResp implements ReqRespInterface {
       );
       return resp;
     } catch (e: any) {
-      this.logger.warn(`SUBPROTOCOL: ${subProtocol}\n`, e);
+      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
@@ -596,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);
@@ -740,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;
   }
 
@@ -768,12 +550,6 @@ 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) {
@@ -793,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

@@ -17,12 +17,7 @@ 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 {
@@ -63,6 +58,19 @@ export type DuplicateProposalInfo = {
  */
 export type P2PDuplicateProposalCallback = (info: DuplicateProposalInfo) => void;
 
+/** Minimal info passed to the oversized proposal callback. */
+export type OversizedProposalInfo = {
+  slot: SlotNumber;
+  proposer: EthAddress;
+};
+
+/**
+ * Callback for when a block proposal whose index lands at or beyond the consensus per-checkpoint block
+ * limit is stored and re-broadcast as slashing evidence. May fire multiple times per (slot, proposer)
+ * if the proposer signed several oversized proposals; consumers are expected to dedup.
+ */
+export type P2POversizedProposalCallback = (info: OversizedProposalInfo) => void;
+
 /** Minimal info passed to the duplicate attestation callback. */
 export type DuplicateAttestationInfo = {
   slot: SlotNumber;
@@ -76,6 +84,8 @@ export type DuplicateAttestationInfo = {
  */
 export type P2PDuplicateAttestationCallback = (info: DuplicateAttestationInfo) => void;
 
+export type P2PCheckpointAttestationCallback = (attestation: CheckpointAttestation) => void;
+
 /**
  * The interface for a P2P service implementation.
  */
@@ -98,26 +108,12 @@ export interface P2PService {
    */
   propagate<T extends Gossipable>(message: T): Promise<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
-   */
-  sendBatchRequest<Protocol extends ReqRespSubProtocol>(
-    protocol: Protocol,
-    requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-    pinnedPeerId?: PeerId,
-    timeoutMs?: number,
-    maxPeers?: number,
-    maxRetryAttempts?: number,
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]>;
-
   // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
   registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
 
-  registerCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+  registerValidatorCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+
+  registerAllNodesCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
 
   /**
    * Registers a callback invoked when a duplicate proposal is detected (equivocation).
@@ -125,6 +121,12 @@ export interface P2PService {
    */
   registerDuplicateProposalCallback(callback: P2PDuplicateProposalCallback): void;
 
+  /**
+   * Registers a callback invoked when an oversized block proposal (index at or beyond the consensus
+   * per-checkpoint block limit) is stored and re-broadcast as slashing evidence.
+   */
+  registerOversizedProposalCallback(callback: P2POversizedProposalCallback): void;
+
   /**
    * Registers a callback invoked when a duplicate attestation is detected (equivocation).
    * A validator signing attestations for different proposals at the same slot.
@@ -132,6 +134,8 @@ export interface P2PService {
    */
   registerDuplicateAttestationCallback(callback: P2PDuplicateAttestationCallback): void;
 
+  registerCheckpointAttestationCallback(callback: P2PCheckpointAttestationCallback): void;
+
   getEnr(): ENR | undefined;
 
   getPeers(includePending?: boolean): PeerInfo[];
@@ -141,11 +145,7 @@ export interface P2PService {
 
   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>;
 
@@ -196,6 +196,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;

package/src/services/tx_collection/config.ts

@@ -1,26 +1,9 @@
-import {
-  type ConfigMappingsType,
-  booleanConfigHelper,
-  enumConfigHelper,
-  numberConfigHelper,
-} from '@aztec/foundation/config';
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
 import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
 
-export type MissingTxsCollectorType = 'new' | 'old';
-
 export type TxCollectionConfig = {
   /** How long to wait before starting reqresp for fast collection  */
   txCollectionFastNodesTimeoutBeforeReqRespMs: number;
-  /** How often to collect from configured nodes */
-  txCollectionSlowNodesIntervalMs: number;
-  /** How ofter to collect from peers */
-  txCollectionSlowReqRespIntervalMs: number;
-  /** How long to wait for a reqresp response during slow collection */
-  txCollectionSlowReqRespTimeoutMs: number;
-  /** How often to reconcile found txs with the tx pool */
-  txCollectionReconcileIntervalMs: number;
-  /** Whether to disable the slow collection loop if we are dealing with any immediate requests */
-  txCollectionDisableSlowDuringFastRequests: boolean;
   /** How many ms to wait between retried request to a node via RPC during fast collection */
   txCollectionFastNodeIntervalMs: number;
   /** A comma-separated list of Aztec node RPC URLs to use for tx collection */
@@ -29,26 +12,16 @@ export type TxCollectionConfig = {
   txCollectionFastMaxParallelRequestsPerNode: number;
   /** Maximum number of transactions to request from a node in a single batch */
   txCollectionNodeRpcMaxBatchSize: number;
-  /** Which collector implementation to use for missing txs collection */
-  txCollectionMissingTxsCollectorType: MissingTxsCollectorType;
   /** A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection */
   txCollectionFileStoreUrls: string[];
-  /** Delay in ms before file store collection starts after slow collection is triggered */
-  txCollectionFileStoreSlowDelayMs: number;
-  /** Delay in ms before file store collection starts after fast collection is triggered */
+  /** Delay in ms from reqresp start before file store collection begins */
   txCollectionFileStoreFastDelayMs: number;
   /** Number of concurrent workers for fast file store collection */
   txCollectionFileStoreFastWorkerCount: number;
-  /** Number of concurrent workers for slow file store collection */
-  txCollectionFileStoreSlowWorkerCount: number;
   /** Base backoff time in ms for fast file store collection retries */
   txCollectionFileStoreFastBackoffBaseMs: number;
-  /** Base backoff time in ms for slow file store collection retries */
-  txCollectionFileStoreSlowBackoffBaseMs: number;
   /** Max backoff time in ms for fast file store collection retries */
   txCollectionFileStoreFastBackoffMaxMs: number;
-  /** Max backoff time in ms for slow file store collection retries */
-  txCollectionFileStoreSlowBackoffMaxMs: number;
 };
 
 export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig> = {
@@ -57,31 +30,6 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'How long to wait before starting reqresp for fast collection',
     ...numberConfigHelper(200),
   },
-  txCollectionSlowNodesIntervalMs: {
-    env: 'TX_COLLECTION_SLOW_NODES_INTERVAL_MS',
-    description: 'How often to collect from configured nodes in the slow collection loop',
-    ...numberConfigHelper(12_000),
-  },
-  txCollectionSlowReqRespIntervalMs: {
-    env: 'TX_COLLECTION_SLOW_REQ_RESP_INTERVAL_MS',
-    description: 'How often to collect from peers via reqresp in the slow collection loop',
-    ...numberConfigHelper(12_000),
-  },
-  txCollectionSlowReqRespTimeoutMs: {
-    env: 'TX_COLLECTION_SLOW_REQ_RESP_TIMEOUT_MS',
-    description: 'How long to wait for a reqresp response during slow collection',
-    ...numberConfigHelper(20_000),
-  },
-  txCollectionReconcileIntervalMs: {
-    env: 'TX_COLLECTION_RECONCILE_INTERVAL_MS',
-    description: 'How often to reconcile found txs from the tx pool',
-    ...numberConfigHelper(60_000),
-  },
-  txCollectionDisableSlowDuringFastRequests: {
-    env: 'TX_COLLECTION_DISABLE_SLOW_DURING_FAST_REQUESTS',
-    description: 'Whether to disable the slow collection loop if we are dealing with any immediate requests',
-    ...booleanConfigHelper(true),
-  },
   txCollectionFastNodeIntervalMs: {
     env: 'TX_COLLECTION_FAST_NODE_INTERVAL_MS',
     description: 'How many ms to wait between retried request to a node via RPC during fast collection',
@@ -108,11 +56,6 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'Maximum number of transactions to request from a node in a single batch',
     ...numberConfigHelper(MAX_RPC_TXS_LEN),
   },
-  txCollectionMissingTxsCollectorType: {
-    env: 'TX_COLLECTION_MISSING_TXS_COLLECTOR_TYPE',
-    description: 'Which collector implementation to use for missing txs collection (new or old)',
-    ...enumConfigHelper(['new', 'old'] as const, 'new'),
-  },
   txCollectionFileStoreUrls: {
     env: 'TX_COLLECTION_FILE_STORE_URLS',
     description: 'A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection',
@@ -123,14 +66,9 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
         .filter(url => url.length > 0),
     defaultValue: [],
   },
-  txCollectionFileStoreSlowDelayMs: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_DELAY_MS',
-    description: 'Delay before file store collection starts after slow collection',
-    ...numberConfigHelper(24_000),
-  },
   txCollectionFileStoreFastDelayMs: {
     env: 'TX_COLLECTION_FILE_STORE_FAST_DELAY_MS',
-    description: 'Delay before file store collection starts after fast collection',
+    description: 'Delay in ms from reqresp start before file store collection begins',
     ...numberConfigHelper(2_000),
   },
   txCollectionFileStoreFastWorkerCount: {
@@ -138,29 +76,14 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'Number of concurrent workers for fast file store collection',
     ...numberConfigHelper(5),
   },
-  txCollectionFileStoreSlowWorkerCount: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_WORKER_COUNT',
-    description: 'Number of concurrent workers for slow file store collection',
-    ...numberConfigHelper(2),
-  },
   txCollectionFileStoreFastBackoffBaseMs: {
     env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_BASE_MS',
     description: 'Base backoff time in ms for fast file store collection retries',
     ...numberConfigHelper(1_000),
   },
-  txCollectionFileStoreSlowBackoffBaseMs: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_BACKOFF_BASE_MS',
-    description: 'Base backoff time in ms for slow file store collection retries',
-    ...numberConfigHelper(5_000),
-  },
   txCollectionFileStoreFastBackoffMaxMs: {
     env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_MAX_MS',
     description: 'Max backoff time in ms for fast file store collection retries',
     ...numberConfigHelper(5_000),
   },
-  txCollectionFileStoreSlowBackoffMaxMs: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_BACKOFF_MAX_MS',
-    description: 'Max backoff time in ms for slow file store collection retries',
-    ...numberConfigHelper(30_000),
-  },
 };