@aztec/p2p 0.0.1-commit.858058eac → 0.0.1-commit.85d7d01

package/src/services/tx_collection/file_store_tx_collection.ts

@@ -1,152 +1,202 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { FifoMemoryQueue } from '@aztec/foundation/queue';
+import { type PromiseWithResolvers, promiseWithResolvers } from '@aztec/foundation/promise';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider } from '@aztec/foundation/timer';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { FileStoreTxSource } from './file_store_tx_source.js';
 import type { TxAddContext, TxCollectionSink } from './tx_collection_sink.js';
 
-// Internal constants (not configurable by node operators)
-const FILE_STORE_DOWNLOAD_CONCURRENCY = 5; // Max concurrent downloads
+/** Configuration for a FileStoreTxCollection instance. */
+export type FileStoreCollectionConfig = {
+  workerCount: number;
+  backoffBaseMs: number;
+  backoffMaxMs: number;
+};
+
+type FileStoreTxEntry = {
+  txHash: string;
+  context: TxAddContext;
+  deadline: Date;
+  attempts: number;
+  lastAttemptTime: number;
+  nextSourceIndex: number;
+};
 
 /**
  * Collects txs from file stores as a fallback after P2P methods have been tried.
- * Runs in parallel to slow/fast collection. The delay before starting file store
- * collection is managed by the TxCollection orchestrator, not this class.
+ * Uses a shared worker pool that pulls entries with priority (fewest attempts first),
+ * retries with round-robin across sources, and applies exponential backoff between
+ * full cycles through all sources.
  */
 export class FileStoreTxCollection {
-  /** Map from tx hash to add context for txs queued for download. */
-  private pendingTxs = new Map<string, TxAddContext>();
+  /** Map from tx hash string to entry for all pending downloads. */
+  private entries = new Map<string, FileStoreTxEntry>();
 
-  /**
-   * Tracks tx hashes found elsewhere, even before startCollecting is called.
-   * Needed because the orchestrator delays startCollecting via a real sleep, but foundTxs
-   * may arrive during that delay — before the hashes are added to pendingTxs.
-   */
-  private foundTxHashes = new Set<string>();
-
-  /** Queue of tx hashes to be downloaded. */
-  private downloadQueue = new FifoMemoryQueue<TxHash>();
-
-  /** Worker promises for concurrent downloads. */
+  /** Worker promises for the shared worker pool. */
   private workers: Promise<void>[] = [];
 
-  /** Whether the collection has been started. */
-  private started = false;
+  /** Whether the worker pool is running. */
+  private running = false;
+
+  /** Signal used to wake sleeping workers when new entries arrive or stop is called. */
+  private wakeSignal: PromiseWithResolvers<void>;
 
   constructor(
-    private readonly fileStoreSources: FileStoreTxSource[],
+    private readonly sources: FileStoreTxSource[],
     private readonly txCollectionSink: TxCollectionSink,
+    private readonly config: FileStoreCollectionConfig,
+    private readonly dateProvider: DateProvider = new DateProvider(),
     private readonly log: Logger = createLogger('p2p:file_store_tx_collection'),
-  ) {}
+  ) {
+    this.wakeSignal = promiseWithResolvers<void>();
+  }
 
-  /** Starts the file store collection workers. */
-  public start() {
-    if (this.fileStoreSources.length === 0) {
-      this.log.debug('No file store sources configured, skipping file store collection');
+  /** Starts the shared worker pool. */
+  public start(): void {
+    if (this.sources.length === 0) {
+      this.log.debug('No file store sources configured');
       return;
     }
-
-    this.started = true;
-    this.downloadQueue = new FifoMemoryQueue<TxHash>();
-
-    // Start concurrent download workers
-    for (let i = 0; i < FILE_STORE_DOWNLOAD_CONCURRENCY; i++) {
-      this.workers.push(this.downloadQueue.process(txHash => this.processDownload(txHash)));
+    this.running = true;
+    for (let i = 0; i < this.config.workerCount; i++) {
+      this.workers.push(this.workerLoop());
     }
-
-    this.log.info(`Started file store tx collection with ${this.fileStoreSources.length} sources`, {
-      sources: this.fileStoreSources.map(s => s.getInfo()),
-      concurrency: FILE_STORE_DOWNLOAD_CONCURRENCY,
-    });
   }
 
-  /** Stops all collection activity. */
-  public async stop() {
-    if (!this.started) {
-      return;
-    }
-    this.started = false;
-    this.downloadQueue.end();
+  /** Stops all workers and clears state. */
+  public async stop(): Promise<void> {
+    this.running = false;
+    this.wake();
     await Promise.all(this.workers);
     this.workers = [];
-    this.pendingTxs.clear();
-    this.foundTxHashes.clear();
+    this.entries.clear();
   }
 
-  /** Remove the given tx hashes from pending. */
-  public stopCollecting(txHashes: TxHash[]) {
-    for (const txHash of txHashes) {
-      const hashStr = txHash.toString();
-      this.pendingTxs.delete(hashStr);
+  /** Adds entries to the shared map and wakes workers. */
+  public startCollecting(txHashes: TxHash[], context: TxAddContext, deadline: Date): void {
+    if (this.sources.length === 0 || txHashes.length === 0) {
+      return;
+    }
+    if (+deadline <= this.dateProvider.now()) {
+      return;
     }
-  }
-
-  /** Clears all pending state. Items already in the download queue will still be processed but won't be re-queued. */
-  public clearPending() {
-    this.pendingTxs.clear();
-    this.foundTxHashes.clear();
-  }
 
-  /** Queue the given tx hashes for file store collection. */
-  public startCollecting(txHashes: TxHash[], context: TxAddContext) {
     for (const txHash of txHashes) {
       const hashStr = txHash.toString();
-      if (!this.pendingTxs.has(hashStr) && !this.foundTxHashes.has(hashStr)) {
-        this.pendingTxs.set(hashStr, context);
-        this.downloadQueue.put(txHash);
+      if (!this.entries.has(hashStr)) {
+        this.entries.set(hashStr, {
+          txHash: hashStr,
+          context,
+          deadline,
+          attempts: 0,
+          lastAttemptTime: 0,
+          nextSourceIndex: Math.floor(Math.random() * this.sources.length),
+        });
       }
     }
+    this.wake();
   }
 
-  /** Stop tracking txs that were found elsewhere. */
-  public foundTxs(txs: Tx[]) {
+  /** Removes entries for txs that have been found elsewhere. */
+  public foundTxs(txs: Tx[]): void {
     for (const tx of txs) {
-      const hashStr = tx.getTxHash().toString();
-      this.pendingTxs.delete(hashStr);
-      this.foundTxHashes.add(hashStr);
+      this.entries.delete(tx.getTxHash().toString());
     }
   }
 
-  /** Processes a single tx hash from the download queue. */
-  private async processDownload(txHash: TxHash) {
-    const hashStr = txHash.toString();
-    const context = this.pendingTxs.get(hashStr);
-
-    // Skip if already found by another method
-    if (!context) {
-      return;
-    }
-
-    await this.downloadTx(txHash, context);
-    this.pendingTxs.delete(hashStr);
+  /** Clears all pending entries. */
+  public clearPending(): void {
+    this.entries.clear();
   }
 
-  /** Attempt to download a tx from file stores (round-robin). */
-  private async downloadTx(txHash: TxHash, context: TxAddContext) {
-    const startIndex = Math.floor(Math.random() * this.fileStoreSources.length);
-    for (let i = startIndex; i < startIndex + this.fileStoreSources.length; i++) {
-      const source = this.fileStoreSources[i % this.fileStoreSources.length];
+  private async workerLoop(): Promise<void> {
+    while (this.running) {
+      const action = this.getNextAction();
+      if (action.type === 'sleep') {
+        await action.promise;
+        continue;
+      }
+
+      const entry = action.entry;
+      const source = this.sources[entry.nextSourceIndex % this.sources.length];
+      entry.nextSourceIndex++;
+      entry.attempts++;
+      entry.lastAttemptTime = this.dateProvider.now();
 
       try {
         const result = await this.txCollectionSink.collect(
-          hashes => source.getTxsByHash(hashes),
-          [txHash],
+          () => source.getTxsByHash([TxHash.fromString(entry.txHash)]),
+          [entry.txHash],
           {
             description: `file-store ${source.getInfo()}`,
             method: 'file-store',
             fileStore: source.getInfo(),
           },
-          context,
+          entry.context,
         );
-
         if (result.txs.length > 0) {
-          return;
+          this.entries.delete(entry.txHash);
         }
       } catch (err) {
-        this.log.trace(`Failed to download tx ${txHash} from ${source.getInfo()}`, { err });
+        this.log.trace(`Error downloading tx ${entry.txHash} from ${source.getInfo()}`, { err });
+      }
+    }
+  }
+
+  /** Single-pass scan: removes expired entries, finds the best ready entry, or computes sleep time. */
+  private getNextAction(): { type: 'process'; entry: FileStoreTxEntry } | { type: 'sleep'; promise: Promise<void> } {
+    const now = this.dateProvider.now();
+    let best: FileStoreTxEntry | undefined;
+    let earliestReadyAt = Infinity;
+
+    for (const [key, entry] of this.entries) {
+      if (+entry.deadline <= now) {
+        this.entries.delete(key);
+        continue;
+      }
+      const backoffMs = this.getBackoffMs(entry);
+      const readyAt = entry.lastAttemptTime + backoffMs;
+      if (readyAt > now) {
+        earliestReadyAt = Math.min(earliestReadyAt, readyAt);
+        continue;
+      }
+      if (!best || entry.attempts < best.attempts) {
+        best = entry;
       }
     }
 
-    this.log.trace(`Tx ${txHash} not found in any file store`);
+    if (best) {
+      return { type: 'process', entry: best };
+    }
+    if (earliestReadyAt < Infinity) {
+      return { type: 'sleep', promise: this.sleepOrWake(earliestReadyAt - now) };
+    }
+    return { type: 'sleep', promise: this.waitForWake() };
+  }
+
+  /** Computes backoff for an entry. Backoff applies after a full cycle through all sources. */
+  private getBackoffMs(entry: FileStoreTxEntry): number {
+    const fullCycles = Math.floor(entry.attempts / this.sources.length);
+    if (fullCycles === 0) {
+      return 0;
+    }
+    return Math.min(this.config.backoffBaseMs * Math.pow(2, fullCycles - 1), this.config.backoffMaxMs);
+  }
+
+  /** Resolves the current wake signal and creates a new one. */
+  private wake(): void {
+    this.wakeSignal.resolve();
+    this.wakeSignal = promiseWithResolvers<void>();
+  }
+
+  /** Waits until the wake signal is resolved. */
+  private async waitForWake(): Promise<void> {
+    await this.wakeSignal.promise;
+  }
+
+  /** Sleeps for the given duration or until the wake signal is resolved. */
+  private async sleepOrWake(ms: number): Promise<void> {
+    await Promise.race([sleep(ms), this.wakeSignal.promise]);
   }
 }

package/src/services/tx_collection/file_store_tx_source.ts

@@ -1,26 +1,51 @@
 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 {
+  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 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,
     log: Logger = createLogger('p2p:file_store_tx_source'),
+    telemetry: TelemetryClient = getTelemetryClient(),
   ): Promise<FileStoreTxSource | undefined> {
     try {
       const fileStore = await createReadOnlyFileStore(url, log);
@@ -28,7 +53,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, log, telemetry);
     } catch (err) {
       log.warn(`Error creating file store for URL: ${url}`, { error: err });
       return undefined;
@@ -39,32 +64,54 @@ export class FileStoreTxSource implements TxSource {
     return `file-store:${this.baseUrl}`;
   }
 
-  public getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
-    return Promise.all(
-      txHashes.map(async txHash => {
-        const path = `txs/${txHash.toString()}.bin`;
-        try {
-          const buffer = await this.fileStore.read(path);
-          return Tx.fromBuffer(buffer);
-        } catch {
-          // Tx not found or error reading - return undefined
-          return undefined;
-        }
-      }),
-    );
+  public async getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult> {
+    const invalidTxHashes: string[] = [];
+    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,
+    };
   }
 }
 
 /**
  * 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,
   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, 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/missing_txs_tracker.ts

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

package/src/services/tx_collection/proposal_tx_collector.ts

@@ -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 { IMissingTxsTracker } from './missing_txs_tracker.js';
 
 /**
  * Strategy interface for collecting missing transactions for a block or proposal.
@@ -17,14 +18,14 @@ 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 missingTxsTracker - The missing transactions tracker
    * @param blockTxsSource - The block or proposal containing the transactions
    * @param pinnedPeer - Optional peer expected to have the transactions
    * @param timeoutMs - Timeout in milliseconds
    * @returns The collected transactions
    */
   collectTxs(
-    txHashes: TxHash[],
+    missingTxsTracker: IMissingTxsTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
@@ -45,7 +46,7 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
   ) {}
 
   async collectTxs(
-    txHashes: TxHash[],
+    missingTxsTracker: IMissingTxsTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
@@ -58,7 +59,7 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
     } = this.batchTxRequesterConfig ?? {};
 
     const batchRequester = new BatchTxRequester(
-      txHashes,
+      missingTxsTracker,
       blockTxsSource,
       pinnedPeer,
       timeoutMs,
@@ -93,14 +94,14 @@ export class SendBatchRequestCollector implements MissingTxsCollector {
   ) {}
 
   async collectTxs(
-    txHashes: TxHash[],
+    missingTxsTracker: IMissingTxsTracker,
     _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(missingTxsTracker.missingTxHashes).map(TxHash.fromString)),
       pinnedPeer,
       timeoutMs,
       this.maxPeers,

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.missingTxTracker.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);
+}