@aztec/p2p 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/services/reqresp/batch-tx-requester/peer_collection.ts

@@ -2,23 +2,18 @@ import type { DateProvider } from '@aztec/foundation/timer';
 import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
 import type { PeerId } from '@libp2p/interface';
-import { peerIdFromString } from '@libp2p/peer-id';
 
-import type { ConnectionSampler } from '../connection-sampler/connection_sampler.js';
 import { DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD } from './config.js';
 import type { IPeerPenalizer } from './interface.js';
 
 export const RATE_LIMIT_EXCEEDED_PEER_CACHE_TTL = 1000; // 1s
 
 export interface IPeerCollection {
+  getAllPeers(): Set<string>;
+  getSmartPeers(): Set<string>;
   markPeerSmart(peerId: PeerId): void;
-  markPeerDumb(peerId: PeerId): void;
-
-  /** Sample next peer in round-robin fashion. No smart peers if returns undefined */
-  nextSmartPeerToQuery(): PeerId | undefined;
-  /** Sample next peer in round-robin fashion. No dumb peers if returns undefined */
-  nextDumbPeerToQuery(): PeerId | undefined;
-
+  getSmartPeersToQuery(): Array<string>;
+  getDumbPeersToQuery(): Array<string>;
   thereAreSomeDumbRatelimitExceededPeers(): boolean;
   penalisePeer(peerId: PeerId, severity: PeerErrorSeverity): void;
   unMarkPeerAsBad(peerId: PeerId): void;
@@ -33,6 +28,8 @@ export interface IPeerCollection {
 }
 
 export class PeerCollection implements IPeerCollection {
+  private readonly peers;
+
   private readonly smartPeers = new Set<string>();
   private readonly inFlightPeers = new Set<string>();
   private readonly rateLimitExceededPeers = new Map<string, number>();
@@ -40,64 +37,46 @@ export class PeerCollection implements IPeerCollection {
   private readonly badPeers = new Set<string>();
 
   constructor(
-    private readonly connectionSampler: Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'>,
+    initialPeers: PeerId[],
     private readonly pinnedPeerId: PeerId | undefined,
     private readonly dateProvider: DateProvider,
     private readonly badPeerThreshold: number = DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD,
     private readonly peerPenalizer?: IPeerPenalizer,
   ) {
-    // Pinned peer is treated specially, always mark it as in-flight
+    this.peers = new Set(initialPeers.map(peer => peer.toString()));
+
+    // Pinned peer is treaded specially, always mark it as in-flight
     // and never return it as part of smart/dumb peers
     if (this.pinnedPeerId) {
       const peerIdStr = this.pinnedPeerId.toString();
       this.inFlightPeers.add(peerIdStr);
+      this.peers.delete(peerIdStr);
     }
   }
 
-  public markPeerSmart(peerId: PeerId): void {
-    this.smartPeers.add(peerId.toString());
-  }
-
-  public markPeerDumb(peerId: PeerId): void {
-    this.smartPeers.delete(peerId.toString());
-  }
-
-  // We keep track of all peers that are queried for peer sampling algorithm
-  private queriedSmartPeers: Set<string> = new Set<string>();
-  private queriedDumbPeers: Set<string> = new Set<string>();
-
-  private static nextPeer(allPeers: Set<string>, queried: Set<string>): PeerId | undefined {
-    if (allPeers.size === 0) {
-      return undefined;
-    }
-    const availablePeers = allPeers.difference(queried);
-    let [first] = availablePeers;
-    if (first === undefined) {
-      // We queried all peers. Start over
-      [first] = allPeers;
-      queried.clear();
-    }
-    queried.add(first);
-    return peerIdFromString(first);
+  public getAllPeers(): Set<string> {
+    return this.peers;
   }
 
-  public nextSmartPeerToQuery(): PeerId | undefined {
-    return PeerCollection.nextPeer(this.availableSmartPeers, this.queriedSmartPeers);
+  public getSmartPeers(): Set<string> {
+    return this.smartPeers;
   }
 
-  public nextDumbPeerToQuery(): PeerId | undefined {
-    return PeerCollection.nextPeer(this.availableDumbPeers, this.queriedDumbPeers);
+  public markPeerSmart(peerId: PeerId): void {
+    this.smartPeers.add(peerId.toString());
   }
 
-  private get availableSmartPeers(): Set<string> {
-    return this.peers.intersection(
+  public getSmartPeersToQuery(): Array<string> {
+    return Array.from(
       this.smartPeers.difference(this.getBadPeers().union(this.inFlightPeers).union(this.getRateLimitExceededPeers())),
     );
   }
 
-  private get availableDumbPeers(): Set<string> {
-    return this.peers.difference(
-      this.smartPeers.union(this.getBadPeers()).union(this.inFlightPeers).union(this.getRateLimitExceededPeers()),
+  public getDumbPeersToQuery(): Array<string> {
+    return Array.from(
+      this.peers.difference(
+        this.smartPeers.union(this.getBadPeers()).union(this.inFlightPeers).union(this.getRateLimitExceededPeers()),
+      ),
     );
   }
 
@@ -223,27 +202,4 @@ export class PeerCollection implements IPeerCollection {
 
     return minExpiry! - now;
   }
-
-  private orderedPeers: Set<string> = new Set();
-
-  private get peers(): Set<string> {
-    const pinnedStr = this.pinnedPeerId?.toString();
-    const currentlyConnected = new Set(
-      this.connectionSampler
-        .getPeerListSortedByConnectionCountAsc()
-        .map(p => p.toString())
-        .filter(p => p !== pinnedStr),
-    );
-
-    // Remove disconnected peers, preserving order of the rest.
-    this.orderedPeers = this.orderedPeers.intersection(currentlyConnected);
-
-    // Append newly connected peers at the end (lowest priority).
-    for (const peer of currentlyConnected) {
-      if (!this.orderedPeers.has(peer)) {
-        this.orderedPeers.add(peer);
-      }
-    }
-    return this.orderedPeers;
-  }
 }

package/src/services/reqresp/reqresp.ts

@@ -320,7 +320,7 @@ export class ReqResp implements ReqRespInterface {
               };
 
               for (const index of indices) {
-                this.logger.trace(`Sending request ${index} to peer ${peerAsString}`);
+                this.logger.info(`Sending request ${index} to peer ${peerAsString}`);
                 const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
 
                 // Check the status of the response buffer
@@ -462,7 +462,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
@@ -621,9 +621,7 @@ 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', 'read ECONNRESET'].some(msg =>
-            err.message.includes(msg),
-          );
+          ['stream reset', 'Cannot push value onto an ended pushable'].some(msg => err.message.includes(msg));
         const level = isMessageToNotWarn ? 'debug' : 'warn';
         this.logger[level]('Unknown stream error while handling the stream, aborting', {
           protocol,

package/src/services/service.ts

@@ -196,13 +196,6 @@ export interface PeerDiscoveryService extends EventEmitter {
   on(event: 'peer:discovered', listener: (enr: ENR) => void): this;
   emit(event: 'peer:discovered', enr: ENR): boolean;
 
-  /**
-   * Event emitted when our public IP is discovered or changes via discv5 peer interactions.
-   * Only emitted when enrUpdate is enabled (i.e. queryForIp=true and no static p2pIp).
-   */
-  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/fast_tx_collection.ts

@@ -1,9 +1,12 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
+import { AbortError, TimeoutError } from '@aztec/foundation/error';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, elapsed } from '@aztec/foundation/timer';
 import type { L2BlockInfo } from '@aztec/stdlib/block';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -11,12 +14,12 @@ import type { PeerId } from '@libp2p/interface';
 import type { BatchTxRequesterConfig } from '../reqresp/batch-tx-requester/config.js';
 import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
 import type { TxCollectionConfig } from './config.js';
+import { MissingTxsTracker } from './missing_txs_tracker.js';
 import {
   BatchTxRequesterCollector,
   type MissingTxsCollector,
   SendBatchRequestCollector,
 } from './proposal_tx_collector.js';
-import { RequestTracker } from './request_tracker.js';
 import type { FastCollectionRequest, FastCollectionRequestInput } from './tx_collection.js';
 import type { TxAddContext, TxCollectionSink } from './tx_collection_sink.js';
 import type { TxSource } from './tx_source.js';
@@ -45,9 +48,7 @@ export class FastTxCollection {
   }
 
   public async stop() {
-    this.requests.forEach(request => {
-      request.requestTracker.cancel();
-    });
+    this.requests.forEach(request => request.promise.reject(new AbortError(`Stopped collection service`)));
     await Promise.resolve();
   }
 
@@ -74,65 +75,81 @@ export class FastTxCollection {
         ? { ...input.blockProposal.toBlockInfo(), blockNumber: input.blockNumber }
         : { ...input.block.toBlockInfo() };
 
+    // This promise is used to await for the collection to finish during the main collectFast method.
+    // It gets resolved in `foundTxs` when all txs have been collected, or rejected if the request is aborted or hits the deadline.
+    const promise = promiseWithResolvers<void>();
+    const timeoutTimer = setTimeout(() => promise.reject(new TimeoutError(`Timed out while collecting txs`)), timeout);
+
     const request: FastCollectionRequest = {
       ...input,
       blockInfo,
-      requestTracker: RequestTracker.create(txHashes, opts.deadline, this.dateProvider),
+      promise,
+      missingTxTracker: MissingTxsTracker.fromArray(txHashes),
+      deadline: opts.deadline,
     };
 
     const [duration] = await elapsed(() => this.collectFast(request, { ...opts }));
+    clearTimeout(timeoutTimer);
 
     this.log.verbose(
-      `Collected ${request.requestTracker.collectedTxs.length} txs out of ${txHashes.length} for ${input.type} at slot ${blockInfo.slotNumber}`,
+      `Collected ${request.missingTxTracker.collectedTxs.length} txs out of ${txHashes.length} for ${input.type} at slot ${blockInfo.slotNumber}`,
       {
         ...blockInfo,
         duration,
         requestType: input.type,
-        missingTxs: [...request.requestTracker.missingTxHashes],
+        missingTxs: [...request.missingTxTracker.missingTxHashes],
       },
     );
-    return request.requestTracker.collectedTxs;
+    return request.missingTxTracker.collectedTxs;
   }
 
-  protected async collectFast(request: FastCollectionRequest, opts: { pinnedPeer?: PeerId }) {
+  protected async collectFast(
+    request: FastCollectionRequest,
+    opts: { proposal?: BlockProposal; deadline: Date; pinnedPeer?: PeerId },
+  ) {
     this.requests.add(request);
     const { blockInfo } = request;
 
     this.log.debug(
-      `Starting fast collection of ${request.requestTracker.numberOfMissingTxs} txs for ${request.type} at slot ${blockInfo.slotNumber}`,
-      { ...blockInfo, requestType: request.type, deadline: request.requestTracker.deadline },
+      `Starting fast collection of ${request.missingTxTracker.numberOfMissingTxs} txs for ${request.type} at slot ${blockInfo.slotNumber}`,
+      { ...blockInfo, requestType: request.type, deadline: opts.deadline },
     );
 
     try {
       // Start blasting all nodes for the txs. We give them a little time to respond before we start reqresp.
-      // We race against the cancellation token to exit as soon as all txs are collected, the deadline expires,
-      // or the request is externally cancelled.
-      const nodeCollectionPromise = this.collectFastFromNodes(request);
+      // And keep an eye on the request promise to ensure we don't wait longer than the deadline or return as soon
+      // as we have collected all txs, whatever the source.
+      const nodeCollectionPromise = this.collectFastFromNodes(request, opts);
       const waitBeforeReqResp = sleep(this.config.txCollectionFastNodesTimeoutBeforeReqRespMs);
-      await Promise.race([request.requestTracker.cancellationToken, waitBeforeReqResp]);
+      await Promise.race([request.promise.promise, waitBeforeReqResp]);
 
-      // If we have collected all txs or the request was cancelled, we can stop here.
-      // Wait for node collection to settle so inner tasks finish before we return.
-      if (request.requestTracker.checkCancelled()) {
-        if (request.requestTracker.allFetched()) {
-          this.log.debug(`All txs collected for slot ${blockInfo.slotNumber} without reqresp`, blockInfo);
-        }
-        await nodeCollectionPromise;
+      // If we have collected all txs, we can stop here
+      if (request.missingTxTracker.allFetched()) {
+        this.log.debug(`All txs collected for slot ${blockInfo.slotNumber} without reqresp`, blockInfo);
         return;
       }
 
       // Start blasting reqresp for the remaining txs. Note that node collection keeps running in parallel.
       // We stop when we have collected all txs, timed out, or both node collection and reqresp have given up.
-      // Inner tasks observe requestTracker.checkCancelled() and stop themselves, so this settles shortly after cancellation.
-      await Promise.allSettled([this.collectFastViaReqResp(request, opts), nodeCollectionPromise]);
+      const collectionPromise = Promise.allSettled([this.collectFastViaReqResp(request, opts), nodeCollectionPromise]);
+      await Promise.race([collectionPromise, request.promise.promise]);
     } catch (err) {
-      this.log.error(`Error collecting txs for ${request.type} for slot ${blockInfo.slotNumber}`, err, {
+      // Log and swallow all errors
+      const logCtx = {
         ...blockInfo,
-        missingTxs: request.requestTracker.missingTxHashes.values().map(txHash => txHash.toString()),
-      });
+        errorMessage: err instanceof Error ? err.message : undefined,
+        missingTxs: request.missingTxTracker.missingTxHashes.values().map(txHash => txHash.toString()),
+      };
+      if (err instanceof Error && err.name === 'TimeoutError') {
+        this.log.warn(`Timed out collecting txs for ${request.type} at slot ${blockInfo.slotNumber}`, logCtx);
+      } else if (err instanceof Error && err.name === 'AbortError') {
+        this.log.warn(`Aborted collecting txs for ${request.type} at slot ${blockInfo.slotNumber}`, logCtx);
+      } else {
+        this.log.error(`Error collecting txs for ${request.type} for slot ${blockInfo.slotNumber}`, err, logCtx);
+      }
     } finally {
       // Ensure no unresolved promises and remove the request from the set
-      request.requestTracker.cancel();
+      request.promise.resolve();
       this.requests.delete(request);
     }
   }
@@ -143,28 +160,30 @@ export class FastTxCollection {
    * the txs that have been requested less often whenever we need to send a new batch of requests. We ensure that no
    * tx is requested more than once at the same time to the same node.
    */
-  private async collectFastFromNodes(request: FastCollectionRequest): Promise<void> {
+  private async collectFastFromNodes(request: FastCollectionRequest, opts: { deadline: Date }): Promise<void> {
     if (this.nodes.length === 0) {
       return;
     }
 
     // Keep a shared priority queue of all txs pending to be requested, sorted by the number of attempts made to collect them.
-    const attemptsPerTx = [...request.requestTracker.missingTxHashes].map(txHash => ({
+    const attemptsPerTx = [...request.missingTxTracker.missingTxHashes].map(txHash => ({
       txHash,
       attempts: 0,
       found: false,
     }));
 
     // Returns once we have finished all node loops. Each loop finishes when the deadline is hit, or all txs have been collected.
-    await Promise.allSettled(this.nodes.map(node => this.collectFastFromNode(request, node, attemptsPerTx)));
+    await Promise.allSettled(this.nodes.map(node => this.collectFastFromNode(request, node, attemptsPerTx, opts)));
   }
 
   private async collectFastFromNode(
     request: FastCollectionRequest,
     node: TxSource,
     attemptsPerTx: { txHash: string; attempts: number; found: boolean }[],
+    opts: { deadline: Date },
   ) {
-    const notFinished = () => !request.requestTracker.checkCancelled();
+    const notFinished = () =>
+      this.dateProvider.now() <= +opts.deadline && !request.missingTxTracker.allFetched() && this.requests.has(request);
 
     const maxParallelRequests = this.config.txCollectionFastMaxParallelRequestsPerNode;
     const maxBatchSize = this.config.txCollectionNodeRpcMaxBatchSize;
@@ -181,7 +200,7 @@ export class FastTxCollection {
           if (!txToRequest) {
             // No more txs to process
             break;
-          } else if (!request.requestTracker.isMissing(txToRequest.txHash)) {
+          } else if (!request.missingTxTracker.isMissing(txToRequest.txHash)) {
             // Mark as found if it was found somewhere else, we'll then remove it from the array.
             // We don't delete it now since 'array.splice' is pretty expensive, so we do it after sorting.
             txToRequest.found = true;
@@ -216,7 +235,7 @@ export class FastTxCollection {
           async () => {
             const result = await node.getTxsByHash(txHashes.map(TxHash.fromString));
             for (const tx of result.validTxs) {
-              request.requestTracker.markFetched(tx);
+              request.missingTxTracker.markFetched(tx);
             }
             return result;
           },
@@ -235,12 +254,9 @@ export class FastTxCollection {
           activeRequestsToThisNode.delete(requestedTx.txHash);
         }
 
-        // Sleep a bit until hitting the node again, but wake up immediately on cancellation
+        // Sleep a bit until hitting the node again (or not, depending on config)
         if (notFinished()) {
-          await Promise.race([
-            sleep(this.config.txCollectionFastNodeIntervalMs),
-            request.requestTracker.cancellationToken,
-          ]);
+          await sleep(this.config.txCollectionFastNodeIntervalMs);
         }
       }
     };
@@ -250,20 +266,21 @@ export class FastTxCollection {
   }
 
   private async collectFastViaReqResp(request: FastCollectionRequest, opts: { pinnedPeer?: PeerId }) {
+    const timeoutMs = +request.deadline - this.dateProvider.now();
     const pinnedPeer = opts.pinnedPeer;
     const blockInfo = request.blockInfo;
     const slotNumber = blockInfo.slotNumber;
-    if (request.requestTracker.timeoutMs < 100) {
+    if (timeoutMs < 100) {
       this.log.warn(
         `Not initiating fast reqresp for txs for ${request.type} at slot ${blockInfo.slotNumber} due to timeout`,
-        { timeoutMs: request.requestTracker.timeoutMs, ...blockInfo },
+        { timeoutMs, ...blockInfo },
       );
       return;
     }
 
     this.log.debug(
-      `Starting fast reqresp for ${request.requestTracker.numberOfMissingTxs} txs for ${request.type} at slot ${blockInfo.slotNumber}`,
-      { ...blockInfo, timeoutMs: request.requestTracker.timeoutMs, pinnedPeer },
+      `Starting fast reqresp for ${request.missingTxTracker.numberOfMissingTxs} txs for ${request.type} at slot ${blockInfo.slotNumber}`,
+      { ...blockInfo, timeoutMs, pinnedPeer },
     );
 
     try {
@@ -272,28 +289,34 @@ export class FastTxCollection {
           let result: Tx[];
           if (request.type === 'proposal') {
             result = await this.missingTxsCollector.collectTxs(
-              request.requestTracker,
+              request.missingTxTracker,
               request.blockProposal,
               pinnedPeer,
+              timeoutMs,
             );
           } else if (request.type === 'block') {
             const blockTxsSource = {
               txHashes: request.block.body.txEffects.map(e => e.txHash),
               archive: request.block.archive.root,
             };
-            result = await this.missingTxsCollector.collectTxs(request.requestTracker, blockTxsSource, pinnedPeer);
+            result = await this.missingTxsCollector.collectTxs(
+              request.missingTxTracker,
+              blockTxsSource,
+              pinnedPeer,
+              timeoutMs,
+            );
           } else {
             throw new Error(`Unknown request type: ${(request as any).type}`);
           }
           return { validTxs: result, invalidTxHashes: [] };
         },
-        Array.from(request.requestTracker.missingTxHashes),
+        Array.from(request.missingTxTracker.missingTxHashes),
         { description: `reqresp for slot ${slotNumber}`, method: 'fast-req-resp', ...opts, ...request.blockInfo },
         this.getAddContext(request),
       );
     } catch (err) {
       this.log.error(`Error sending fast reqresp request for txs`, err, {
-        txs: [...request.requestTracker.missingTxHashes],
+        txs: [...request.missingTxTracker.missingTxHashes],
         ...blockInfo,
       });
     }
@@ -317,19 +340,20 @@ export class FastTxCollection {
       for (const tx of txs) {
         const txHash = tx.txHash.toString();
         // Remove the tx hash from the missing set, and add it to the found set.
-        if (request.requestTracker.markFetched(tx)) {
+        if (request.missingTxTracker.markFetched(tx)) {
           this.log.trace(`Found tx ${txHash} for fast collection request`, {
             ...request.blockInfo,
             txHash: tx.txHash.toString(),
             type: request.type,
           });
-          if (request.requestTracker.allFetched()) {
-            this.log.trace(`All txs found for fast collection request`, {
-              ...request.blockInfo,
-              type: request.type,
-            });
-            break;
-          }
+        }
+        // If we found all txs for this request, we resolve the promise
+        if (request.missingTxTracker.allFetched()) {
+          this.log.trace(`All txs found for fast collection request`, {
+            ...request.blockInfo,
+            type: request.type,
+          });
+          request.promise.resolve();
         }
       }
     }
@@ -342,7 +366,8 @@ export class FastTxCollection {
   public stopCollectingForBlocksUpTo(blockNumber: BlockNumber): void {
     for (const request of this.requests) {
       if (request.blockInfo.blockNumber <= blockNumber) {
-        request.requestTracker.cancel();
+        request.promise.reject(new AbortError(`Stopped collecting txs up to block ${blockNumber}`));
+        this.requests.delete(request);
       }
     }
   }
@@ -354,7 +379,8 @@ export class FastTxCollection {
   public stopCollectingForBlocksAfter(blockNumber: BlockNumber): void {
     for (const request of this.requests) {
       if (request.blockInfo.blockNumber > blockNumber) {
-        request.requestTracker.cancel();
+        request.promise.reject(new AbortError(`Stopped collecting txs after block ${blockNumber}`));
+        this.requests.delete(request);
       }
     }
   }

package/src/services/tx_collection/missing_txs_tracker.ts

@@ -0,0 +1,52 @@
+import { TxHash } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
+
+/**
+ * Tracks which transactions are still missing and need to be fetched.
+ * Allows external code to mark transactions as fetched, enabling coordination
+ * between multiple fetching mechanisms (e.g., BatchTxRequester and Rpc Node requests).
+ */
+export interface IMissingTxsTracker {
+  /** Returns the set of transaction hashes that are still missing. */
+  get missingTxHashes(): Set<string>;
+  /** Size of this.missingTxHashes */
+  get numberOfMissingTxs(): number;
+  /** Are all requested txs are fetched */
+  allFetched(): boolean;
+  /** Checks that transaction is still missing */
+  isMissing(txHash: string): boolean;
+  /** Marks a transaction as fetched. Returns true if it was previously missing. */
+  markFetched(tx: Tx): boolean;
+  /** Get list of collected txs */
+  get collectedTxs(): Tx[];
+}
+
+export class MissingTxsTracker implements IMissingTxsTracker {
+  public readonly collectedTxs: Tx[] = [];
+
+  private constructor(public readonly missingTxHashes: Set<string>) {}
+
+  public static fromArray(hashes: TxHash[] | string[]) {
+    return new MissingTxsTracker(new Set(hashes.map(hash => hash.toString())));
+  }
+
+  markFetched(tx: Tx): boolean {
+    if (this.missingTxHashes.delete(tx.txHash.toString())) {
+      this.collectedTxs.push(tx);
+      return true;
+    }
+    return false;
+  }
+
+  get numberOfMissingTxs(): number {
+    return this.missingTxHashes.size;
+  }
+
+  allFetched(): boolean {
+    return this.numberOfMissingTxs === 0;
+  }
+
+  isMissing(txHash: string): boolean {
+    return this.missingTxHashes.has(txHash.toString());
+  }
+}

package/src/services/tx_collection/proposal_tx_collector.ts

@@ -9,7 +9,7 @@ import type { BatchTxRequesterConfig } from '../reqresp/batch-tx-requester/confi
 import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
 import type { IBatchRequestTxValidator } from '../reqresp/batch-tx-requester/tx_validator.js';
 import { type BlockTxsSource, ReqRespSubProtocol, chunkTxHashesRequest } from '../reqresp/index.js';
-import type { IRequestTracker } from './request_tracker.js';
+import type { IMissingTxsTracker } from './missing_txs_tracker.js';
 
 /**
  * Strategy interface for collecting missing transactions for a block or proposal.
@@ -18,15 +18,17 @@ import type { IRequestTracker } from './request_tracker.js';
 export interface MissingTxsCollector {
   /**
    * Collect missing transactions for a block or proposal.
-   * @param requestTracker - The missing transactions tracker
+   * @param missingTxsTracker - The missing transactions tracker
    * @param blockTxsSource - The block or proposal containing the transactions
    * @param pinnedPeer - Optional peer expected to have the transactions
+   * @param timeoutMs - Timeout in milliseconds
    * @returns The collected transactions
    */
   collectTxs(
-    requestTracker: IRequestTracker,
+    missingTxsTracker: IMissingTxsTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
   ): Promise<Tx[]>;
 }
 
@@ -44,9 +46,10 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
   ) {}
 
   async collectTxs(
-    requestTracker: IRequestTracker,
+    missingTxsTracker: IMissingTxsTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
   ): Promise<Tx[]> {
     const {
       batchTxRequesterSmartParallelWorkerCount: smartParallelWorkerCount,
@@ -56,9 +59,10 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
     } = this.batchTxRequesterConfig ?? {};
 
     const batchRequester = new BatchTxRequester(
-      requestTracker,
+      missingTxsTracker,
       blockTxsSource,
       pinnedPeer,
+      timeoutMs,
       this.p2pService,
       this.log,
       this.dateProvider,
@@ -90,15 +94,16 @@ export class SendBatchRequestCollector implements MissingTxsCollector {
   ) {}
 
   async collectTxs(
-    requestTracker: IRequestTracker,
+    missingTxsTracker: IMissingTxsTracker,
     _blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
   ): Promise<Tx[]> {
     const txs = await this.p2pService.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
       ReqRespSubProtocol.TX,
-      chunkTxHashesRequest(Array.from(requestTracker.missingTxHashes).map(TxHash.fromString)),
+      chunkTxHashesRequest(Array.from(missingTxsTracker.missingTxHashes).map(TxHash.fromString)),
       pinnedPeer,
-      requestTracker.timeoutMs,
+      timeoutMs,
       this.maxPeers,
       this.maxRetryAttempts,
     );

package/src/services/tx_collection/slow_tx_collection.ts

@@ -196,7 +196,7 @@ export class SlowTxCollection {
     // from mined unproven blocks it has seen in the past.
     const fastRequests = this.fastCollection.getFastCollectionRequests();
     const fastCollectionTxs: Set<string> = new Set(
-      fastRequests.values().flatMap(r => Array.from(r.requestTracker.missingTxHashes)),
+      fastRequests.values().flatMap(r => Array.from(r.missingTxTracker.missingTxHashes)),
     );
 
     // Return all missing txs that are not in fastCollectionTxs and are ready for reqresp if requested