@aztec/p2p 0.0.1-commit.4d79d1f2d → 0.0.1-commit.4eabbdb

package/src/services/gossipsub/topic_score_params.ts

@@ -15,6 +15,8 @@ export type TopicScoringNetworkParams = {
   targetCommitteeSize: number;
   /** Duration per block in milliseconds when building multiple blocks per slot. If undefined, single block mode. */
   blockDurationMs?: number;
+  /** Expected number of block proposals per slot for scoring override. 0 disables scoring, undefined falls back to blocksPerSlot - 1. */
+  expectedBlockProposalsPerSlot?: number;
 };
 
 /**
@@ -89,18 +91,41 @@ export function computeThreshold(convergence: number, conservativeFactor: number
   return convergence * conservativeFactor;
 }
 
+/**
+ * Determines the effective expected block proposals per slot for scoring.
+ * Returns undefined if scoring should be disabled, or a positive number if enabled.
+ *
+ * @param blocksPerSlot - Number of blocks per slot from timetable
+ * @param expectedBlockProposalsPerSlot - Config override. 0 disables scoring, undefined falls back to blocksPerSlot - 1.
+ * @returns Positive number of expected block proposals, or undefined if scoring is disabled
+ */
+export function getEffectiveBlockProposalsPerSlot(
+  blocksPerSlot: number,
+  expectedBlockProposalsPerSlot?: number,
+): number | undefined {
+  if (expectedBlockProposalsPerSlot !== undefined) {
+    return expectedBlockProposalsPerSlot > 0 ? expectedBlockProposalsPerSlot : undefined;
+  }
+  // Fallback: In MBPS mode, N-1 block proposals per slot (last one bundled with checkpoint)
+  // In single block mode (blocksPerSlot=1), this is 0 → disabled
+  const fallback = Math.max(0, blocksPerSlot - 1);
+  return fallback > 0 ? fallback : undefined;
+}
+
 /**
  * Gets the expected messages per slot for a given topic type.
  *
  * @param topicType - The topic type
  * @param targetCommitteeSize - Target committee size
  * @param blocksPerSlot - Number of blocks per slot
+ * @param expectedBlockProposalsPerSlot - Override for block proposals. 0 disables scoring, undefined falls back to blocksPerSlot - 1.
  * @returns Expected messages per slot, or undefined if unpredictable
  */
 export function getExpectedMessagesPerSlot(
   topicType: TopicType,
   targetCommitteeSize: number,
   blocksPerSlot: number,
+  expectedBlockProposalsPerSlot?: number,
 ): number | undefined {
   switch (topicType) {
     case TopicType.tx:
@@ -108,9 +133,7 @@ export function getExpectedMessagesPerSlot(
       return undefined;
 
     case TopicType.block_proposal:
-      // In MBPS mode, N-1 block proposals per slot (last one bundled with checkpoint)
-      // In single block mode (blocksPerSlot=1), this is 0
-      return Math.max(0, blocksPerSlot - 1);
+      return getEffectiveBlockProposalsPerSlot(blocksPerSlot, expectedBlockProposalsPerSlot);
 
     case TopicType.checkpoint_proposal:
       // Exactly 1 checkpoint proposal per slot
@@ -190,10 +213,12 @@ const P2_DECAY_WINDOW_SLOTS = 2;
 //   |P3| > 8 + 25 = 33
 //
 // We set P3 max = -34 per topic (slightly more than P1+P2) to ensure pruning.
-// With 3 topics having P3 enabled, total P3b after pruning = -102.
+// The number of P3-enabled topics depends on config: by default 2 (checkpoint_proposal +
+// checkpoint_attestation), or 3 if block proposal scoring is enabled via
+// expectedBlockProposalsPerSlot. Total P3b after pruning = -68 (2 topics) or -102 (3 topics).
 //
-// With appSpecificWeight=10, ~20 HighTolerance errors (-40 app score) plus max P3b (-102)
-// would cross gossipThreshold (-500). This keeps non-contributors from being disconnected
+// With appSpecificWeight=10, ~20 HighTolerance errors (-40 app score) plus max P3b (-68 or -102)
+// would not cross gossipThreshold (-500). This keeps non-contributors from being disconnected
 // unless they also accrue app-level penalties.
 //
 // The weight formula ensures max penalty equals MAX_P3_PENALTY_PER_TOPIC:
@@ -203,12 +228,6 @@ const P2_DECAY_WINDOW_SLOTS = 2;
 /** Maximum P3 penalty per topic (must exceed P1 + P2 to cause pruning) */
 export const MAX_P3_PENALTY_PER_TOPIC = -(MAX_P1_SCORE + MAX_P2_SCORE + 1); // -34
 
-/** Number of topics with P3 enabled in MBPS mode (block_proposal + checkpoint_proposal + checkpoint_attestation) */
-export const NUM_P3_ENABLED_TOPICS = 3;
-
-/** Total maximum P3b penalty across all topics after pruning in MBPS mode */
-export const TOTAL_MAX_P3B_PENALTY = MAX_P3_PENALTY_PER_TOPIC * NUM_P3_ENABLED_TOPICS; // -102
-
 /**
  * Factory class for creating gossipsub topic scoring parameters.
  * Computes shared values once and reuses them across all topics.
@@ -384,6 +403,18 @@ export class TopicScoreParamsFactory {
     });
   }
 
+  /** Number of topics with P3 enabled, computed from config. Always 2 (checkpoint_proposal + checkpoint_attestation) plus optionally block_proposal. */
+  get numP3EnabledTopics(): number {
+    const blockProposalP3Enabled =
+      getEffectiveBlockProposalsPerSlot(this.blocksPerSlot, this.params.expectedBlockProposalsPerSlot) !== undefined;
+    return blockProposalP3Enabled ? 3 : 2;
+  }
+
+  /** Total maximum P3b penalty across all topics after pruning, computed from config */
+  get totalMaxP3bPenalty(): number {
+    return MAX_P3_PENALTY_PER_TOPIC * this.numP3EnabledTopics;
+  }
+
   /**
    * Creates topic score parameters for a specific topic type.
    *
@@ -391,7 +422,12 @@ export class TopicScoreParamsFactory {
    * @returns TopicScoreParams for the topic
    */
   createForTopic(topicType: TopicType): ReturnType<typeof createTopicScoreParams> {
-    const expectedPerSlot = getExpectedMessagesPerSlot(topicType, this.params.targetCommitteeSize, this.blocksPerSlot);
+    const expectedPerSlot = getExpectedMessagesPerSlot(
+      topicType,
+      this.params.targetCommitteeSize,
+      this.blocksPerSlot,
+      this.params.expectedBlockProposalsPerSlot,
+    );
 
     // For unpredictable topics (tx) or topics with 0 expected messages, disable P3/P3b
     if (expectedPerSlot === undefined || expectedPerSlot === 0) {

package/src/services/libp2p/libp2p_service.ts

@@ -341,6 +341,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       heartbeatIntervalMs: config.gossipsubInterval,
       targetCommitteeSize: l1Constants.targetCommitteeSize,
       blockDurationMs: config.blockDurationMs,
+      expectedBlockProposalsPerSlot: config.expectedBlockProposalsPerSlot,
     });
 
     const node = await createLibp2p({
@@ -614,6 +615,10 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return this.peerManager.getPeers(includePending);
   }
 
+  public getGossipMeshPeerCount(topicType: TopicType): number {
+    return this.node.services.pubsub.getMeshPeers(this.topicStrings[topicType]).length;
+  }
+
   private handleGossipSubEvent(e: CustomEvent<GossipsubMessage>) {
     this.logger.trace(`Received PUBSUB message.`);
 
@@ -1544,7 +1549,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   protected async validatePropagatedTx(tx: Tx, peerId: PeerId): Promise<boolean> {
     const currentBlockNumber = await this.archiver.getBlockNumber();
 
-    // We accept transactions if they are not expired by the next slot (checked based on the IncludeByTimestamp field)
+    // We accept transactions if they are not expired by the next slot (checked based on the ExpirationTimestamp field)
     const { ts: nextSlotTimestamp } = this.epochCache.getEpochAndSlotInNextL1Slot();
     const messageValidators = await this.createMessageValidators(currentBlockNumber, nextSlotTimestamp);
 
@@ -1599,7 +1604,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   public async validate(txs: Tx[]): Promise<void> {
     const currentBlockNumber = await this.archiver.getBlockNumber();
 
-    // We accept transactions if they are not expired by the next slot (checked based on the IncludeByTimestamp field)
+    // We accept transactions if they are not expired by the next slot (checked based on the ExpirationTimestamp field)
     const { ts: nextSlotTimestamp } = this.epochCache.getEpochAndSlotInNextL1Slot();
     const messageValidators = await this.createMessageValidators(currentBlockNumber, nextSlotTimestamp);
 

package/src/services/reqresp/batch-tx-requester/batch_tx_requester.ts

@@ -10,6 +10,7 @@ import { Tx, TxArray, TxHash } from '@aztec/stdlib/tx';
 import type { PeerId } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 
+import type { IMissingTxsTracker } from '../../tx_collection/missing_txs_tracker.js';
 import { ReqRespSubProtocol } from '.././interface.js';
 import { BlockTxsRequest, BlockTxsResponse, type BlockTxsSource } from '.././protocols/index.js';
 import { ReqRespStatus } from '.././status.js';
@@ -20,7 +21,7 @@ import {
   DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE,
 } from './config.js';
 import type { BatchTxRequesterLibP2PService, BatchTxRequesterOptions, ITxMetadataCollection } from './interface.js';
-import { MissingTxMetadata, MissingTxMetadataCollection } from './missing_txs.js';
+import { MissingTxMetadataCollection } from './missing_txs.js';
 import { type IPeerCollection, PeerCollection } from './peer_collection.js';
 import { BatchRequestTxValidator, type IBatchRequestTxValidator } from './tx_validator.js';
 
@@ -60,7 +61,7 @@ export class BatchTxRequester {
   private readonly txBatchSize: number;
 
   constructor(
-    missingTxs: TxHash[],
+    missingTxsTracker: IMissingTxsTracker,
     blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
@@ -99,8 +100,7 @@ export class BatchTxRequester {
         this.p2pService.peerScoring,
       );
     }
-    const entries: Array<[string, MissingTxMetadata]> = missingTxs.map(h => [h.toString(), new MissingTxMetadata(h)]);
-    this.txsMetadata = new MissingTxMetadataCollection(entries, this.txBatchSize);
+    this.txsMetadata = new MissingTxMetadataCollection(missingTxsTracker, this.txBatchSize);
     this.smartRequesterSemaphore = this.opts.semaphore ?? new Semaphore(0);
   }
 
@@ -661,7 +661,7 @@ export class BatchTxRequester {
   /*
    * @returns true if all missing txs have been fetched */
   private fetchedAllTxs() {
-    return Array.from(this.txsMetadata.values()).every(tx => tx.fetched);
+    return this.txsMetadata.getMissingTxHashes().size == 0;
   }
 
   /*
@@ -679,7 +679,7 @@ export class BatchTxRequester {
       this.unlockSmartRequesterSemaphores();
     }
 
-    return aborted || this.txsMetadata.size === 0 || this.fetchedAllTxs() || this.dateProvider.now() > this.deadline;
+    return aborted || this.fetchedAllTxs() || this.dateProvider.now() > this.deadline;
   }
 
   /*

package/src/services/reqresp/batch-tx-requester/interface.ts

@@ -6,7 +6,6 @@ import type { PeerId } from '@libp2p/interface';
 
 import type { ConnectionSampler } from '../connection-sampler/connection_sampler.js';
 import type { ReqRespInterface } from '../interface.js';
-import type { MissingTxMetadata } from './missing_txs.js';
 import type { IPeerCollection } from './peer_collection.js';
 import type { BatchRequestTxValidatorConfig, IBatchRequestTxValidator } from './tx_validator.js';
 
@@ -15,18 +14,15 @@ export interface IPeerPenalizer {
 }
 
 export interface ITxMetadataCollection {
-  size: number;
-  values(): IterableIterator<MissingTxMetadata>;
   getMissingTxHashes(): Set<string>;
+  markFetched(peerId: PeerId, tx: Tx): boolean;
   getTxsToRequestFromThePeer(peer: PeerId): TxHash[];
   markRequested(txHash: TxHash): void;
   markInFlightBySmartPeer(txHash: TxHash): void;
   markNotInFlightBySmartPeer(txHash: TxHash): void;
   alreadyFetched(txHash: TxHash): boolean;
   // Returns true if tx was marked as fetched, false if it was already marked as fetched
-  markFetched(peerId: PeerId, tx: Tx): boolean;
   markPeerHas(peerId: PeerId, txHashes: TxHash[]): void;
-  getFetchedTxs(): Tx[];
 }
 
 /**

package/src/services/reqresp/batch-tx-requester/missing_txs.ts

@@ -2,13 +2,13 @@ import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
+import type { IMissingTxsTracker } from '../../tx_collection/missing_txs_tracker.js';
 import { DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE } from './config.js';
 import type { ITxMetadataCollection } from './interface.js';
 
-export class MissingTxMetadata {
+class MissingTxMetadata {
   constructor(
-    public readonly txHash: TxHash,
-    public fetched = false,
+    public readonly txHash: string,
     public requestedCount = 0,
     public inFlightCount = 0,
     public tx: Tx | undefined = undefined,
@@ -30,24 +30,6 @@ export class MissingTxMetadata {
   public isInFlight(): boolean {
     return this.inFlightCount > 0;
   }
-
-  //Returns true if this is the first time we mark it as fetched
-  public markAsFetched(peerId: PeerId, tx: Tx): boolean {
-    if (this.fetched) {
-      return false;
-    }
-
-    this.fetched = true;
-    this.tx = tx;
-
-    this.peers.add(peerId.toString());
-
-    return true;
-  }
-
-  public toString() {
-    return this.txHash.toString();
-  }
 }
 
 /*
@@ -55,21 +37,18 @@ export class MissingTxMetadata {
  * This could be better optimized but given expected count of missing txs (N < 100)
  * At the moment there is no need for it. And benefit is that we have everything in single store
  * */
-export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata> implements ITxMetadataCollection {
+export class MissingTxMetadataCollection implements ITxMetadataCollection {
+  private txMetadata = new Map<string, MissingTxMetadata>();
+
   constructor(
-    entries?: readonly (readonly [string, MissingTxMetadata])[] | null,
+    private missingTxsTracker: IMissingTxsTracker,
     private readonly txBatchSize: number = DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE,
   ) {
-    super(entries);
-  }
-  public getSortedByRequestedCountAsc(txs: string[]): MissingTxMetadata[] {
-    return Array.from(this.values().filter(txMeta => txs.includes(txMeta.txHash.toString()))).sort(
-      (a, b) => a.requestedCount - b.requestedCount,
-    );
+    missingTxsTracker.missingTxHashes.forEach(hash => this.txMetadata.set(hash, new MissingTxMetadata(hash)));
   }
 
   public getPrioritizingNotInFlightAndLowerRequestCount(txs: string[]): MissingTxMetadata[] {
-    const filtered = Array.from(this.values()).filter(txMeta => txs.includes(txMeta.txHash.toString()));
+    const filtered = Array.from(this.txMetadata.values()).filter(txMeta => txs.includes(txMeta.txHash.toString()));
 
     const [notInFlight, inFlight] = filtered.reduce<[MissingTxMetadata[], MissingTxMetadata[]]>(
       (buckets, tx) => {
@@ -85,43 +64,15 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
     return [...notInFlight, ...inFlight];
   }
 
-  public getFetchedTxHashes(): Set<string> {
-    return new Set(
-      this.values()
-        .filter(t => t.fetched)
-        .map(t => t.txHash.toString()),
-    );
-  }
-
   public getMissingTxHashes(): Set<string> {
-    return new Set(
-      this.values()
-        .filter(t => !t.fetched)
-        .map(t => t.txHash.toString()),
-    );
-  }
-
-  public getInFlightTxHashes(): Set<string> {
-    return new Set(
-      this.values()
-        .filter(t => t.isInFlight())
-        .map(t => t.txHash.toString()),
-    );
-  }
-
-  public getFetchedTxs(): Tx[] {
-    return Array.from(
-      this.values()
-        .map(t => t.tx)
-        .filter(t => !!t),
-    );
+    return this.missingTxsTracker.missingTxHashes;
   }
 
   public getTxsPeerHas(peer: PeerId): Set<string> {
     const peerIdStr = peer.toString();
     const txsPeerHas = new Set<string>();
 
-    this.values().forEach(txMeta => {
+    this.txMetadata.values().forEach(txMeta => {
       if (txMeta.peers.has(peerIdStr)) {
         txsPeerHas.add(txMeta.txHash.toString());
       }
@@ -132,13 +83,13 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
 
   public getTxsToRequestFromThePeer(peer: PeerId): TxHash[] {
     const txsPeerHas = this.getTxsPeerHas(peer);
-    const fetchedTxs = this.getFetchedTxHashes();
+    const missingTxHashes = this.getMissingTxHashes();
 
-    const txsToRequest = txsPeerHas.difference(fetchedTxs);
+    const txsToRequest = txsPeerHas.intersection(missingTxHashes);
 
     if (txsToRequest.size >= this.txBatchSize) {
       return this.getPrioritizingNotInFlightAndLowerRequestCount(Array.from(txsToRequest))
-        .map(t => t.txHash)
+        .map(t => TxHash.fromString(t.txHash))
         .slice(0, this.txBatchSize);
     }
 
@@ -150,13 +101,13 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
       Array.from(this.getMissingTxHashes().difference(txsToRequest)),
     )
       .slice(0, countToFill)
-      .map(t => t.txHash);
+      .map(t => TxHash.fromString(t.txHash));
 
     return [...Array.from(txsToRequest).map(t => TxHash.fromString(t)), ...txsToFill];
   }
 
   public markRequested(txHash: TxHash) {
-    this.get(txHash.toString())?.markAsRequested();
+    this.txMetadata.get(txHash.toString())?.markAsRequested();
   }
 
   /*
@@ -165,7 +116,7 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
    * "dumb" peer might return it, or might not - we don't know
    * */
   public markInFlightBySmartPeer(txHash: TxHash) {
-    this.get(txHash.toString())?.markInFlight();
+    this.txMetadata.get(txHash.toString())?.markInFlight();
   }
 
   /*
@@ -173,16 +124,16 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
    * Because the smart peer should return this tx, whereas
    * "dumb" peer might return it, or might not - we don't know*/
   public markNotInFlightBySmartPeer(txHash: TxHash) {
-    this.get(txHash.toString())?.markNotInFlight();
+    this.txMetadata.get(txHash.toString())?.markNotInFlight();
   }
 
   public alreadyFetched(txHash: TxHash): boolean {
-    return this.get(txHash.toString())?.fetched ?? false;
+    return !this.missingTxsTracker.isMissing(txHash.toString());
   }
 
   public markFetched(peerId: PeerId, tx: Tx): boolean {
     const txHashStr = tx.txHash.toString();
-    const txMeta = this.get(txHashStr);
+    const txMeta = this.txMetadata.get(txHashStr);
     if (!txMeta) {
       //TODO: what to do about peer which sent txs we didn't request?
       // 1. don't request from it in the scope of this batch request
@@ -192,7 +143,8 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
       return false;
     }
 
-    return txMeta.markAsFetched(peerId, tx);
+    txMeta.peers.add(peerId.toString());
+    return this.missingTxsTracker.markFetched(tx);
   }
 
   public markPeerHas(peerId: PeerId, txHash: TxHash[]) {
@@ -200,7 +152,7 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
     txHash
       .map(t => t.toString())
       .forEach(txh => {
-        const txMeta = this.get(txh);
+        const txMeta = this.txMetadata.get(txh);
         if (txMeta) {
           txMeta.peers.add(peerIdStr);
         }

package/src/services/service.ts

@@ -1,7 +1,13 @@
 import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
-import type { BlockProposal, CheckpointAttestation, CheckpointProposalCore, Gossipable } from '@aztec/stdlib/p2p';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposalCore,
+  Gossipable,
+  TopicType,
+} from '@aztec/stdlib/p2p';
 import type { Tx } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -130,6 +136,9 @@ export interface P2PService {
 
   getPeers(includePending?: boolean): PeerInfo[];
 
+  /** Returns the number of peers in the GossipSub mesh for a given topic type. */
+  getGossipMeshPeerCount(topicType: TopicType): number;
+
   validate(txs: Tx[]): Promise<void>;
 
   addReqRespSubProtocol(

package/src/services/tx_collection/config.ts

@@ -37,6 +37,18 @@ export type TxCollectionConfig = {
   txCollectionFileStoreSlowDelayMs: number;
   /** Delay in ms before file store collection starts after fast collection is triggered */
   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> = {
@@ -121,4 +133,34 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'Delay before file store collection starts after fast collection',
     ...numberConfigHelper(2_000),
   },
+  txCollectionFileStoreFastWorkerCount: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_WORKER_COUNT',
+    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),
+  },
 };