@aztec/p2p 0.0.1-commit.9ef841308 → 0.0.1-commit.a5db02d

package/src/services/tx_collection/config.ts

@@ -1,26 +1,9 @@
-import {
-  type ConfigMappingsType,
-  booleanConfigHelper,
-  enumConfigHelper,
-  numberConfigHelper,
-} from '@aztec/foundation/config';
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
 import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
 
-export type MissingTxsCollectorType = 'new' | 'old';
-
 export type TxCollectionConfig = {
   /** How long to wait before starting reqresp for fast collection  */
   txCollectionFastNodesTimeoutBeforeReqRespMs: number;
-  /** How often to collect from configured nodes */
-  txCollectionSlowNodesIntervalMs: number;
-  /** How ofter to collect from peers */
-  txCollectionSlowReqRespIntervalMs: number;
-  /** How long to wait for a reqresp response during slow collection */
-  txCollectionSlowReqRespTimeoutMs: number;
-  /** How often to reconcile found txs with the tx pool */
-  txCollectionReconcileIntervalMs: number;
-  /** Whether to disable the slow collection loop if we are dealing with any immediate requests */
-  txCollectionDisableSlowDuringFastRequests: boolean;
   /** How many ms to wait between retried request to a node via RPC during fast collection */
   txCollectionFastNodeIntervalMs: number;
   /** A comma-separated list of Aztec node RPC URLs to use for tx collection */
@@ -29,26 +12,16 @@ export type TxCollectionConfig = {
   txCollectionFastMaxParallelRequestsPerNode: number;
   /** Maximum number of transactions to request from a node in a single batch */
   txCollectionNodeRpcMaxBatchSize: number;
-  /** Which collector implementation to use for missing txs collection */
-  txCollectionMissingTxsCollectorType: MissingTxsCollectorType;
   /** A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection */
   txCollectionFileStoreUrls: string[];
-  /** Delay in ms before file store collection starts after slow collection is triggered */
-  txCollectionFileStoreSlowDelayMs: number;
-  /** Delay in ms before file store collection starts after fast collection is triggered */
+  /** Delay in ms from reqresp start before file store collection begins */
   txCollectionFileStoreFastDelayMs: number;
   /** Number of concurrent workers for fast file store collection */
   txCollectionFileStoreFastWorkerCount: number;
-  /** Number of concurrent workers for slow file store collection */
-  txCollectionFileStoreSlowWorkerCount: number;
   /** Base backoff time in ms for fast file store collection retries */
   txCollectionFileStoreFastBackoffBaseMs: number;
-  /** Base backoff time in ms for slow file store collection retries */
-  txCollectionFileStoreSlowBackoffBaseMs: number;
   /** Max backoff time in ms for fast file store collection retries */
   txCollectionFileStoreFastBackoffMaxMs: number;
-  /** Max backoff time in ms for slow file store collection retries */
-  txCollectionFileStoreSlowBackoffMaxMs: number;
 };
 
 export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig> = {
@@ -57,31 +30,6 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'How long to wait before starting reqresp for fast collection',
     ...numberConfigHelper(200),
   },
-  txCollectionSlowNodesIntervalMs: {
-    env: 'TX_COLLECTION_SLOW_NODES_INTERVAL_MS',
-    description: 'How often to collect from configured nodes in the slow collection loop',
-    ...numberConfigHelper(12_000),
-  },
-  txCollectionSlowReqRespIntervalMs: {
-    env: 'TX_COLLECTION_SLOW_REQ_RESP_INTERVAL_MS',
-    description: 'How often to collect from peers via reqresp in the slow collection loop',
-    ...numberConfigHelper(12_000),
-  },
-  txCollectionSlowReqRespTimeoutMs: {
-    env: 'TX_COLLECTION_SLOW_REQ_RESP_TIMEOUT_MS',
-    description: 'How long to wait for a reqresp response during slow collection',
-    ...numberConfigHelper(20_000),
-  },
-  txCollectionReconcileIntervalMs: {
-    env: 'TX_COLLECTION_RECONCILE_INTERVAL_MS',
-    description: 'How often to reconcile found txs from the tx pool',
-    ...numberConfigHelper(60_000),
-  },
-  txCollectionDisableSlowDuringFastRequests: {
-    env: 'TX_COLLECTION_DISABLE_SLOW_DURING_FAST_REQUESTS',
-    description: 'Whether to disable the slow collection loop if we are dealing with any immediate requests',
-    ...booleanConfigHelper(true),
-  },
   txCollectionFastNodeIntervalMs: {
     env: 'TX_COLLECTION_FAST_NODE_INTERVAL_MS',
     description: 'How many ms to wait between retried request to a node via RPC during fast collection',
@@ -108,11 +56,6 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'Maximum number of transactions to request from a node in a single batch',
     ...numberConfigHelper(MAX_RPC_TXS_LEN),
   },
-  txCollectionMissingTxsCollectorType: {
-    env: 'TX_COLLECTION_MISSING_TXS_COLLECTOR_TYPE',
-    description: 'Which collector implementation to use for missing txs collection (new or old)',
-    ...enumConfigHelper(['new', 'old'] as const, 'new'),
-  },
   txCollectionFileStoreUrls: {
     env: 'TX_COLLECTION_FILE_STORE_URLS',
     description: 'A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection',
@@ -123,14 +66,9 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
         .filter(url => url.length > 0),
     defaultValue: [],
   },
-  txCollectionFileStoreSlowDelayMs: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_DELAY_MS',
-    description: 'Delay before file store collection starts after slow collection',
-    ...numberConfigHelper(24_000),
-  },
   txCollectionFileStoreFastDelayMs: {
     env: 'TX_COLLECTION_FILE_STORE_FAST_DELAY_MS',
-    description: 'Delay before file store collection starts after fast collection',
+    description: 'Delay in ms from reqresp start before file store collection begins',
     ...numberConfigHelper(2_000),
   },
   txCollectionFileStoreFastWorkerCount: {
@@ -138,29 +76,14 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'Number of concurrent workers for fast file store collection',
     ...numberConfigHelper(5),
   },
-  txCollectionFileStoreSlowWorkerCount: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_WORKER_COUNT',
-    description: 'Number of concurrent workers for slow file store collection',
-    ...numberConfigHelper(2),
-  },
   txCollectionFileStoreFastBackoffBaseMs: {
     env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_BASE_MS',
     description: 'Base backoff time in ms for fast file store collection retries',
     ...numberConfigHelper(1_000),
   },
-  txCollectionFileStoreSlowBackoffBaseMs: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_BACKOFF_BASE_MS',
-    description: 'Base backoff time in ms for slow file store collection retries',
-    ...numberConfigHelper(5_000),
-  },
   txCollectionFileStoreFastBackoffMaxMs: {
     env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_MAX_MS',
     description: 'Max backoff time in ms for fast file store collection retries',
     ...numberConfigHelper(5_000),
   },
-  txCollectionFileStoreSlowBackoffMaxMs: {
-    env: 'TX_COLLECTION_FILE_STORE_SLOW_BACKOFF_MAX_MS',
-    description: 'Max backoff time in ms for slow file store collection retries',
-    ...numberConfigHelper(30_000),
-  },
 };

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/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);