@aztec/p2p 0.0.1-commit.29c6b1a3 → 0.0.1-commit.2c85e299c

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

@@ -6,17 +6,19 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 
-import { type GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
+import { GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
 
 export class PeerManagerMetrics {
   private sentGoodbyes: UpDownCounter;
   private receivedGoodbyes: UpDownCounter;
   private peerCount: Gauge;
+  private healthyPeerCount: Gauge;
   private lowScoreDisconnects: UpDownCounter;
   private peerConnectionDuration: Histogram;
 
@@ -31,10 +33,27 @@ export class PeerManagerMetrics {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);
-    this.sentGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_SENT);
-    this.receivedGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_RECEIVED);
+    const goodbyeReasonAttrs = {
+      [Attributes.P2P_GOODBYE_REASON]: [
+        prettyGoodbyeReason(GoodByeReason.SHUTDOWN),
+        prettyGoodbyeReason(GoodByeReason.MAX_PEERS),
+        prettyGoodbyeReason(GoodByeReason.LOW_SCORE),
+        prettyGoodbyeReason(GoodByeReason.BANNED),
+        prettyGoodbyeReason(GoodByeReason.WRONG_NETWORK),
+        prettyGoodbyeReason(GoodByeReason.UNKNOWN),
+      ],
+    };
+    this.sentGoodbyes = createUpDownCounterWithDefault(meter, Metrics.PEER_MANAGER_GOODBYES_SENT, goodbyeReasonAttrs);
+    this.receivedGoodbyes = createUpDownCounterWithDefault(
+      meter,
+      Metrics.PEER_MANAGER_GOODBYES_RECEIVED,
+      goodbyeReasonAttrs,
+    );
     this.peerCount = meter.createGauge(Metrics.PEER_MANAGER_PEER_COUNT);
-    this.lowScoreDisconnects = meter.createUpDownCounter(Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS);
+    this.healthyPeerCount = meter.createGauge(Metrics.PEER_MANAGER_HEALTHY_PEER_COUNT);
+    this.lowScoreDisconnects = createUpDownCounterWithDefault(meter, Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS, {
+      [Attributes.P2P_PEER_SCORE_STATE]: ['Banned', 'Disconnect'],
+    });
     this.peerConnectionDuration = meter.createHistogram(Metrics.PEER_MANAGER_PEER_CONNECTION_DURATION);
   }
 
@@ -50,6 +69,10 @@ export class PeerManagerMetrics {
     this.peerCount.record(count);
   }
 
+  public recordHealthyPeerCount(count: number) {
+    this.healthyPeerCount.record(count);
+  }
+
   public recordLowScoreDisconnect(scoreState: 'Banned' | 'Disconnect') {
     this.lowScoreDisconnects.add(1, { [Attributes.P2P_PEER_SCORE_STATE]: scoreState });
   }
@@ -62,6 +85,7 @@ export class PeerManagerMetrics {
     const connectedAt = this.peerConnectedAt.get(id.toString());
     if (connectedAt) {
       this.peerConnectionDuration.record(Date.now() - connectedAt);
+      this.peerConnectedAt.delete(id.toString());
     }
   }
 }

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

@@ -515,7 +515,8 @@ export class PeerManager implements PeerManagerInterface {
       ...this.peerScoring.getStats(),
     });
 
-    this.metrics.recordPeerCount(healthyConnections.length);
+    this.metrics.recordPeerCount(connections.length);
+    this.metrics.recordHealthyPeerCount(healthyConnections.length);
 
     // Exit if no peers to connect
     if (peersToConnect <= 0) {

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

@@ -6,6 +6,7 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
@@ -13,6 +14,21 @@ import type { PeerId } from '@libp2p/interface';
 
 import type { P2PConfig } from '../../config.js';
 
+/**
+ * Application-level peer penalties.
+ *
+ * These scores are multiplied by appSpecificWeight (10) when contributing to gossipsub score.
+ * The values are designed to align with gossipsub thresholds:
+ *
+ * - LowToleranceError (50): 1 error → app score -50 → gossipsub -500 → gossipThreshold
+ * - MidToleranceError (10): 5 errors → app score -50 → gossipsub -500 → gossipThreshold
+ * - HighToleranceError (2): 25 errors → app score -50 → gossipsub -500 → gossipThreshold
+ *
+ * Examples of each severity:
+ * - LowToleranceError: Invalid messages, deserialization errors, manipulation attempts
+ * - MidToleranceError: Hash mismatches, protocol violations
+ * - HighToleranceError: Rate limit exceeded, failed responses, transient errors
+ */
 const DefaultPeerPenalties = {
   [PeerErrorSeverity.LowToleranceError]: 50,
   [PeerErrorSeverity.MidToleranceError]: 10,
@@ -25,6 +41,16 @@ export enum PeerScoreState {
   Healthy,
 }
 
+/**
+ * Score thresholds for peer states.
+ *
+ * These values align with gossipsub thresholds when multiplied by appSpecificWeight (10):
+ * - MIN_SCORE_BEFORE_DISCONNECT (-50) × 10 = -500 = gossipThreshold
+ * - MIN_SCORE_BEFORE_BAN (-100) × 10 = -1000 = publishThreshold
+ *
+ * This ensures that when a peer is disconnected at the application level,
+ * they also stop receiving gossip, and when banned, they cannot publish.
+ */
 // TODO: move into config / constants
 const MIN_SCORE_BEFORE_BAN = -100;
 const MIN_SCORE_BEFORE_DISCONNECT = -50;
@@ -52,7 +78,9 @@ export class PeerScoring {
 
     const meter = telemetry.getMeter('PeerScoring');
 
-    this.peerStateCounter = meter.createUpDownCounter(Metrics.P2P_PEER_STATE_COUNT);
+    this.peerStateCounter = createUpDownCounterWithDefault(meter, Metrics.P2P_PEER_STATE_COUNT, {
+      [Attributes.P2P_PEER_SCORE_STATE]: ['Healthy', 'Disconnect', 'Banned'],
+    });
   }
 
   public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {

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

@@ -1,14 +1,14 @@
 # BatchTxRequester
 
-The `BatchTxRequester` is a specialized P2P service that aggressively fetches missing transactions from peers when a node receives a block proposal but lacks some of the referenced transactions. This is critical for validators who need all transactions to attest to a proposal.
+The `BatchTxRequester` is a specialized P2P service that aggressively fetches missing transactions from peers when a node lacks some of the referenced transactions. It serves two pathways: (1) block proposals, where validators need all transactions to attest, and (2) block proving, where provers need all transactions to generate proofs.
 
 ## Overview
 
-When a validator receives a block proposal, they must verify all transactions in the block. If some transactions are missing from the local mempool (e.g., due to gossip delays), the `BatchTxRequester` kicks in to fetch them via direct peer-to-peer requests before the attestation deadline.
+When a validator receives a block proposal or a prover needs to prove a block, they must have all transactions. If some transactions are missing from the local mempool (e.g., due to gossip delays), the `BatchTxRequester` kicks in to fetch them via direct peer-to-peer requests before the deadline.
 
 ```
 ┌─────────────────────────────────────────────────────────────────────────────┐
-│                           Block Proposal Received                           │
+│                      Block Proposal or Block Received                       │
 │                     (contains hashes of N transactions)                     │
 └─────────────────────────────────────────────────────────────────────────────┘
                                       │
@@ -71,7 +71,7 @@ The requester classifies peers into three categories to optimize fetching:
 ### Blind Phase → Smart Phase Transition
 
 Peers transition from "dumb" to "smart" when they respond with a valid `BlockTxsResponse` containing:
-1. A matching `blockHash`
+1. A matching `archiveRoot`
 2. A non-empty `txIndices` BitVector indicating which transactions they have
 3. At least one transaction we're still missing
 
@@ -81,10 +81,10 @@ Peers transition from "dumb" to "smart" when they respond with a valid `BlockTxs
 │  ┌────────────────────────────────────────────────────────────────────────┐  │
 │  │  Initial State: All peers are "dumb" (except pinned peer)              │  │
 │  │                                                                        │  │
-│  │  Request: [blockHash, txHashes (full list), txIndices (BitVector)]     │  │
+│  │  Request: [archiveRoot, txHashes (full list), txIndices (BitVector)]   │  │
 │  │           └─ Include full hashes because peer may not have proposal    │  │
 │  │                                                                        │  │
-│  │  Response: [blockHash, txs[], txIndices (what peer has)]               │  │
+│  │  Response: [archiveRoot, txs[], txIndices (what peer has)]             │  │
 │  │            └─ Tells us exactly which txs this peer can provide         │  │
 │  └────────────────────────────────────────────────────────────────────────┘  │
 └──────────────────────────────────────────────────────────────────────────────┘
@@ -97,10 +97,10 @@ Peers transition from "dumb" to "smart" when they respond with a valid `BlockTxs
 │  ┌────────────────────────────────────────────────────────────────────────┐  │
 │  │  Peer promoted to "smart" - we know exactly what they have             │  │
 │  │                                                                        │  │
-│  │  Request: [blockHash, txIndices (BitVector only)]                      │  │
+│  │  Request: [archiveRoot, txIndices (BitVector only)]                    │  │
 │  │           └─ No need for full hashes, peer has the proposal            │  │
 │  │                                                                        │  │
-│  │  Response: [blockHash, txs[], txIndices (updated availability)]        │  │
+│  │  Response: [archiveRoot, txs[], txIndices (updated availability)]      │  │
 │  │            └─ May have received more txs since last response           │  │
 │  └────────────────────────────────────────────────────────────────────────┘  │
 └──────────────────────────────────────────────────────────────────────────────┘
@@ -152,7 +152,7 @@ The `BatchTxRequester` runs three types of workers concurrently:
 
 ```typescript
 class BlockTxsRequest {
-  blockHash: Fr;           // 32-byte hash of the proposed block header
+  archiveRoot: Fr;         // Archive root after the proposed block is applied
   txHashes: TxHashArray;   // Full tx hashes (for dumb peers without proposal)
   txIndices: BitVector;    // Which txs from proposal we're requesting (1 = want)
 }
@@ -162,7 +162,7 @@ class BlockTxsRequest {
 
 ```typescript
 class BlockTxsResponse {
-  blockHash: Fr;           // Echo back the block hash
+  archiveRoot: Fr;         // Echo back the proposal archive root
   txs: TxArray;            // Actual transaction data
   txIndices: BitVector;    // Which txs the peer has available (1 = have)
 }
@@ -230,8 +230,8 @@ Request to peer fails
 ```typescript
 const requester = new BatchTxRequester(
   missingTxHashes,      // TxHash[] - what we need
-  blockProposal,        // BlockProposal - the proposal we're attesting to
-  pinnedPeer,           // PeerId | undefined - who sent us the proposal
+  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
 );
@@ -268,14 +268,14 @@ const txs = await BatchTxRequester.collectAllTxs(requester.run());
 ┌───────────────────────────────────┐   ┌─────────────────────────────────────┐
 │        FastTxCollection           │   │         SlowTxCollection            │
 │                                   │   │                                     │
-│  Time-critical: attestations      │   │  Background: unproven blocks        │
+│  Time-critical: proposals/proving │   │  Background: unproven blocks        │
 │                                   │   │                                     │
 │  1. Try RPC nodes first (fast)    │   │  Periodic polling of RPC nodes      │
 │  2. Fall back to BatchTxRequester │   │  and peers for missing txs          │
 │                                   │   │                                     │
 └───────────────────┬───────────────┘   └─────────────────────────────────────┘
                     │
-                    │ For 'proposal' requests
+                    │ For 'proposal' and 'block' requests
                     ▼
 ┌─────────────────────────────────────────────────────────────────────────────┐
 │                           BatchTxRequester                                  │

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

@@ -4,14 +4,14 @@ 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, executeTimeout } from '@aztec/foundation/timer';
-import { type BlockProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+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 { IMissingTxsTracker } from '../../tx_collection/missing_txs_tracker.js';
 import { ReqRespSubProtocol } from '.././interface.js';
-import { BlockTxsRequest, BlockTxsResponse } from '.././protocols/index.js';
+import { BlockTxsRequest, BlockTxsResponse, type BlockTxsSource } from '.././protocols/index.js';
 import { ReqRespStatus } from '.././status.js';
 import {
   DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD,
@@ -20,7 +20,7 @@ import {
   DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE,
 } from './config.js';
 import type { BatchTxRequesterLibP2PService, BatchTxRequesterOptions, ITxMetadataCollection } from './interface.js';
-import { MissingTxMetadata, MissingTxMetadataCollection } from './missing_txs.js';
+import { MissingTxMetadataCollection } from './missing_txs.js';
 import { type IPeerCollection, PeerCollection } from './peer_collection.js';
 import { BatchRequestTxValidator, type IBatchRequestTxValidator } from './tx_validator.js';
 
@@ -42,7 +42,7 @@ 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 blockProposal: BlockProposal;
+  private readonly blockTxsSource: BlockTxsSource;
   private readonly pinnedPeer: PeerId | undefined;
   private readonly timeoutMs: number;
   private readonly p2pService: BatchTxRequesterLibP2PService;
@@ -60,8 +60,8 @@ export class BatchTxRequester {
   private readonly txBatchSize: number;
 
   constructor(
-    missingTxs: TxHash[],
-    blockProposal: BlockProposal,
+    missingTxsTracker: IMissingTxsTracker,
+    blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
     p2pService: BatchTxRequesterLibP2PService,
@@ -69,7 +69,7 @@ export class BatchTxRequester {
     dateProvider?: DateProvider,
     opts?: BatchTxRequesterOptions,
   ) {
-    this.blockProposal = blockProposal;
+    this.blockTxsSource = blockTxsSource;
     this.pinnedPeer = pinnedPeer;
     this.timeoutMs = timeoutMs;
     this.p2pService = p2pService;
@@ -89,18 +89,16 @@ export class BatchTxRequester {
     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(
-        initialPeers,
+        this.p2pService.connectionSampler,
         this.pinnedPeer,
         this.dateProvider,
         badPeerThreshold,
         this.p2pService.peerScoring,
       );
     }
-    const entries: Array<[string, MissingTxMetadata]> = missingTxs.map(h => [h.toString(), new MissingTxMetadata(h)]);
-    this.txsMetadata = new MissingTxMetadataCollection(entries, this.txBatchSize);
+    this.txsMetadata = new MissingTxMetadataCollection(missingTxsTracker, this.txBatchSize);
     this.smartRequesterSemaphore = this.opts.semaphore ?? new Semaphore(0);
   }
 
@@ -205,7 +203,7 @@ export class BatchTxRequester {
         return;
       }
 
-      const request = BlockTxsRequest.fromBlockProposalAndMissingTxs(this.blockProposal, txs);
+      const request = BlockTxsRequest.fromTxsSourceAndMissingTxs(this.blockTxsSource, txs);
       if (!request) {
         return;
       }
@@ -227,7 +225,6 @@ 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
@@ -249,8 +246,8 @@ export class BatchTxRequester {
       // If peer is dumb peer, we don't know yet if they received full blockProposal
       // there is solid chance that peer didn't receive proposal yet, thus we must send full hashes
       const includeFullHashesInRequestNotJustIndices = true;
-      const blockRequest = BlockTxsRequest.fromBlockProposalAndMissingTxs(
-        this.blockProposal,
+      const blockRequest = BlockTxsRequest.fromTxsSourceAndMissingTxs(
+        this.blockTxsSource,
         txs,
         includeFullHashesInRequestNotJustIndices,
       );
@@ -263,15 +260,9 @@ export class BatchTxRequester {
       return { blockRequest, txs };
     };
 
-    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 workerCount = this.dumbParallelWorkerCount;
     const workers = Array.from({ length: workerCount }, (_, index) =>
-      this.dumbWorkerLoop(nextPeer, makeRequest, index + 1),
+      this.dumbWorkerLoop(this.peers.nextDumbPeerToQuery.bind(this.peers), makeRequest, index + 1),
     );
 
     await Promise.allSettled(workers);
@@ -332,17 +323,9 @@ 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.fromBlockProposalAndMissingTxs(this.blockProposal, txs);
+      const blockRequest = BlockTxsRequest.fromTxsSourceAndMissingTxs(this.blockTxsSource, txs);
       if (!blockRequest) {
         return undefined;
       }
@@ -350,9 +333,8 @@ export class BatchTxRequester {
       return { blockRequest, txs };
     };
 
-    const workers = Array.from(
-      { length: Math.min(this.smartParallelWorkerCount, this.peers.getAllPeers().size) },
-      (_, index) => this.smartWorkerLoop(nextPeer, makeRequest, index + 1),
+    const workers = Array.from({ length: this.smartParallelWorkerCount }, (_, index) =>
+      this.smartWorkerLoop(this.peers.nextSmartPeerToQuery.bind(this.peers), makeRequest, index + 1),
     );
 
     await Promise.allSettled(workers);
@@ -387,26 +369,18 @@ export class BatchTxRequester {
         if (weRanOutOfPeersToQuery) {
           this.logger.debug(`Worker loop smart: No more peers to query`);
 
-          // 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;
+          // 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;
           }
 
-          // 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 dumb peers still exist that could become smart.
+          // but there are dumb peers that could be promoted
+          // or new peer can join as dumb and be promoted later
           //
           // When a dumb peer responds with valid txIndices, it gets
           // promoted to smart and releases the semaphore, waking this worker.
@@ -599,15 +573,13 @@ export class BatchTxRequester {
     this.markTxsPeerHas(peerId, response);
 
     // Unblock smart workers
-    if (this.peers.getSmartPeersToQuery().length <= this.smartParallelWorkerCount) {
-      this.smartRequesterSemaphore.release();
-    }
+    this.smartRequesterSemaphore.release();
   }
 
   private isBlockResponseValid(response: BlockTxsResponse): boolean {
-    const blockIdsMatch = this.blockProposal.archive.toString() === response.blockHash.toString();
+    const archiveRootsMatch = this.blockTxsSource.archive.toString() === response.archiveRoot.toString();
     const peerHasSomeTxsFromProposal = !response.txIndices.isEmpty();
-    return blockIdsMatch && peerHasSomeTxsFromProposal;
+    return archiveRootsMatch && peerHasSomeTxsFromProposal;
   }
 
   private peerHasSomeTxsWeAreMissing(_peerId: PeerId, response: BlockTxsResponse): boolean {
@@ -624,7 +596,7 @@ export class BatchTxRequester {
   private extractHashesPeerHasFromResponse(response: BlockTxsResponse): Array<TxHash> {
     const hashes: TxHash[] = [];
     const indicesOfHashesPeerHas = new Set(response.txIndices.getTrueIndices());
-    this.blockProposal.txHashes.forEach((hash, idx) => {
+    this.blockTxsSource.txHashes.forEach((hash, idx) => {
       if (indicesOfHashesPeerHas.has(idx)) {
         hashes.push(hash);
       }
@@ -661,7 +633,7 @@ export class BatchTxRequester {
   /*
    * @returns true if all missing txs have been fetched */
   private fetchedAllTxs() {
-    return Array.from(this.txsMetadata.values()).every(tx => tx.fetched);
+    return this.txsMetadata.getMissingTxHashes().size == 0;
   }
 
   /*
@@ -679,7 +651,7 @@ export class BatchTxRequester {
       this.unlockSmartRequesterSemaphores();
     }
 
-    return aborted || this.txsMetadata.size === 0 || this.fetchedAllTxs() || this.dateProvider.now() > this.deadline;
+    return aborted || this.fetchedAllTxs() || this.dateProvider.now() > this.deadline;
   }
 
   /*

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

@@ -6,7 +6,6 @@ import type { PeerId } from '@libp2p/interface';
 
 import type { ConnectionSampler } from '../connection-sampler/connection_sampler.js';
 import type { ReqRespInterface } from '../interface.js';
-import type { MissingTxMetadata } from './missing_txs.js';
 import type { IPeerCollection } from './peer_collection.js';
 import type { BatchRequestTxValidatorConfig, IBatchRequestTxValidator } from './tx_validator.js';
 
@@ -15,18 +14,15 @@ export interface IPeerPenalizer {
 }
 
 export interface ITxMetadataCollection {
-  size: number;
-  values(): IterableIterator<MissingTxMetadata>;
   getMissingTxHashes(): Set<string>;
+  markFetched(peerId: PeerId, tx: Tx): boolean;
   getTxsToRequestFromThePeer(peer: PeerId): TxHash[];
   markRequested(txHash: TxHash): void;
   markInFlightBySmartPeer(txHash: TxHash): void;
   markNotInFlightBySmartPeer(txHash: TxHash): void;
   alreadyFetched(txHash: TxHash): boolean;
   // Returns true if tx was marked as fetched, false if it was already marked as fetched
-  markFetched(peerId: PeerId, tx: Tx): boolean;
   markPeerHas(peerId: PeerId, txHashes: TxHash[]): void;
-  getFetchedTxs(): Tx[];
 }
 
 /**