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

package/src/services/reqresp/batch-tx-requester/README.md

@@ -170,37 +170,6 @@ class BlockTxsResponse {
 
 The `BitVector` is a compact representation where each bit corresponds to a transaction index in the block proposal. This allows efficient capability advertisement without repeating full hashes.
 
-## Cancellation
-
-All cancellation is managed by a single `RequestTracker` instance, shared across the entire collection
-flow. The `RequestTracker` owns the deadline, tracks which txs are still missing, and exposes a
-`cancellationToken` promise that resolves when the request should stop (deadline hit, all txs fetched,
-or external `cancel()` call).
-
-Cancellation propagates from the deepest stack level upward:
-
-```
-RequestTracker.finish()
-  ├── resolves cancellationToken promise
-  │
-  ├── BatchTxRequester workers (deepest)
-  │     ├── shouldStop() checks requestTracker.cancelled → exit loop
-  │     ├── sleepClampedToDeadline races sleep vs cancellationToken → wakes
-  │     └── semaphore.acquire races vs cancellationToken → wakes
-  │           │
-  │           ▼ workers settle → txQueue.end() → generator returns
-  │
-  ├── Node collection loops
-  │     ├── notFinished() checks requestTracker.cancelled → exit loop
-  │     └── inter-retry sleep races vs cancellationToken → wakes
-  │           │
-  │           ▼ all node loops settle
-  │
-  └── collectFast (outermost)
-        awaits Promise.allSettled([reqresp, nodes]) → settles after inner tasks
-        finally: requestTracker.cancel() (idempotent), cleanup
-```
-
 ## Key Files
 
 | File | Description |
@@ -210,16 +179,15 @@ RequestTracker.finish()
 | `peer_collection.ts` | Manages peer classification (dumb/smart/bad) and rate limiting |
 | `interface.ts` | Type definitions for dependencies |
 | `../protocols/block_txs/` | Wire protocol definitions (`BlockTxsRequest`, `BlockTxsResponse`, `BitVector`) |
-| `../../tx_collection/request_tracker.ts` | Centralized deadline, missing tx tracking, and cancellation signal |
 
 ## Stopping Conditions
 
-The `BatchTxRequester` stops when any of these conditions are met, all managed by the `RequestTracker`:
+The `BatchTxRequester` stops when any of these conditions are met:
 
-1. **All transactions fetched** - `markFetched()` removes the last missing tx, triggering `finish()`
-2. **Deadline exceeded** - `setTimeout` in `RequestTracker` fires, triggering `finish()`
-3. **External cancellation** - `RequestTracker.cancel()` called (e.g., from `stop()`, `stopCollectingForBlocksUpTo`)
-4. **No transactions to fetch** - Empty hash set at construction, `RequestTracker` finishes immediately
+1. **All transactions fetched** - Success!
+2. **Deadline exceeded** - Timeout configured by caller
+3. **Abort signal** - External cancellation
+4. **No transactions to fetch** - Nothing was missing
 
 ## Configuration
 
@@ -260,15 +228,11 @@ Request to peer fails
 ## Usage Example
 
 ```typescript
-const requestTracker = RequestTracker.create(
-  missingTxHashes,                          // TxHash[] - what we need
-  new Date(Date.now() + 5_000),             // deadline
-);
-
 const requester = new BatchTxRequester(
-  requestTracker,       // IRequestTracker - tracks missing txs, deadline, and cancellation
+  missingTxHashes,      // TxHash[] - what we need
   blockTxsSource,       // BlockTxsSource - the proposal or block we need txs for
   pinnedPeer,           // PeerId | undefined - peer expected to have the txs
+  timeoutMs,            // number - how long to try
   p2pService,           // BatchTxRequesterLibP2PService
 );
 
@@ -309,8 +273,6 @@ const txs = await BatchTxRequester.collectAllTxs(requester.run());
 │  1. Try RPC nodes first (fast)    │   │  Periodic polling of RPC nodes      │
 │  2. Fall back to BatchTxRequester │   │  and peers for missing txs          │
 │                                   │   │                                     │
-│  Creates RequestTracker per       │   │                                     │
-│  request with deadline            │   │                                     │
 └───────────────────┬───────────────┘   └─────────────────────────────────────┘
                     │
                     │ For 'proposal' and 'block' requests
@@ -319,7 +281,6 @@ const txs = await BatchTxRequester.collectAllTxs(requester.run());
 │                           BatchTxRequester                                  │
 │                                                                             │
 │  Aggressive parallel fetching from multiple peers                           │
-│  Shares RequestTracker with FastTxCollection for unified cancellation       │
 │  Uses BLOCK_TXS sub-protocol for efficient batching                         │
 └───────────────────┬─────────────────────────────────────────────────────────┘
                     │

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

@@ -1,14 +1,16 @@
 import { chunkWrapAround } from '@aztec/foundation/collection';
+import { TimeoutError } from '@aztec/foundation/error';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { FifoMemoryQueue, type ISemaphore, Semaphore } from '@aztec/foundation/queue';
 import { sleep } from '@aztec/foundation/sleep';
-import { DateProvider } from '@aztec/foundation/timer';
+import { DateProvider, executeTimeout } from '@aztec/foundation/timer';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Tx, TxArray, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
+import { peerIdFromString } from '@libp2p/peer-id';
 
-import type { IRequestTracker } from '../../tx_collection/request_tracker.js';
+import type { IMissingTxsTracker } from '../../tx_collection/missing_txs_tracker.js';
 import { ReqRespSubProtocol } from '.././interface.js';
 import { BlockTxsRequest, BlockTxsResponse, type BlockTxsSource } from '.././protocols/index.js';
 import { ReqRespStatus } from '.././status.js';
@@ -41,14 +43,16 @@ import { BatchRequestTxValidator, type IBatchRequestTxValidator } from './tx_val
  *    - Is the peer which was unable to send us successful response N times in a row
  * */
 export class BatchTxRequester {
-  private readonly requestTracker: IRequestTracker;
   private readonly blockTxsSource: BlockTxsSource;
   private readonly pinnedPeer: PeerId | undefined;
+  private readonly timeoutMs: number;
   private readonly p2pService: BatchTxRequesterLibP2PService;
   private readonly logger: Logger;
+  private readonly dateProvider: DateProvider;
   private readonly opts: BatchTxRequesterOptions;
   private readonly peers: IPeerCollection;
   private readonly txsMetadata: ITxMetadataCollection;
+  private readonly deadline: number;
   private readonly smartRequesterSemaphore: ISemaphore;
   private readonly txQueue: FifoMemoryQueue<Tx>;
   private readonly txValidator: IBatchRequestTxValidator;
@@ -57,19 +61,21 @@ export class BatchTxRequester {
   private readonly txBatchSize: number;
 
   constructor(
-    requestTracker: IRequestTracker,
+    missingTxsTracker: IMissingTxsTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
     p2pService: BatchTxRequesterLibP2PService,
     logger?: Logger,
     dateProvider?: DateProvider,
     opts?: BatchTxRequesterOptions,
   ) {
-    this.requestTracker = requestTracker;
     this.blockTxsSource = blockTxsSource;
     this.pinnedPeer = pinnedPeer;
+    this.timeoutMs = timeoutMs;
     this.p2pService = p2pService;
     this.logger = logger ?? createLogger('p2p:reqresp_batch');
+    this.dateProvider = dateProvider ?? new DateProvider();
     this.opts = opts ?? {};
 
     this.smartParallelWorkerCount =
@@ -77,22 +83,24 @@ export class BatchTxRequester {
     this.dumbParallelWorkerCount =
       this.opts.dumbParallelWorkerCount ?? DEFAULT_BATCH_TX_REQUESTER_DUMB_PARALLEL_WORKER_COUNT;
     this.txBatchSize = this.opts.txBatchSize ?? DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE;
+    this.deadline = this.dateProvider.now() + this.timeoutMs;
     this.txQueue = new FifoMemoryQueue(this.logger);
     this.txValidator = this.opts.txValidator ?? new BatchRequestTxValidator(this.p2pService.txValidatorConfig);
 
     if (this.opts.peerCollection) {
       this.peers = this.opts.peerCollection;
     } else {
+      const initialPeers = this.p2pService.connectionSampler.getPeerListSortedByConnectionCountAsc();
       const badPeerThreshold = this.opts.badPeerThreshold ?? DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD;
       this.peers = new PeerCollection(
-        this.p2pService.connectionSampler,
+        initialPeers,
         this.pinnedPeer,
-        dateProvider ?? new DateProvider(),
+        this.dateProvider,
         badPeerThreshold,
         this.p2pService.peerScoring,
       );
     }
-    this.txsMetadata = new MissingTxMetadataCollection(requestTracker, this.txBatchSize);
+    this.txsMetadata = new MissingTxMetadataCollection(missingTxsTracker, this.txBatchSize);
     this.smartRequesterSemaphore = this.opts.semaphore ?? new Semaphore(0);
   }
 
@@ -100,30 +108,40 @@ export class BatchTxRequester {
    * Fetches all missing transactions and yields them  one by one
    * */
   public async *run(): AsyncGenerator<Tx, Tx | undefined, unknown> {
+    // Our timeout is represented in milliseconds but queue expects seconds
+    // We also want to make sure we wait at least 1 second in case of very low timeouts
+    const timeoutQueueAfter = Math.max(Math.ceil(this.timeoutMs / 1_000), 1);
     try {
       if (this.txsMetadata.getMissingTxHashes().size === 0) {
         return undefined;
       }
 
-      // Start workers in background. Workers stop themselves via requestTracker.checkCancelled().
-      const workersPromise = Promise.allSettled([
-        this.smartRequester(),
-        this.dumbRequester(),
-        this.pinnedPeerRequester(),
-      ]).finally(() => {
+      // Start workers in background
+      const workersPromise = executeTimeout(
+        () => Promise.allSettled([this.smartRequester(), this.dumbRequester(), this.pinnedPeerRequester()]),
+        this.timeoutMs,
+      ).finally(() => {
         this.txQueue.end();
       });
 
-      // Yield txs as workers put them on the queue. The queue's end() drains remaining items
-      // before returning null, so we don't lose any txs.
       while (true) {
-        const tx = await this.txQueue.get();
+        const tx = await this.txQueue.get(timeoutQueueAfter);
 
+        // null indicates that the queue has ended
         if (tx === null) {
           break;
         }
 
         yield tx;
+
+        if (this.shouldStop()) {
+          // Drain queue before ending
+          let remaining;
+          while ((remaining = this.txQueue.getImmediate()) !== undefined) {
+            yield remaining;
+          }
+          break;
+        }
       }
 
       this.unlockSmartRequesterSemaphores();
@@ -209,6 +227,7 @@ export class BatchTxRequester {
    * Starts dumb worker loops
    * */
   private async dumbRequester() {
+    const nextPeerIndex = this.makeRoundRobinIndexer();
     const nextBatchIndex = this.makeRoundRobinIndexer();
 
     // Chunk missing tx hashes into batches of txBatchSize, wrapping around to ensure no peer gets less than txBatchSize
@@ -244,9 +263,15 @@ export class BatchTxRequester {
       return { blockRequest, txs };
     };
 
-    const workerCount = this.dumbParallelWorkerCount;
+    const nextPeer = () => {
+      const peers = this.peers.getDumbPeersToQuery();
+      const idx = nextPeerIndex(() => peers.length);
+      return idx === undefined ? undefined : peerIdFromString(peers[idx]);
+    };
+
+    const workerCount = Math.min(this.dumbParallelWorkerCount, this.peers.getAllPeers().size);
     const workers = Array.from({ length: workerCount }, (_, index) =>
-      this.dumbWorkerLoop(this.peers.nextDumbPeerToQuery.bind(this.peers), makeRequest, index + 1),
+      this.dumbWorkerLoop(nextPeer, makeRequest, index + 1),
     );
 
     await Promise.allSettled(workers);
@@ -307,6 +332,14 @@ export class BatchTxRequester {
    * Starts smart worker loops
    * */
   private async smartRequester() {
+    const nextPeerIndex = this.makeRoundRobinIndexer();
+
+    const nextPeer = () => {
+      const peers = this.peers.getSmartPeersToQuery();
+      const idx = nextPeerIndex(() => peers.length);
+      return idx === undefined ? undefined : peerIdFromString(peers[idx]);
+    };
+
     const makeRequest = (pid: PeerId) => {
       const txs = this.txsMetadata.getTxsToRequestFromThePeer(pid);
       const blockRequest = BlockTxsRequest.fromTxsSourceAndMissingTxs(this.blockTxsSource, txs);
@@ -317,8 +350,9 @@ export class BatchTxRequester {
       return { blockRequest, txs };
     };
 
-    const workers = Array.from({ length: this.smartParallelWorkerCount }, (_, index) =>
-      this.smartWorkerLoop(this.peers.nextSmartPeerToQuery.bind(this.peers), makeRequest, index + 1),
+    const workers = Array.from(
+      { length: Math.min(this.smartParallelWorkerCount, this.peers.getAllPeers().size) },
+      (_, index) => this.smartWorkerLoop(nextPeer, makeRequest, index + 1),
     );
 
     await Promise.allSettled(workers);
@@ -344,10 +378,7 @@ export class BatchTxRequester {
   ) {
     try {
       this.logger.trace(`Smart worker ${workerIndex} started`);
-      await Promise.race([this.smartRequesterSemaphore.acquire(), this.requestTracker.cancellationToken]);
-      if (this.requestTracker.checkCancelled()) {
-        return;
-      }
+      await executeTimeout((_: AbortSignal) => this.smartRequesterSemaphore.acquire(), this.timeoutMs);
       this.logger.trace(`Smart worker ${workerIndex} acquired semaphore`);
 
       while (!this.shouldStop()) {
@@ -356,25 +387,30 @@ export class BatchTxRequester {
         if (weRanOutOfPeersToQuery) {
           this.logger.debug(`Worker loop smart: No more peers to query`);
 
-          // If we have rate limited peers wait for them.
-          const nextSmartPeerDelay = this.peers.getNextSmartPeerAvailabilityDelayMs();
-          const thereAreSomeRateLimitedSmartPeers = nextSmartPeerDelay !== undefined;
-          if (thereAreSomeRateLimitedSmartPeers) {
-            await this.sleepClampedToDeadline(nextSmartPeerDelay);
-            continue;
+          // If there are no more dumb peers to query then none of our peers can become smart,
+          // thus we can simply exit this worker
+          const noMoreDumbPeersToQuery = this.peers.getDumbPeersToQuery().length === 0;
+          if (noMoreDumbPeersToQuery) {
+            // These might be either smart peers that will get unblocked after _some time_
+            const nextSmartPeerDelay = this.peers.getNextSmartPeerAvailabilityDelayMs();
+            const thereAreSomeRateLimitedSmartPeers = nextSmartPeerDelay !== undefined;
+            if (thereAreSomeRateLimitedSmartPeers) {
+              await this.sleepClampedToDeadline(nextSmartPeerDelay);
+              continue;
+            }
+
+            this.logger.debug(`Worker loop smart: No more smart peers to query killing ${workerIndex}`);
+            break;
           }
 
+          // Otherwise there are still some dumb peers that could become smart.
           // We end up here when all known smart peers became temporarily unavailable via combination of
           // (bad, in-flight, or rate-limited) or in some weird scenario all current smart peers turn bad which is permanent
-          // but there are dumb peers that could be promoted
-          // or new peer can join as dumb and be promoted later
+          // but dumb peers still exist that could become smart.
           //
           // When a dumb peer responds with valid txIndices, it gets
           // promoted to smart and releases the semaphore, waking this worker.
-          await Promise.race([this.smartRequesterSemaphore.acquire(), this.requestTracker.cancellationToken]);
-          if (this.requestTracker.checkCancelled()) {
-            break;
-          }
+          await executeTimeout((_: AbortSignal) => this.smartRequesterSemaphore.acquire(), this.timeoutMs);
           this.logger.debug(`Worker loop smart: acquired next smart peer`);
           continue;
         }
@@ -401,7 +437,11 @@ export class BatchTxRequester {
         });
       }
     } catch (err: any) {
-      this.logger.error(`Smart worker ${workerIndex} encountered an error: ${err}`);
+      if (err instanceof TimeoutError) {
+        this.logger.debug(`Smart worker ${workerIndex} timed out waiting for semaphore`);
+      } else {
+        this.logger.error(`Smart worker ${workerIndex} encountered an error: ${err}`);
+      }
     } finally {
       this.logger.debug(`Smart worker ${workerIndex} finished`);
     }
@@ -449,18 +489,9 @@ export class BatchTxRequester {
    *   this implies we will query these peers couple of more times and give them a chance to "redeem" themselves before completely ignoring them
    */
   private handleFailResponseFromPeer(peerId: PeerId, responseStatus: ReqRespStatus) {
+    //TODO: Should we ban these peers?
     if (responseStatus === ReqRespStatus.FAILURE || responseStatus === ReqRespStatus.UNKNOWN) {
       this.peers.penalisePeer(peerId, PeerErrorSeverity.HighToleranceError);
-      this.peers.markPeerDumb(peerId);
-      this.txsMetadata.clearPeerData(peerId);
-      return;
-    }
-
-    // NOT_FOUND means the peer pruned its block proposal — it can no longer serve
-    // index-based requests, but this is a legitimate state so we don't penalize.
-    if (responseStatus === ReqRespStatus.NOT_FOUND) {
-      this.peers.markPeerDumb(peerId);
-      this.txsMetadata.clearPeerData(peerId);
       return;
     }
 
@@ -514,9 +545,6 @@ export class BatchTxRequester {
     });
 
     if (hasInvalidTx) {
-      this.logger.warn(`Penalizing peer ${peerId.toString()} for sending invalid transactions in batch response`, {
-        peerId,
-      });
       this.peers.penalisePeer(peerId, PeerErrorSeverity.LowToleranceError);
     } else {
       // If we have received successful response from the peer, they have "redeemed" themselves and not considered bad anymore
@@ -553,9 +581,10 @@ export class BatchTxRequester {
       return;
     }
 
-    const hasArchiveRootMismatch = this.blockTxsSource.archive.toString() !== response.archiveRoot.toString();
-    if (hasArchiveRootMismatch) {
-      this.handleArchiveRootMismatch(peerId, response);
+    // If block response is invalid we still want to query this peer in the future
+    // Because they sent successful response, so they might become smart peer in the future
+    // Or send us needed txs
+    if (!this.isBlockResponseValid(response)) {
       return;
     }
 
@@ -570,28 +599,18 @@ export class BatchTxRequester {
     this.markTxsPeerHas(peerId, response);
 
     // Unblock smart workers
-    this.smartRequesterSemaphore.release();
-  }
-
-  /**
-   * Handles an archive root mismatch between local state and peer response.
-   *
-   * - Response archive is Fr.ZERO (peer pruned proposal, legitimate): marks peer dumb.
-   * - Non-zero archive mismatch (malicious response): penalises + marks dumb.
-   */
-  private handleArchiveRootMismatch(peerId: PeerId, response: BlockTxsResponse): void {
-    if (!response.archiveRoot.isZero()) {
-      this.peers.penalisePeer(peerId, PeerErrorSeverity.LowToleranceError);
+    if (this.peers.getSmartPeersToQuery().length <= this.smartParallelWorkerCount) {
+      this.smartRequesterSemaphore.release();
     }
+  }
 
-    this.peers.markPeerDumb(peerId);
-    this.txsMetadata.clearPeerData(peerId);
+  private isBlockResponseValid(response: BlockTxsResponse): boolean {
+    const archiveRootsMatch = this.blockTxsSource.archive.toString() === response.archiveRoot.toString();
+    const peerHasSomeTxsFromProposal = !response.txIndices.isEmpty();
+    return archiveRootsMatch && peerHasSomeTxsFromProposal;
   }
 
   private peerHasSomeTxsWeAreMissing(_peerId: PeerId, response: BlockTxsResponse): boolean {
-    if (response.txIndices.isEmpty()) {
-      return false;
-    }
     const txsPeerHas = new Set(this.extractHashesPeerHasFromResponse(response).map(h => h.toString()));
     return this.txsMetadata.getMissingTxHashes().intersection(txsPeerHas).size > 0;
   }
@@ -640,14 +659,27 @@ export class BatchTxRequester {
   }
 
   /*
-   * Checks if the BatchTxRequester should stop fetching missing txs.
-   * Delegates to requestTracker which covers: deadline hit, all txs fetched, or external cancellation. */
+   * @returns true if all missing txs have been fetched */
+  private fetchedAllTxs() {
+    return this.txsMetadata.getMissingTxHashes().size == 0;
+  }
+
+  /*
+   * Checks if the BatchTxRequester should stop fetching missing txs
+   * Conditions for stopping are:
+   * - There have been no missing transactions to start with
+   * - All transactions have been fetched
+   * - The deadline has been hit (no more time to fetch)
+   * - This process has been cancelled via abortSignal
+   *
+   * @returns true if BatchTxRequester should stop, otherwise false*/
   private shouldStop() {
-    if (this.requestTracker.checkCancelled()) {
+    const aborted = this.opts.abortSignal?.aborted ?? false;
+    if (aborted) {
       this.unlockSmartRequesterSemaphores();
     }
 
-    return this.requestTracker.checkCancelled();
+    return aborted || this.fetchedAllTxs() || this.dateProvider.now() > this.deadline;
   }
 
   /*
@@ -665,9 +697,10 @@ export class BatchTxRequester {
    * This ensures we don't sleep past the deadline.
    * */
   private async sleepClampedToDeadline(durationMs: number) {
-    if (this.requestTracker.checkCancelled()) {
-      return;
+    const remaining = this.deadline - this.dateProvider.now();
+    const thereIsTimeRemaining = remaining > 0;
+    if (thereIsTimeRemaining) {
+      await sleep(Math.min(durationMs, remaining));
     }
-    await Promise.race([sleep(durationMs), this.requestTracker.cancellationToken]);
   }
 }

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

@@ -23,8 +23,6 @@ export interface ITxMetadataCollection {
   alreadyFetched(txHash: TxHash): boolean;
   // Returns true if tx was marked as fetched, false if it was already marked as fetched
   markPeerHas(peerId: PeerId, txHashes: TxHash[]): void;
-  /** Remove all tx metadata associations for a peer (e.g. on demotion from smart to dumb). */
-  clearPeerData(peerId: PeerId): void;
 }
 
 /**
@@ -49,6 +47,7 @@ export interface BatchTxRequesterOptions {
   //Injectable for testing purposes
   semaphore?: ISemaphore;
   peerCollection?: IPeerCollection;
+  abortSignal?: AbortSignal;
   /** Optional tx validator for testing - if not provided, one is created from p2pService.txValidatorConfig */
   txValidator?: IBatchRequestTxValidator;
 }

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

@@ -2,7 +2,7 @@ import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
-import type { IRequestTracker } from '../../tx_collection/request_tracker.js';
+import type { IMissingTxsTracker } from '../../tx_collection/missing_txs_tracker.js';
 import { DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE } from './config.js';
 import type { ITxMetadataCollection } from './interface.js';
 
@@ -41,10 +41,10 @@ export class MissingTxMetadataCollection implements ITxMetadataCollection {
   private txMetadata = new Map<string, MissingTxMetadata>();
 
   constructor(
-    private requestTracker: IRequestTracker,
+    private missingTxsTracker: IMissingTxsTracker,
     private readonly txBatchSize: number = DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE,
   ) {
-    requestTracker.missingTxHashes.forEach(hash => this.txMetadata.set(hash, new MissingTxMetadata(hash)));
+    missingTxsTracker.missingTxHashes.forEach(hash => this.txMetadata.set(hash, new MissingTxMetadata(hash)));
   }
 
   public getPrioritizingNotInFlightAndLowerRequestCount(txs: string[]): MissingTxMetadata[] {
@@ -65,7 +65,7 @@ export class MissingTxMetadataCollection implements ITxMetadataCollection {
   }
 
   public getMissingTxHashes(): Set<string> {
-    return this.requestTracker.missingTxHashes;
+    return this.missingTxsTracker.missingTxHashes;
   }
 
   public getTxsPeerHas(peer: PeerId): Set<string> {
@@ -128,7 +128,7 @@ export class MissingTxMetadataCollection implements ITxMetadataCollection {
   }
 
   public alreadyFetched(txHash: TxHash): boolean {
-    return !this.requestTracker.isMissing(txHash.toString());
+    return !this.missingTxsTracker.isMissing(txHash.toString());
   }
 
   public markFetched(peerId: PeerId, tx: Tx): boolean {
@@ -144,7 +144,7 @@ export class MissingTxMetadataCollection implements ITxMetadataCollection {
     }
 
     txMeta.peers.add(peerId.toString());
-    return this.requestTracker.markFetched(tx);
+    return this.missingTxsTracker.markFetched(tx);
   }
 
   public markPeerHas(peerId: PeerId, txHash: TxHash[]) {
@@ -158,11 +158,4 @@ export class MissingTxMetadataCollection implements ITxMetadataCollection {
         }
       });
   }
-
-  public clearPeerData(peerId: PeerId) {
-    const peerIdStr = peerId.toString();
-    for (const txMeta of this.txMetadata.values()) {
-      txMeta.peers.delete(peerIdStr);
-    }
-  }
 }