@aztec/p2p 0.0.1-commit.88e6f9396 → 0.0.1-commit.8c0b8ff

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/rate-limiter/rate_limiter.ts

@@ -97,9 +97,10 @@ export function prettyPrintRateLimitStatus(status: RateLimitStatus) {
  * 2. Individual rate limits for each peer.
  *
  * How it works:
- * - When a request comes in, it first checks against the global rate limit.
- * - If the global limit allows, it then checks against the specific peer's rate limit.
- * - The request is only allowed if both the global and peer-specific limits allow it.
+ * - When a request comes in, it first checks against the peer's individual rate limit.
+ * - If the peer limit allows, it then checks against the global rate limit.
+ * - The request is only allowed if both the peer-specific and global limits allow it.
+ * - Checking peer limit first ensures a rate-limited peer cannot exhaust the global quota.
  * - It automatically creates and manages rate limiters for new peers as they make requests.
  * - It periodically cleans up rate limiters for inactive peers to conserve memory.
  *
@@ -119,10 +120,6 @@ export class SubProtocolRateLimiter {
   }
 
   allow(peerId: PeerId): RateLimitStatus {
-    if (!this.globalLimiter.allow()) {
-      return RateLimitStatus.DeniedGlobal;
-    }
-
     const peerIdStr = peerId.toString();
     let peerLimiter: PeerRateLimiter | undefined = this.peerLimiters.get(peerIdStr);
     if (!peerLimiter) {
@@ -135,10 +132,17 @@ export class SubProtocolRateLimiter {
     } else {
       peerLimiter.lastAccess = Date.now();
     }
-    const peerLimitAllowed = peerLimiter.limiter.allow();
-    if (!peerLimitAllowed) {
+
+    // Check peer limit first: a rate-limited peer must not consume global quota,
+    // otherwise one spamming peer can starve all others by exhausting the global bucket.
+    if (!peerLimiter.limiter.allow()) {
       return RateLimitStatus.DeniedPeer;
     }
+
+    if (!this.globalLimiter.allow()) {
+      return RateLimitStatus.DeniedGlobal;
+    }
+
     return RateLimitStatus.Allowed;
   }
 

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/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/file_store_tx_source.ts

@@ -1,7 +1,8 @@
+import { partitionAsync } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { type ReadOnlyFileStore, createReadOnlyFileStore } from '@aztec/stdlib/file-store';
-import { Tx, type TxHash } from '@aztec/stdlib/tx';
+import { Tx, type TxHash, type TxValidator } from '@aztec/stdlib/tx';
 import {
   type Histogram,
   Metrics,
@@ -23,6 +24,7 @@ export class FileStoreTxSource implements TxSource {
     private readonly fileStore: ReadOnlyFileStore,
     private readonly baseUrl: string,
     private readonly basePath: string,
+    private readonly txValidator: TxValidator,
     private readonly log: Logger,
     telemetry: TelemetryClient,
   ) {
@@ -44,6 +46,7 @@ export class FileStoreTxSource implements TxSource {
   public static async create(
     url: string,
     basePath: string,
+    txValidator: TxValidator,
     log: Logger = createLogger('p2p:file_store_tx_source'),
     telemetry: TelemetryClient = getTelemetryClient(),
   ): Promise<FileStoreTxSource | undefined> {
@@ -53,7 +56,7 @@ export class FileStoreTxSource implements TxSource {
         log.warn(`Failed to create file store for URL: ${url}`);
         return undefined;
       }
-      return new FileStoreTxSource(fileStore, url, basePath, log, telemetry);
+      return new FileStoreTxSource(fileStore, url, basePath, txValidator, log, telemetry);
     } catch (err) {
       log.warn(`Error creating file store for URL: ${url}`, { error: err });
       return undefined;
@@ -65,35 +68,41 @@ export class FileStoreTxSource implements TxSource {
   }
 
   public async getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult> {
-    const invalidTxHashes: string[] = [];
+    const results = await Promise.all(
+      txHashes.map(async txHash => {
+        const path = `${this.basePath}/txs/${txHash.toString()}.bin`;
+        const timer = new Timer();
+        try {
+          const buffer = await this.fileStore.read(path);
+          const tx = Tx.fromBuffer(buffer);
+          return { tx, downloadDuration: timer.ms(), downloadSize: buffer.length };
+        } catch {
+          this.downloadsFailed.add(1);
+          return undefined;
+        }
+      }),
+    );
+
+    const txs = results.filter(tx => tx !== undefined);
+    const [validTxs, invalidTxs] = await partitionAsync(
+      txs,
+      async ({ tx, downloadDuration, downloadSize }): Promise<boolean> => {
+        const valid = await this.txValidator.validateTx(tx);
+        if (valid.result === 'valid') {
+          this.downloadsSuccess.add(1);
+          this.downloadDuration.record(Math.ceil(downloadDuration));
+          this.downloadSize.record(downloadSize);
+          return true;
+        } else {
+          this.downloadsFailed.add(1);
+          return false;
+        }
+      },
+    );
+
     return {
-      validTxs: (
-        await Promise.all(
-          txHashes.map(async txHash => {
-            const path = `${this.basePath}/txs/${txHash.toString()}.bin`;
-            const timer = new Timer();
-            try {
-              const buffer = await this.fileStore.read(path);
-              const tx = Tx.fromBuffer(buffer);
-              if ((await tx.validateTxHash()) && txHash.equals(tx.txHash)) {
-                this.downloadsSuccess.add(1);
-                this.downloadDuration.record(Math.ceil(timer.ms()));
-                this.downloadSize.record(buffer.length);
-                return tx;
-              } else {
-                invalidTxHashes.push(tx.txHash.toString());
-                this.downloadsFailed.add(1);
-                return undefined;
-              }
-            } catch {
-              // Tx not found or error reading - return undefined
-              this.downloadsFailed.add(1);
-              return undefined;
-            }
-          }),
-        )
-      ).filter(tx => tx !== undefined),
-      invalidTxHashes: invalidTxHashes,
+      validTxs: validTxs.map(({ tx }) => tx),
+      invalidTxHashes: invalidTxs.map(({ tx }) => tx.getTxHash().toString()),
     };
   }
 }
@@ -109,9 +118,12 @@ export class FileStoreTxSource implements TxSource {
 export async function createFileStoreTxSources(
   urls: string[],
   basePath: string,
+  txValidator: TxValidator,
   log: Logger = createLogger('p2p:file_store_tx_source'),
   telemetry: TelemetryClient = getTelemetryClient(),
 ): Promise<FileStoreTxSource[]> {
-  const sources = await Promise.all(urls.map(url => FileStoreTxSource.create(url, basePath, log, telemetry)));
+  const sources = await Promise.all(
+    urls.map(url => FileStoreTxSource.create(url, basePath, txValidator, log, telemetry)),
+  );
   return sources.filter((s): s is FileStoreTxSource => s !== undefined);
 }