@aztec/p2p 0.0.1-commit.d6f2b3f94 → 0.0.1-commit.d939eb5aa

package/src/services/tx_collection/file_store_tx_source.ts

@@ -1,26 +1,54 @@
+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,
+  type TelemetryClient,
+  type UpDownCounter,
+  getTelemetryClient,
+} from '@aztec/telemetry-client';
 
-import type { TxSource } from './tx_source.js';
+import type { TxSource, TxSourceCollectionResult } from './tx_source.js';
 
 /** TxSource implementation that downloads txs from a file store. */
 export class FileStoreTxSource implements TxSource {
+  private downloadsSuccess: UpDownCounter;
+  private downloadsFailed: UpDownCounter;
+  private downloadDuration: Histogram;
+  private downloadSize: Histogram;
+
   private constructor(
     private readonly fileStore: ReadOnlyFileStore,
     private readonly baseUrl: string,
+    private readonly basePath: string,
+    private readonly txValidator: TxValidator,
     private readonly log: Logger,
-  ) {}
+    telemetry: TelemetryClient,
+  ) {
+    const meter = telemetry.getMeter('file-store-tx-source');
+    this.downloadsSuccess = meter.createUpDownCounter(Metrics.TX_FILE_STORE_DOWNLOADS_SUCCESS);
+    this.downloadsFailed = meter.createUpDownCounter(Metrics.TX_FILE_STORE_DOWNLOADS_FAILED);
+    this.downloadDuration = meter.createHistogram(Metrics.TX_FILE_STORE_DOWNLOAD_DURATION);
+    this.downloadSize = meter.createHistogram(Metrics.TX_FILE_STORE_DOWNLOAD_SIZE);
+  }
 
   /**
    * Creates a FileStoreTxSource from a URL.
    * @param url - The file store URL (s3://, gs://, file://, http://, https://).
+   * @param basePath - Base path for tx files within the store.
    * @param log - Optional logger.
+   * @param telemetry - Optional telemetry client.
    * @returns The FileStoreTxSource instance, or undefined if creation fails.
    */
   public static async create(
     url: string,
+    basePath: string,
+    txValidator: TxValidator,
     log: Logger = createLogger('p2p:file_store_tx_source'),
+    telemetry: TelemetryClient = getTelemetryClient(),
   ): Promise<FileStoreTxSource | undefined> {
     try {
       const fileStore = await createReadOnlyFileStore(url, log);
@@ -28,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, log);
+      return new FileStoreTxSource(fileStore, url, basePath, txValidator, log, telemetry);
     } catch (err) {
       log.warn(`Error creating file store for URL: ${url}`, { error: err });
       return undefined;
@@ -39,32 +67,63 @@ export class FileStoreTxSource implements TxSource {
     return `file-store:${this.baseUrl}`;
   }
 
-  public getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
-    return Promise.all(
+  public async getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult> {
+    const results = await Promise.all(
       txHashes.map(async txHash => {
-        const path = `txs/${txHash.toString()}.bin`;
+        const path = `${this.basePath}/txs/${txHash.toString()}.bin`;
+        const timer = new Timer();
         try {
           const buffer = await this.fileStore.read(path);
-          return Tx.fromBuffer(buffer);
+          const tx = Tx.fromBuffer(buffer);
+          return { tx, downloadDuration: timer.ms(), downloadSize: buffer.length };
         } catch {
-          // Tx not found or error reading - return undefined
+          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: validTxs.map(({ tx }) => tx),
+      invalidTxHashes: invalidTxs.map(({ tx }) => tx.getTxHash().toString()),
+    };
   }
 }
 
 /**
  * Creates FileStoreTxSource instances from URLs.
  * @param urls - Array of file store URLs.
+ * @param basePath - Base path for tx files within each store.
  * @param log - Optional logger.
+ * @param telemetry - Optional telemetry client.
  * @returns Array of successfully created FileStoreTxSource instances.
  */
 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, log)));
+  const sources = await Promise.all(
+    urls.map(url => FileStoreTxSource.create(url, basePath, txValidator, log, telemetry)),
+  );
   return sources.filter((s): s is FileStoreTxSource => s !== undefined);
 }

package/src/services/tx_collection/instrumentation.ts

@@ -18,7 +18,13 @@ export class TxCollectionInstrumentation {
     const meter = client.getMeter(name);
 
     this.txsCollected = createUpDownCounterWithDefault(meter, Metrics.TX_COLLECTOR_COUNT, {
-      [Attributes.TX_COLLECTION_METHOD]: ['fast-req-resp', 'fast-node-rpc', 'slow-req-resp', 'slow-node-rpc'],
+      [Attributes.TX_COLLECTION_METHOD]: [
+        'fast-req-resp',
+        'fast-node-rpc',
+        'slow-req-resp',
+        'slow-node-rpc',
+        'file-store',
+      ],
     });
 
     this.collectionDurationPerTx = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_TX);

package/src/services/tx_collection/proposal_tx_collector.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
@@ -9,6 +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';
 
 /**
  * Strategy interface for collecting missing transactions for a block or proposal.
@@ -17,17 +18,15 @@ import { type BlockTxsSource, ReqRespSubProtocol, chunkTxHashesRequest } from '.
 export interface MissingTxsCollector {
   /**
    * Collect missing transactions for a block or proposal.
-   * @param txHashes - The transaction hashes to collect
+   * @param requestTracker - 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(
-    txHashes: TxHash[],
+    requestTracker: IRequestTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
-    timeoutMs: number,
   ): Promise<Tx[]>;
 }
 
@@ -45,10 +44,9 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
   ) {}
 
   async collectTxs(
-    txHashes: TxHash[],
+    requestTracker: IRequestTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
-    timeoutMs: number,
   ): Promise<Tx[]> {
     const {
       batchTxRequesterSmartParallelWorkerCount: smartParallelWorkerCount,
@@ -58,10 +56,9 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
     } = this.batchTxRequesterConfig ?? {};
 
     const batchRequester = new BatchTxRequester(
-      txHashes,
+      requestTracker,
       blockTxsSource,
       pinnedPeer,
-      timeoutMs,
       this.p2pService,
       this.log,
       this.dateProvider,
@@ -93,16 +90,15 @@ export class SendBatchRequestCollector implements MissingTxsCollector {
   ) {}
 
   async collectTxs(
-    txHashes: TxHash[],
+    requestTracker: IRequestTracker,
     _blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
-    timeoutMs: number,
   ): Promise<Tx[]> {
     const txs = await this.p2pService.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
       ReqRespSubProtocol.TX,
-      chunkTxHashesRequest(txHashes),
+      chunkTxHashesRequest(Array.from(requestTracker.missingTxHashes).map(TxHash.fromString)),
       pinnedPeer,
-      timeoutMs,
+      requestTracker.timeoutMs,
       this.maxPeers,
       this.maxRetryAttempts,
     );

package/src/services/tx_collection/request_tracker.ts

@@ -0,0 +1,127 @@
+import { type PromiseWithResolvers, promiseWithResolvers } from '@aztec/foundation/promise';
+import type { DateProvider } from '@aztec/foundation/timer';
+import { TxHash } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
+
+/**
+ * Tracks which transactions are still missing and need to be fetched.
+ * Manages the request deadline and serves as the sole source of cancellation signal.
+ * The request is cancelled when all txs are fetched or the deadline expires.
+ */
+export interface IRequestTracker {
+  /** 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 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[];
+  /** The deadline for this request. */
+  get deadline(): Date;
+  /** Remaining time in milliseconds until deadline. Returns 0 if already past. */
+  get timeoutMs(): number;
+  /** Checks whether the request is cancelled (deadline expired or all fetched). May trigger cancellation if deadline has passed. */
+  checkCancelled(): boolean;
+  /** Resolves when deadline expires or all txs are fetched. */
+  get cancellationToken(): Promise<void>;
+  /** Externally cancel the request. */
+  cancel(): void;
+}
+
+export class RequestTracker implements IRequestTracker {
+  public readonly collectedTxs: Tx[] = [];
+  private done = false;
+  private readonly cancellationTokenPromise: PromiseWithResolvers<void>;
+  private readonly deadlineTimer: ReturnType<typeof setTimeout> | undefined;
+
+  private constructor(
+    public readonly missingTxHashes: Set<string>,
+    public readonly deadline: Date,
+    private readonly dateProvider?: DateProvider,
+  ) {
+    this.cancellationTokenPromise = promiseWithResolvers<void>();
+
+    if (missingTxHashes.size === 0) {
+      this.finish();
+      return;
+    }
+
+    const now = this.dateProvider?.now() ?? Date.now();
+    const remaining = deadline.getTime() - now;
+    if (remaining <= 0) {
+      this.finish();
+    } else {
+      this.deadlineTimer = setTimeout(() => this.finish(), remaining);
+    }
+  }
+
+  public static create(hashes: TxHash[] | string[], deadline: Date, dateProvider?: DateProvider) {
+    return new RequestTracker(new Set(hashes.map(hash => hash.toString())), deadline, dateProvider);
+  }
+
+  markFetched(tx: Tx): boolean {
+    if (this.missingTxHashes.delete(tx.txHash.toString())) {
+      this.collectedTxs.push(tx);
+      if (this.allFetched()) {
+        this.finish();
+      }
+      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());
+  }
+
+  get timeoutMs(): number {
+    const now = this.dateProvider?.now() ?? Date.now();
+    return Math.max(0, this.deadline.getTime() - now);
+  }
+
+  checkCancelled(): boolean {
+    if (this.done) {
+      return true;
+    }
+    // Synchronous fallback: check deadline even if setTimeout hasn't fired yet.
+    // This prevents macrotask starvation in tight async loops from blocking cancellation.
+    const now = this.dateProvider?.now() ?? Date.now();
+    if (now >= this.deadline.getTime()) {
+      this.finish();
+      return true;
+    }
+    return false;
+  }
+
+  get cancellationToken(): Promise<void> {
+    return this.cancellationTokenPromise.promise;
+  }
+
+  cancel(): void {
+    this.finish();
+  }
+
+  private finish() {
+    if (this.done) {
+      return;
+    }
+    this.done = true;
+    if (this.deadlineTimer) {
+      clearTimeout(this.deadlineTimer);
+    }
+    this.cancellationTokenPromise.resolve();
+  }
+}

package/src/services/tx_collection/slow_tx_collection.ts

@@ -8,8 +8,7 @@ import type { L2Block } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getEpochAtSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
-import { type ReqRespInterface, ReqRespSubProtocol } from '../reqresp/interface.js';
-import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
+import { type ReqRespInterface, ReqRespSubProtocol, chunkTxHashesRequest } from '../reqresp/index.js';
 import type { TxCollectionConfig } from './config.js';
 import type { FastTxCollection } from './fast_tx_collection.js';
 import type { MissingTxInfo } from './tx_collection.js';
@@ -120,8 +119,8 @@ export class SlowTxCollection {
       const txHashes = entries.map(([txHash]) => TxHash.fromString(txHash));
       for (const batch of chunk(txHashes, this.config.txCollectionNodeRpcMaxBatchSize)) {
         await this.txCollectionSink.collect(
-          hashes => node.getTxsByHash(hashes),
-          batch,
+          () => node.getTxsByHash(batch),
+          batch.map(h => h.toString()),
           {
             description: `node ${node.getInfo()}`,
             node: node.getInfo(),
@@ -166,18 +165,18 @@ export class SlowTxCollection {
       const txHashes = entries.map(([txHash]) => TxHash.fromString(txHash));
       const maxPeers = boundInclusive(Math.ceil(txHashes.length / 3), 4, 16);
       await this.txCollectionSink.collect(
-        async hashes => {
+        async () => {
           const txs = await this.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
             ReqRespSubProtocol.TX,
-            chunkTxHashesRequest(hashes),
+            chunkTxHashesRequest(txHashes),
             pinnedPeer,
             timeoutMs,
             maxPeers,
             maxRetryAttempts,
           );
-          return txs.flat();
+          return { validTxs: txs.flat(), invalidTxHashes: [] };
         },
-        txHashes,
+        txHashes.map(h => h.toString()),
         { description: 'slow reqresp', timeoutMs, method: 'slow-req-resp' },
         { type: 'mined', block },
       );
@@ -197,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(
-      ...Array.from(fastRequests.values()).flatMap(r => r.missingTxHashes),
+      fastRequests.values().flatMap(r => Array.from(r.requestTracker.missingTxHashes)),
     );
 
     // Return all missing txs that are not in fastCollectionTxs and are ready for reqresp if requested
@@ -254,9 +253,14 @@ export class SlowTxCollection {
 
   /** Computes the proof submission deadline for a given slot, a tx mined in this slot is no longer interesting after this deadline */
   private getDeadlineForSlot(slotNumber: SlotNumber): Date {
-    const epoch = getEpochAtSlot(slotNumber, this.constants);
-    const submissionEndEpoch = EpochNumber(epoch + this.constants.proofSubmissionEpochs);
-    const submissionEndTimestamp = getTimestampRangeForEpoch(submissionEndEpoch, this.constants)[1];
-    return new Date(Number(submissionEndTimestamp) * 1000);
+    return getProofDeadlineForSlot(slotNumber, this.constants);
   }
 }
+
+/** Computes the proof submission deadline for a given slot. A tx mined in this slot is no longer interesting after this deadline. */
+export function getProofDeadlineForSlot(slotNumber: SlotNumber, constants: L1RollupConstants): Date {
+  const epoch = getEpochAtSlot(slotNumber, constants);
+  const submissionEndEpoch = EpochNumber(epoch + constants.proofSubmissionEpochs);
+  const submissionEndTimestamp = getTimestampRangeForEpoch(submissionEndEpoch, constants)[1];
+  return new Date(Number(submissionEndTimestamp) * 1000);
+}

package/src/services/tx_collection/tx_collection.ts

@@ -1,13 +1,14 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type PromiseWithResolvers, RunningPromise } from '@aztec/foundation/promise';
+import { RunningPromise } from '@aztec/foundation/promise';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
+import { TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
@@ -18,7 +19,8 @@ import type { TxCollectionConfig } from './config.js';
 import { FastTxCollection } from './fast_tx_collection.js';
 import { FileStoreTxCollection } from './file_store_tx_collection.js';
 import type { FileStoreTxSource } from './file_store_tx_source.js';
-import { SlowTxCollection } from './slow_tx_collection.js';
+import type { IRequestTracker } from './request_tracker.js';
+import { SlowTxCollection, getProofDeadlineForSlot } from './slow_tx_collection.js';
 import { type TxAddContext, TxCollectionSink } from './tx_collection_sink.js';
 import type { TxSource } from './tx_source.js';
 
@@ -31,11 +33,8 @@ export type FastCollectionRequestInput =
   | { type: 'proposal'; blockProposal: BlockProposal; blockNumber: BlockNumber };
 
 export type FastCollectionRequest = FastCollectionRequestInput & {
-  missingTxHashes: Set<string>;
-  deadline: Date;
+  requestTracker: IRequestTracker;
   blockInfo: L2BlockInfo;
-  promise: PromiseWithResolvers<void>;
-  foundTxs: Map<string, Tx>;
 };
 
 /**
@@ -56,8 +55,11 @@ export class TxCollection {
   /** Fast collection methods */
   protected readonly fastCollection: FastTxCollection;
 
-  /** File store collection */
-  protected readonly fileStoreCollection: FileStoreTxCollection;
+  /** File store collection for slow (mined block) path */
+  protected readonly fileStoreSlowCollection: FileStoreTxCollection;
+
+  /** File store collection for fast (proposal/proving) path */
+  protected readonly fileStoreFastCollection: FileStoreTxCollection;
 
   /** Loop for periodically reconciling found transactions from the tx pool in case we missed some */
   private readonly reconcileFoundTxsLoop: RunningPromise;
@@ -111,7 +113,28 @@ export class TxCollection {
     );
 
     this.hasFileStoreSources = fileStoreSources.length > 0;
-    this.fileStoreCollection = new FileStoreTxCollection(fileStoreSources, this.txCollectionSink, this.log);
+    this.fileStoreSlowCollection = new FileStoreTxCollection(
+      fileStoreSources,
+      this.txCollectionSink,
+      {
+        workerCount: config.txCollectionFileStoreSlowWorkerCount,
+        backoffBaseMs: config.txCollectionFileStoreSlowBackoffBaseMs,
+        backoffMaxMs: config.txCollectionFileStoreSlowBackoffMaxMs,
+      },
+      this.dateProvider,
+      this.log,
+    );
+    this.fileStoreFastCollection = new FileStoreTxCollection(
+      fileStoreSources,
+      this.txCollectionSink,
+      {
+        workerCount: config.txCollectionFileStoreFastWorkerCount,
+        backoffBaseMs: config.txCollectionFileStoreFastBackoffBaseMs,
+        backoffMaxMs: config.txCollectionFileStoreFastBackoffMaxMs,
+      },
+      this.dateProvider,
+      this.log,
+    );
 
     this.reconcileFoundTxsLoop = new RunningPromise(
       () => this.reconcileFoundTxsWithPool(),
@@ -137,7 +160,8 @@ export class TxCollection {
   public start(): Promise<void> {
     this.started = true;
     this.slowCollection.start();
-    this.fileStoreCollection.start();
+    this.fileStoreSlowCollection.start();
+    this.fileStoreFastCollection.start();
     this.reconcileFoundTxsLoop.start();
 
     // TODO(palla/txs): Collect mined unproven tx hashes for txs we dont have in the pool and populate missingTxs on startup
@@ -150,7 +174,8 @@ export class TxCollection {
     await Promise.all([
       this.slowCollection.stop(),
       this.fastCollection.stop(),
-      this.fileStoreCollection.stop(),
+      this.fileStoreSlowCollection.stop(),
+      this.fileStoreFastCollection.stop(),
       this.reconcileFoundTxsLoop.stop(),
     ]);
 
@@ -175,6 +200,7 @@ export class TxCollection {
     // Delay file store collection to give P2P methods time to find txs first
     if (this.hasFileStoreSources) {
       const context: TxAddContext = { type: 'mined', block };
+      const deadline = getProofDeadlineForSlot(block.header.getSlot(), this.constants);
       sleep(this.config.txCollectionFileStoreSlowDelayMs)
         .then(() => {
           if (this.started) {
@@ -182,7 +208,7 @@ export class TxCollection {
             const stillMissing = new Set(this.slowCollection.getMissingTxHashes().map(h => h.toString()));
             const remaining = txHashes.filter(h => stillMissing.has(h.toString()));
             if (remaining.length > 0) {
-              this.fileStoreCollection.startCollecting(remaining, context);
+              this.fileStoreSlowCollection.startCollecting(remaining, context, deadline);
             }
           }
         })
@@ -223,7 +249,7 @@ export class TxCollection {
       sleep(this.config.txCollectionFileStoreFastDelayMs)
         .then(() => {
           if (this.started) {
-            this.fileStoreCollection.startCollecting(hashes, context);
+            this.fileStoreFastCollection.startCollecting(hashes, context, opts.deadline);
           }
         })
         .catch(err => this.log.error('Error in file store fast delay', err));
@@ -245,7 +271,8 @@ export class TxCollection {
   private foundTxs(txs: Tx[]) {
     this.slowCollection.foundTxs(txs);
     this.fastCollection.foundTxs(txs);
-    this.fileStoreCollection.foundTxs(txs);
+    this.fileStoreSlowCollection.foundTxs(txs);
+    this.fileStoreFastCollection.foundTxs(txs);
   }
 
   /**
@@ -255,7 +282,8 @@ export class TxCollection {
   public stopCollectingForBlocksUpTo(blockNumber: BlockNumber): void {
     this.slowCollection.stopCollectingForBlocksUpTo(blockNumber);
     this.fastCollection.stopCollectingForBlocksUpTo(blockNumber);
-    this.fileStoreCollection.clearPending();
+    this.fileStoreSlowCollection.clearPending();
+    this.fileStoreFastCollection.clearPending();
   }
 
   /**
@@ -265,7 +293,8 @@ export class TxCollection {
   public stopCollectingForBlocksAfter(blockNumber: BlockNumber): void {
     this.slowCollection.stopCollectingForBlocksAfter(blockNumber);
     this.fastCollection.stopCollectingForBlocksAfter(blockNumber);
-    this.fileStoreCollection.clearPending();
+    this.fileStoreSlowCollection.clearPending();
+    this.fileStoreFastCollection.clearPending();
   }
 
   /** Every now and then, check if the pool has received one of the txs we are looking for, just to catch any race conditions */