@aztec/p2p 0.0.1-commit.7b97ef96e → 0.0.1-commit.7cbc774

package/src/services/tx_collection/file_store_tx_collection.ts

@@ -1,10 +1,11 @@
+import { times } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-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 { TxHash } from '@aztec/stdlib/tx';
 
 import type { FileStoreTxSource } from './file_store_tx_source.js';
+import type { IRequestTracker } from './request_tracker.js';
 import type { TxAddContext, TxCollectionSink } from './tx_collection_sink.js';
 
 /** Configuration for a FileStoreTxCollection instance. */
@@ -16,8 +17,6 @@ export type FileStoreCollectionConfig = {
 
 type FileStoreTxEntry = {
   txHash: string;
-  context: TxAddContext;
-  deadline: Date;
   attempts: number;
   lastAttemptTime: number;
   nextSourceIndex: number;
@@ -25,96 +24,60 @@ type FileStoreTxEntry = {
 
 /**
  * Collects txs from file stores as a fallback after P2P methods have been tried.
- * 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.
+ * Each call to startCollecting spins up its own worker pool which pulls entries with priority
+ * (fewest attempts first), retries with round-robin across sources, and applies exponential
+ * backoff between full cycles through all sources. Workers self-terminate when the request
+ * tracker is cancelled (deadline / all-fetched / external) or when there is nothing left to do.
  */
 export class FileStoreTxCollection {
-  /** Map from tx hash string to entry for all pending downloads. */
-  private entries = new Map<string, FileStoreTxEntry>();
-
-  /** Worker promises for the shared worker pool. */
-  private workers: Promise<void>[] = [];
-
-  /** 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 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 shared worker pool. */
-  public start(): void {
-    if (this.sources.length === 0) {
-      this.log.debug('No file store sources configured');
-      return;
-    }
-    this.running = true;
-    for (let i = 0; i < this.config.workerCount; i++) {
-      this.workers.push(this.workerLoop());
-    }
-  }
-
-  /** Stops all workers and clears state. */
-  public async stop(): Promise<void> {
-    this.running = false;
-    this.wake();
-    await Promise.all(this.workers);
-    this.workers = [];
-    this.entries.clear();
-  }
-
-  /** 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()) {
+  ) {}
+
+  /**
+   * Spins up workers to download all txs still missing from the tracker, racing across the
+   * configured file store sources. Resolves once all workers settle.
+   */
+  public async startCollecting(requestTracker: IRequestTracker, context: TxAddContext): Promise<void> {
+    if (this.sources.length === 0 || requestTracker.checkCancelled()) {
       return;
     }
 
-    for (const txHash of txHashes) {
-      const hashStr = txHash.toString();
-      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),
-        });
-      }
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    const entries: Set<FileStoreTxEntry> = new Set();
+    for (const hashStr of requestTracker.missingTxHashes) {
+      entries.add({
+        txHash: hashStr,
+        attempts: 0,
+        lastAttemptTime: 0,
+        nextSourceIndex: Math.floor(Math.random() * this.sources.length),
+      });
     }
-    this.wake();
-  }
 
-  /** Removes entries for txs that have been found elsewhere. */
-  public foundTxs(txs: Tx[]): void {
-    for (const tx of txs) {
-      this.entries.delete(tx.getTxHash().toString());
+    // Yield before spawning so the synchronous caller can finish any follow-up (eg. marking a tx
+    // as fetched on the tracker, or cancelling it) before workers begin scanning entries.
+    await Promise.resolve();
+    if (requestTracker.checkCancelled()) {
+      return;
     }
-  }
 
-  /** Clears all pending entries. */
-  public clearPending(): void {
-    this.entries.clear();
+    await Promise.allSettled(times(this.config.workerCount, () => this.workerLoop(entries, requestTracker, context)));
   }
 
-  private async workerLoop(): Promise<void> {
-    while (this.running) {
-      const action = this.getNextAction();
+  private async workerLoop(
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    entries: Set<FileStoreTxEntry>,
+    requestTracker: IRequestTracker,
+    context: TxAddContext,
+  ): Promise<void> {
+    while (!requestTracker.checkCancelled() && entries.size > 0) {
+      const action = this.getNextAction(entries, requestTracker);
       if (action.type === 'sleep') {
-        await action.promise;
+        await Promise.race([sleep(action.ms), requestTracker.cancellationToken]);
         continue;
       }
 
@@ -133,10 +96,10 @@ export class FileStoreTxCollection {
             method: 'file-store',
             fileStore: source.getInfo(),
           },
-          entry.context,
+          context,
         );
         if (result.txs.length > 0) {
-          this.entries.delete(entry.txHash);
+          entries.delete(entry);
         }
       } catch (err) {
         this.log.trace(`Error downloading tx ${entry.txHash} from ${source.getInfo()}`, { err });
@@ -144,15 +107,20 @@ export class FileStoreTxCollection {
     }
   }
 
-  /** 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> } {
+  /** Single-pass scan: removes stale entries, finds the best ready entry, or computes sleep time. */
+  private getNextAction(
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    entries: Set<FileStoreTxEntry>,
+    requestTracker: IRequestTracker,
+  ): { type: 'process'; entry: FileStoreTxEntry } | { type: 'sleep'; ms: number } {
     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);
+    for (const entry of entries) {
+      // Drop entries whose tx was already found via another collection path.
+      if (!requestTracker.isMissing(entry.txHash)) {
+        entries.delete(entry);
         continue;
       }
       const backoffMs = this.getBackoffMs(entry);
@@ -169,10 +137,9 @@ export class FileStoreTxCollection {
     if (best) {
       return { type: 'process', entry: best };
     }
-    if (earliestReadyAt < Infinity) {
-      return { type: 'sleep', promise: this.sleepOrWake(earliestReadyAt - now) };
-    }
-    return { type: 'sleep', promise: this.waitForWake() };
+    // earliestReadyAt is finite whenever there are surviving entries; if entries became empty,
+    // the outer worker loop will exit on its next iteration via entries.size === 0.
+    return { type: 'sleep', ms: earliestReadyAt === Infinity ? 0 : earliestReadyAt - now };
   }
 
   /** Computes backoff for an entry. Backoff applies after a full cycle through all sources. */
@@ -183,20 +150,4 @@ export class FileStoreTxCollection {
     }
     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,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);
 }

package/src/services/tx_collection/index.ts

@@ -1,8 +1,3 @@
-export { TxCollection, type FastCollectionRequestInput } from './tx_collection.js';
+export { TxCollection, type FastCollectionRequestInput, type IReqRespTxsCollector } from './tx_collection.js';
 export { type TxSource, createNodeRpcTxSources, NodeRpcTxSource } from './tx_source.js';
-export {
-  type MissingTxsCollector,
-  BatchTxRequesterCollector,
-  SendBatchRequestCollector,
-} from './proposal_tx_collector.js';
 export { FileStoreTxSource, createFileStoreTxSources } from './file_store_tx_source.js';

package/src/services/tx_collection/instrumentation.ts

@@ -18,13 +18,7 @@ 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',
-        'file-store',
-      ],
+      [Attributes.TX_COLLECTION_METHOD]: ['fast-req-resp', 'fast-node-rpc', 'file-store'],
     });
 
     this.collectionDurationPerTx = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_TX);

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