@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/dest/services/service.d.ts

@@ -1,3 +1,4 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
 import type { Tx } from '@aztec/stdlib/tx';
@@ -5,12 +6,15 @@ import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import type EventEmitter from 'events';
 import type { P2PReqRespConfig } from './reqresp/config.js';
-import type { ReqRespSubProtocol, SubProtocolMap } from './reqresp/interface.js';
+import type { StatusMessage } from './reqresp/index.js';
+import type { ReqRespSubProtocol, ReqRespSubProtocolHandler, ReqRespSubProtocolValidators, SubProtocolMap } from './reqresp/interface.js';
+import type { AuthRequest, AuthResponse } from './reqresp/protocols/auth.js';
 export declare enum PeerDiscoveryState {
     RUNNING = "running",
     STOPPED = "stopped"
 }
 export type P2PBlockReceivedCallback = (block: BlockProposal, sender: PeerId) => Promise<BlockAttestation[] | undefined>;
+export type AuthReceivedCallback = (peerId: PeerId, authRequest: AuthRequest) => Promise<AuthResponse | undefined>;
 /**
  * The interface for a P2P service implementation.
  */
@@ -30,14 +34,6 @@ export interface P2PService {
      * @param message - The message to be propagated.
      */
     propagate<T extends Gossipable>(message: T): Promise<void>;
-    /**
-     * Request information from peers via the request response protocol.
-     *
-     * @param protocol - The request response protocol to use
-     * @param request - The request type, corresponding to the protocol
-     * @returns The response type, corresponding to the protocol
-     */
-    sendRequest<Protocol extends ReqRespSubProtocol>(protocol: Protocol, request: InstanceType<SubProtocolMap[Protocol]['request']>): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
     /**
      * Send a batch of requests to peers, and return the responses
      *
@@ -45,12 +41,16 @@ export interface P2PService {
      * @param requests - The requests to send to the peers
      * @returns The responses to the requests
      */
-    sendBatchRequest<Protocol extends ReqRespSubProtocol>(protocol: Protocol, requests: InstanceType<SubProtocolMap[Protocol]['request']>[], pinnedPeerId?: PeerId, timeoutMs?: number, maxPeers?: number, maxRetryAttempts?: number): Promise<(InstanceType<SubProtocolMap[Protocol]['response']> | undefined)[]>;
+    sendBatchRequest<Protocol extends ReqRespSubProtocol>(protocol: Protocol, requests: InstanceType<SubProtocolMap[Protocol]['request']>[], pinnedPeerId?: PeerId, timeoutMs?: number, maxPeers?: number, maxRetryAttempts?: number): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]>;
     registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
     getEnr(): ENR | undefined;
     getPeers(includePending?: boolean): PeerInfo[];
     validate(txs: Tx[]): Promise<void>;
+    addReqRespSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler, validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol]): Promise<void>;
+    handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
     updateConfig(config: Partial<P2PReqRespConfig>): void;
+    /** If node running this P2P stack is validator, passes in validator address to P2P layer */
+    registerThisValidatorAddresses(address: EthAddress[]): void;
 }
 /**
  * The interface for a peer discovery service implementation.

package/dest/services/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/services/service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/services/service.ts"],"names":[],"mappings":"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"}

package/dest/services/tx_collection/config.d.ts

@@ -0,0 +1,25 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+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 */
+    txCollectionNodeRpcUrls: string[];
+    /** Maximum number of parallel requests to make to a node during fast collection */
+    txCollectionFastMaxParallelRequestsPerNode: number;
+    /** Maximum number of transactions to request from a node in a single batch */
+    txCollectionNodeRpcMaxBatchSize: number;
+};
+export declare const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dest/services/tx_collection/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA2C,MAAM,0BAA0B,CAAC;AAG5G,MAAM,MAAM,kBAAkB,GAAG;IAC/B,oEAAoE;IACpE,2CAA2C,EAAE,MAAM,CAAC;IACpD,iDAAiD;IACjD,+BAA+B,EAAE,MAAM,CAAC;IACxC,sCAAsC;IACtC,iCAAiC,EAAE,MAAM,CAAC;IAC1C,qEAAqE;IACrE,gCAAgC,EAAE,MAAM,CAAC;IACzC,wDAAwD;IACxD,+BAA+B,EAAE,MAAM,CAAC;IACxC,gGAAgG;IAChG,yCAAyC,EAAE,OAAO,CAAC;IACnD,2FAA2F;IAC3F,8BAA8B,EAAE,MAAM,CAAC;IACvC,6EAA6E;IAC7E,uBAAuB,EAAE,MAAM,EAAE,CAAC;IAClC,mFAAmF;IACnF,0CAA0C,EAAE,MAAM,CAAC;IACnD,8EAA8E;IAC9E,+BAA+B,EAAE,MAAM,CAAC;CACzC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,kBAAkB,CAyD7E,CAAC"}

package/dest/services/tx_collection/config.js

@@ -0,0 +1,58 @@
+import { booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
+import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/server';
+export const txCollectionConfigMappings = {
+    txCollectionFastNodesTimeoutBeforeReqRespMs: {
+        env: 'TX_COLLECTION_FAST_NODES_TIMEOUT_BEFORE_REQ_RESP_MS',
+        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',
+        ...numberConfigHelper(500)
+    },
+    txCollectionNodeRpcUrls: {
+        env: 'TX_COLLECTION_NODE_RPC_URLS',
+        fallback: [
+            'PROVER_COORDINATION_NODE_URLS'
+        ],
+        description: 'A comma-separated list of Aztec node RPC URLs to use for tx collection',
+        parseEnv: (val)=>val.split(',').map((url)=>url.trim().replace(/\/$/, '')).filter((url)=>url.length > 0),
+        defaultValue: []
+    },
+    txCollectionFastMaxParallelRequestsPerNode: {
+        env: 'TX_COLLECTION_FAST_MAX_PARALLEL_REQUESTS_PER_NODE',
+        description: 'Maximum number of parallel requests to make to a node during fast collection',
+        ...numberConfigHelper(4)
+    },
+    txCollectionNodeRpcMaxBatchSize: {
+        env: 'TX_COLLECTION_NODE_RPC_MAX_BATCH_SIZE',
+        description: 'Maximum number of transactions to request from a node in a single batch',
+        ...numberConfigHelper(MAX_RPC_TXS_LEN)
+    }
+};

package/dest/services/tx_collection/fast_tx_collection.d.ts

@@ -0,0 +1,56 @@
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+import type { PeerId } from '@libp2p/interface';
+import { type ReqRespInterface } from '../reqresp/interface.js';
+import type { TxCollectionConfig } from './config.js';
+import type { FastCollectionRequest, FastCollectionRequestInput } from './tx_collection.js';
+import type { TxCollectionSink } from './tx_collection_sink.js';
+import type { TxSource } from './tx_source.js';
+export declare class FastTxCollection {
+    private reqResp;
+    private nodes;
+    private txCollectionSink;
+    private config;
+    private dateProvider;
+    private log;
+    protected requests: Set<FastCollectionRequest>;
+    constructor(reqResp: Pick<ReqRespInterface, 'sendBatchRequest'>, nodes: TxSource[], txCollectionSink: TxCollectionSink, config: TxCollectionConfig, dateProvider?: DateProvider, log?: Logger);
+    stop(): Promise<void>;
+    getFastCollectionRequests(): Set<FastCollectionRequest>;
+    collectFastFor(input: FastCollectionRequestInput, txHashes: TxHash[] | string[], opts: {
+        deadline: Date;
+        pinnedPeer?: PeerId;
+    }): Promise<Tx[]>;
+    protected collectFast(request: FastCollectionRequest, opts: {
+        proposal?: BlockProposal;
+        deadline: Date;
+        pinnedPeer?: PeerId;
+    }): Promise<void>;
+    /**
+     * Starts collecting txs from all configured nodes. We send `txCollectionFastMaxParallelRequestsPerNode` requests
+     * in parallel to each node. We keep track of the number of attempts made to collect each tx, so we can prioritize
+     * the txs that have been requested less often whenever we need to send a new batch of requests. We ensure that no
+     * tx is requested more than once at the same time to the same node.
+     */
+    private collectFastFromNodes;
+    private collectFastFromNode;
+    private collectFastViaReqResp;
+    /**
+     * Handle txs by marking them as found for the requests that are waiting for them, and resolves the request if all its txs have been found.
+     * Called internally and from the main tx collection manager whenever the tx pool emits a tx-added event.
+     */
+    foundTxs(txs: Tx[]): void;
+    /**
+     * Stop collecting all txs for blocks less than or requal to the block number specified.
+     * To be called when we no longer care about gathering txs up to a certain block, eg when they become proven or finalized.
+     */
+    stopCollectingForBlocksUpTo(blockNumber: number): void;
+    /**
+     * Stop collecting all txs for blocks greater than the block number specified.
+     * To be called when there is a chain prune and previously mined txs are no longer relevant.
+     */
+    stopCollectingForBlocksAfter(blockNumber: number): void;
+}
+//# sourceMappingURL=fast_tx_collection.d.ts.map

package/dest/services/tx_collection/fast_tx_collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fast_tx_collection.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/fast_tx_collection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,EAAE,YAAY,EAAW,MAAM,yBAAyB,CAAC;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,KAAK,gBAAgB,EAAsB,MAAM,yBAAyB,CAAC;AAEpF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAC5F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,qBAAa,gBAAgB;IAKzB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,GAAG;IARb,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAa;gBAGjD,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,EACnD,KAAK,EAAE,QAAQ,EAAE,EACjB,gBAAgB,EAAE,gBAAgB,EAClC,MAAM,EAAE,kBAAkB,EAC1B,YAAY,GAAE,YAAiC,EAC/C,GAAG,GAAE,MAAkD;IAGpD,IAAI;IAKV,yBAAyB;IAInB,cAAc,CACzB,KAAK,EAAE,0BAA0B,EACjC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAC7B,IAAI,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;cA0C/B,WAAW,CACzB,OAAO,EAAE,qBAAqB,EAC9B,IAAI,EAAE;QAAE,QAAQ,CAAC,EAAE,aAAa,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;IAiDzE;;;;;OAKG;YACW,oBAAoB;YAYpB,mBAAmB;YAiFnB,qBAAqB;IA6CnC;;;OAGG;IACI,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE;IA0BzB;;;OAGG;IACI,2BAA2B,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAS7D;;;OAGG;IACI,4BAA4B,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;CAQ/D"}

package/dest/services/tx_collection/fast_tx_collection.js

@@ -0,0 +1,295 @@
+import { times } from '@aztec/foundation/collection';
+import { AbortError, TimeoutError } from '@aztec/foundation/error';
+import { createLogger } from '@aztec/foundation/log';
+import { boundInclusive } from '@aztec/foundation/number';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider, elapsed } from '@aztec/foundation/timer';
+import { TxHash } from '@aztec/stdlib/tx';
+import { ReqRespSubProtocol } from '../reqresp/interface.js';
+import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
+export class FastTxCollection {
+    reqResp;
+    nodes;
+    txCollectionSink;
+    config;
+    dateProvider;
+    log;
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    requests;
+    constructor(reqResp, nodes, txCollectionSink, config, dateProvider = new DateProvider(), log = createLogger('p2p:tx_collection_service')){
+        this.reqResp = reqResp;
+        this.nodes = nodes;
+        this.txCollectionSink = txCollectionSink;
+        this.config = config;
+        this.dateProvider = dateProvider;
+        this.log = log;
+        this.requests = new Set();
+    }
+    async stop() {
+        this.requests.forEach((request)=>request.promise.reject(new AbortError(`Stopped collection service`)));
+        await Promise.resolve();
+    }
+    getFastCollectionRequests() {
+        return this.requests;
+    }
+    async collectFastFor(input, txHashes, opts) {
+        const timeout = opts.deadline.getTime() - this.dateProvider.now();
+        if (timeout <= 0) {
+            this.log.warn(`Deadline for fast tx collection is in the past (${timeout}ms)`, {
+                deadline: opts.deadline.getTime(),
+                now: this.dateProvider.now()
+            });
+            return [];
+        }
+        const blockInfo = input.type === 'proposal' ? input.blockProposal.toBlockInfo() : input.block.toBlockInfo();
+        // This promise is used to await for the collection to finish during the main collectFast method.
+        // It gets resolved in `foundTxs` when all txs have been collected, or rejected if the request is aborted or hits the deadline.
+        const promise = promiseWithResolvers();
+        setTimeout(()=>promise.reject(new TimeoutError(`Timed out while collecting txs`)), timeout);
+        const request = {
+            ...input,
+            blockInfo,
+            promise,
+            foundTxs: new Map(),
+            missingTxHashes: new Set(txHashes.map((t)=>t.toString())),
+            deadline: opts.deadline
+        };
+        const [duration] = await elapsed(()=>this.collectFast(request, {
+                ...opts
+            }));
+        this.log.verbose(`Collected ${request.foundTxs.size} txs out of ${txHashes.length} for ${input.type} at slot ${blockInfo.slotNumber}`, {
+            ...blockInfo,
+            duration,
+            requestType: input.type,
+            missingTxs: [
+                ...request.missingTxHashes
+            ]
+        });
+        return [
+            ...request.foundTxs.values()
+        ];
+    }
+    async collectFast(request, opts) {
+        this.requests.add(request);
+        const { blockInfo } = request;
+        this.log.debug(`Starting fast collection of ${request.missingTxHashes.size} txs for ${request.type} at slot ${blockInfo.slotNumber}`, {
+            ...blockInfo,
+            requestType: request.type,
+            deadline: opts.deadline
+        });
+        try {
+            // Start blasting all nodes for the txs. We give them a little time to respond before we start reqresp.
+            // And keep an eye on the request promise to ensure we don't wait longer than the deadline or return as soon
+            // as we have collected all txs, whatever the source.
+            const nodeCollectionPromise = this.collectFastFromNodes(request, opts);
+            const waitBeforeReqResp = sleep(this.config.txCollectionFastNodesTimeoutBeforeReqRespMs);
+            await Promise.race([
+                request.promise.promise,
+                waitBeforeReqResp
+            ]);
+            // If we have collected all txs, we can stop here
+            if (request.missingTxHashes.size === 0) {
+                this.log.debug(`All txs collected for slot ${blockInfo.slotNumber} without reqresp`, blockInfo);
+                return;
+            }
+            // Start blasting reqresp for the remaining txs. Note that node collection keeps running in parallel.
+            // We stop when we have collected all txs, timed out, or both node collection and reqresp have given up.
+            const collectionPromise = Promise.allSettled([
+                this.collectFastViaReqResp(request, opts),
+                nodeCollectionPromise
+            ]);
+            await Promise.race([
+                collectionPromise,
+                request.promise.promise
+            ]);
+        } catch (err) {
+            // Log and swallow all errors
+            const logCtx = {
+                ...blockInfo,
+                errorMessage: err instanceof Error ? err.message : undefined,
+                missingTxs: [
+                    ...request.missingTxHashes
+                ].map((txHash)=>txHash.toString())
+            };
+            if (err instanceof Error && err.name === 'TimeoutError') {
+                this.log.warn(`Timed out collecting txs for ${request.type} at slot ${blockInfo.slotNumber}`, logCtx);
+            } else if (err instanceof Error && err.name === 'AbortError') {
+                this.log.warn(`Aborted collecting txs for ${request.type} at slot ${blockInfo.slotNumber}`, logCtx);
+            } else {
+                this.log.error(`Error collecting txs for ${request.type} for slot ${blockInfo.slotNumber}`, err, logCtx);
+            }
+        } finally{
+            // Ensure no unresolved promises and remove the request from the set
+            request.promise.resolve();
+            this.requests.delete(request);
+        }
+    }
+    /**
+   * Starts collecting txs from all configured nodes. We send `txCollectionFastMaxParallelRequestsPerNode` requests
+   * in parallel to each node. We keep track of the number of attempts made to collect each tx, so we can prioritize
+   * the txs that have been requested less often whenever we need to send a new batch of requests. We ensure that no
+   * tx is requested more than once at the same time to the same node.
+   */ async collectFastFromNodes(request, opts) {
+        if (this.nodes.length === 0) {
+            return;
+        }
+        // Keep a shared priority queue of all txs pending to be requested, sorted by the number of attempts made to collect them.
+        const attemptsPerTx = [
+            ...request.missingTxHashes
+        ].map((txHash)=>({
+                txHash,
+                attempts: 0,
+                found: false
+            }));
+        // Returns once we have finished all node loops. Each loop finishes when the deadline is hit, or all txs have been collected.
+        await Promise.allSettled(this.nodes.map((node)=>this.collectFastFromNode(request, node, attemptsPerTx, opts)));
+    }
+    async collectFastFromNode(request, node, attemptsPerTx, opts) {
+        const notFinished = ()=>this.dateProvider.now() <= +opts.deadline && request.missingTxHashes.size > 0 && this.requests.has(request);
+        const maxParallelRequests = this.config.txCollectionFastMaxParallelRequestsPerNode;
+        const maxBatchSize = this.config.txCollectionNodeRpcMaxBatchSize;
+        const activeRequestsToThisNode = new Set(); // Track the txs being actively requested to this node
+        const processBatch = async ()=>{
+            while(notFinished()){
+                // Pull tx hashes from the attemptsPerTx array, which is sorted by attempts,
+                // so we prioritize txs that have been requested less often.
+                const batch = [];
+                let index = 0;
+                while(batch.length < maxBatchSize){
+                    const txToRequest = attemptsPerTx[index++];
+                    if (!txToRequest) {
+                        break;
+                    } else if (!request.missingTxHashes.has(txToRequest.txHash)) {
+                        // Mark as found if it was found somewhere else, we'll then remove it from the array.
+                        // We don't delete it now since 'array.splice' is pretty expensive, so we do it after sorting.
+                        txToRequest.found = true;
+                    } else if (!activeRequestsToThisNode.has(txToRequest.txHash)) {
+                        // If the tx is not alredy being requested to this node, add it to the current batch and increase attempts.
+                        // Note that we increase the attempts *before* making the request, so the next `collectFastFromNode` that
+                        // needs to grab txs to send, will pick txs that have been requested less often, instead of all requesting
+                        // the same txs at the same time.
+                        batch.push(txToRequest);
+                        activeRequestsToThisNode.add(txToRequest.txHash);
+                        txToRequest.attempts++;
+                    }
+                }
+                // After modifying the array by removing txs or updating attempts, re-sort it and trim the found txs from the end.
+                attemptsPerTx.sort((a, b)=>a.found === b.found ? a.attempts - b.attempts : Number(a.found) - Number(b.found));
+                const firstFoundTxIndex = attemptsPerTx.findIndex((tx)=>tx.found);
+                if (firstFoundTxIndex !== -1) {
+                    attemptsPerTx.length = firstFoundTxIndex;
+                }
+                // If we see no more txs to request, we can stop this "process" loop
+                if (batch.length === 0) {
+                    return;
+                }
+                // Collect this batch from the node
+                await this.txCollectionSink.collect((txHashes)=>node.getTxsByHash(txHashes), batch.map(({ txHash })=>TxHash.fromString(txHash)), {
+                    description: `fast ${node.getInfo()}`,
+                    node: node.getInfo(),
+                    method: 'fast-node-rpc',
+                    ...request.blockInfo
+                });
+                // Clear from the active requests the txs we just requested
+                for (const requestedTx of batch){
+                    activeRequestsToThisNode.delete(requestedTx.txHash);
+                }
+                // Sleep a bit until hitting the node again (or not, depending on config)
+                if (notFinished()) {
+                    await sleep(this.config.txCollectionFastNodeIntervalMs);
+                }
+            }
+        };
+        // Kick off N parallel requests to the node, up to the maxParallelRequests limit
+        await Promise.all(times(maxParallelRequests, processBatch));
+    }
+    async collectFastViaReqResp(request, opts) {
+        const timeoutMs = +request.deadline - this.dateProvider.now();
+        const pinnedPeer = opts.pinnedPeer;
+        const maxPeers = boundInclusive(Math.ceil(request.missingTxHashes.size / 2), 8, 32);
+        const maxRetryAttempts = 5;
+        const blockInfo = request.blockInfo;
+        const slotNumber = blockInfo.slotNumber;
+        if (timeoutMs < 100) {
+            this.log.warn(`Not initiating fast reqresp for txs for ${request.type} at slot ${blockInfo.slotNumber} due to timeout`, {
+                timeoutMs,
+                ...blockInfo
+            });
+            return;
+        }
+        this.log.debug(`Starting fast reqresp for ${request.missingTxHashes.size} txs for ${request.type} at slot ${blockInfo.slotNumber}`, {
+            ...blockInfo,
+            timeoutMs,
+            pinnedPeer
+        });
+        try {
+            await this.txCollectionSink.collect(async (txHashes)=>{
+                const txs = await this.reqResp.sendBatchRequest(ReqRespSubProtocol.TX, chunkTxHashesRequest(txHashes), pinnedPeer, timeoutMs, maxPeers, maxRetryAttempts);
+                return txs.flat();
+            }, Array.from(request.missingTxHashes).map((txHash)=>TxHash.fromString(txHash)), {
+                description: `reqresp for slot ${slotNumber}`,
+                method: 'fast-req-resp',
+                ...opts,
+                ...request.blockInfo
+            });
+        } catch (err) {
+            this.log.error(`Error sending fast reqresp request for txs`, err, {
+                txs: [
+                    ...request.missingTxHashes
+                ],
+                ...blockInfo
+            });
+        }
+    }
+    /**
+   * Handle txs by marking them as found for the requests that are waiting for them, and resolves the request if all its txs have been found.
+   * Called internally and from the main tx collection manager whenever the tx pool emits a tx-added event.
+   */ foundTxs(txs) {
+        for (const request of this.requests){
+            for (const tx of txs){
+                const txHash = tx.txHash.toString();
+                // Remove the tx hash from the missing set, and add it to the found set.
+                if (request.missingTxHashes.has(txHash)) {
+                    request.missingTxHashes.delete(txHash);
+                    request.foundTxs.set(txHash, tx);
+                    this.log.trace(`Found tx ${txHash} for fast collection request`, {
+                        ...request.blockInfo,
+                        txHash: tx.txHash.toString(),
+                        type: request.type
+                    });
+                    // If we found all txs for this request, we resolve the promise
+                    if (request.missingTxHashes.size === 0) {
+                        this.log.trace(`All txs found for fast collection request`, {
+                            ...request.blockInfo,
+                            type: request.type
+                        });
+                        request.promise.resolve();
+                    }
+                }
+            }
+        }
+    }
+    /**
+   * Stop collecting all txs for blocks less than or requal to the block number specified.
+   * To be called when we no longer care about gathering txs up to a certain block, eg when they become proven or finalized.
+   */ stopCollectingForBlocksUpTo(blockNumber) {
+        for (const request of this.requests){
+            if (request.blockInfo.blockNumber <= blockNumber) {
+                request.promise.reject(new AbortError(`Stopped collecting txs up to block ${blockNumber}`));
+                this.requests.delete(request);
+            }
+        }
+    }
+    /**
+   * Stop collecting all txs for blocks greater than the block number specified.
+   * To be called when there is a chain prune and previously mined txs are no longer relevant.
+   */ stopCollectingForBlocksAfter(blockNumber) {
+        for (const request of this.requests){
+            if (request.blockInfo.blockNumber > blockNumber) {
+                request.promise.reject(new AbortError(`Stopped collecting txs after block ${blockNumber}`));
+                this.requests.delete(request);
+            }
+        }
+    }
+}

package/dest/services/tx_collection/index.d.ts

@@ -0,0 +1,3 @@
+export { TxCollection, type FastCollectionRequestInput } from './tx_collection.js';
+export { type TxSource, createNodeRpcTxSources, NodeRpcTxSource } from './tx_source.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/services/tx_collection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,EAAE,KAAK,QAAQ,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dest/services/tx_collection/index.js

@@ -0,0 +1,2 @@
+export { TxCollection } from './tx_collection.js';
+export { createNodeRpcTxSources, NodeRpcTxSource } from './tx_source.js';

package/dest/services/tx_collection/instrumentation.d.ts

@@ -0,0 +1,10 @@
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { CollectionMethod } from './tx_collection.js';
+export declare class TxCollectionInstrumentation {
+    private txsCollected;
+    private collectionDurationPerTx;
+    private collectionDurationPerRequest;
+    constructor(client: TelemetryClient, name: string);
+    increaseTxsFor(what: CollectionMethod, count: number, duration: number): void;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/dest/services/tx_collection/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,qBAAa,2BAA2B;IACtC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,uBAAuB,CAAY;IAC3C,OAAO,CAAC,4BAA4B,CAAY;gBAEpC,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM;IAoBjD,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAMvE"}

package/dest/services/tx_collection/instrumentation.js

@@ -0,0 +1,34 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+export class TxCollectionInstrumentation {
+    txsCollected;
+    collectionDurationPerTx;
+    collectionDurationPerRequest;
+    constructor(client, name){
+        const meter = client.getMeter(name);
+        this.txsCollected = meter.createUpDownCounter(Metrics.TX_COLLECTOR_COUNT, {
+            description: 'The number of txs collected'
+        });
+        this.collectionDurationPerTx = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_TX, {
+            unit: 'ms',
+            description: 'Average duration per tx of an individual tx collection request',
+            valueType: ValueType.INT
+        });
+        this.collectionDurationPerRequest = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_REQUEST, {
+            unit: 'ms',
+            description: 'Total duration of an individual tx collection request',
+            valueType: ValueType.INT
+        });
+    }
+    increaseTxsFor(what, count, duration) {
+        const durationPerTx = Math.ceil(duration / count);
+        this.collectionDurationPerTx.record(durationPerTx, {
+            [Attributes.TX_COLLECTION_METHOD]: what
+        });
+        this.collectionDurationPerRequest.record(Math.ceil(duration), {
+            [Attributes.TX_COLLECTION_METHOD]: what
+        });
+        this.txsCollected.add(count, {
+            [Attributes.TX_COLLECTION_METHOD]: what
+        });
+    }
+}

package/dest/services/tx_collection/slow_tx_collection.d.ts

@@ -0,0 +1,54 @@
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { L2Block } from '@aztec/stdlib/block';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+import { type ReqRespInterface } from '../reqresp/interface.js';
+import type { TxCollectionConfig } from './config.js';
+import type { FastTxCollection } from './fast_tx_collection.js';
+import type { TxCollectionSink } from './tx_collection_sink.js';
+import type { TxSource } from './tx_source.js';
+export declare class SlowTxCollection {
+    private reqResp;
+    private nodes;
+    private txCollectionSink;
+    private fastCollection;
+    private constants;
+    private config;
+    private dateProvider;
+    private log;
+    /** Map from tx hash to missing tx info to collect via slow loop */
+    private missingTxs;
+    /** One slow collection loop for each node tx source we have */
+    private nodesSlowCollectionLoops;
+    /** Slow collection loop for reqresp which collects txs from peers */
+    private reqrespSlowCollectionLoop;
+    constructor(reqResp: Pick<ReqRespInterface, 'sendBatchRequest'>, nodes: TxSource[], txCollectionSink: TxCollectionSink, fastCollection: Pick<FastTxCollection, 'getFastCollectionRequests'>, constants: L1RollupConstants, config: TxCollectionConfig, dateProvider?: DateProvider, log?: Logger);
+    getMissingTxHashes(): TxHash[];
+    start(): void;
+    stop(): Promise<void>;
+    trigger(): Promise<void>;
+    /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
+    startCollecting(block: L2Block, txHashes: TxHash[]): void;
+    /** Entrypoint for the node slow collection loop */
+    private collectMissingTxsFromNode;
+    /** Entrypoint for the reqresp slow collection loop */
+    private collectMissingTxsViaReqResp;
+    /** Retrieves all missing txs for the slow collection process. This is, all missing txs that are not part of a fast request. */
+    private getMissingTxsForSlowCollection;
+    /** Stop collecting the given txs since we have found them. Called whenever tx pool emits a tx-added event. */
+    foundTxs(txs: Tx[]): void;
+    /**
+     * Stop collecting all txs for blocks less than or requal to the block number specified.
+     * To be called when we no longer care about gathering txs up to a certain block, eg when they become proven or finalized.
+     */
+    stopCollectingForBlocksUpTo(blockNumber: number): void;
+    /**
+     * Stop collecting all txs for blocks greater than the block number specified.
+     * To be called when there is a chain prune and previously mined txs are no longer relevant.
+     */
+    stopCollectingForBlocksAfter(blockNumber: number): void;
+    /** Computes the proof submission deadline for a given slot, a tx mined in this slot is no longer interesting after this deadline */
+    private getDeadlineForSlot;
+}
+//# sourceMappingURL=slow_tx_collection.d.ts.map

package/dest/services/tx_collection/slow_tx_collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slow_tx_collection.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/slow_tx_collection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAGlE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,KAAK,iBAAiB,EAA6C,MAAM,6BAA6B,CAAC;AAChH,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,KAAK,gBAAgB,EAAsB,MAAM,yBAAyB,CAAC;AAEpF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,qBAAa,gBAAgB;IAWzB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,GAAG;IAjBb,mEAAmE;IACnE,OAAO,CAAC,UAAU,CAAyC;IAE3D,+DAA+D;IAC/D,OAAO,CAAC,wBAAwB,CAAmB;IAEnD,qEAAqE;IACrE,OAAO,CAAC,yBAAyB,CAAiB;gBAGxC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,EACnD,KAAK,EAAE,QAAQ,EAAE,EACjB,gBAAgB,EAAE,gBAAgB,EAClC,cAAc,EAAE,IAAI,CAAC,gBAAgB,EAAE,2BAA2B,CAAC,EACnE,SAAS,EAAE,iBAAiB,EAC5B,MAAM,EAAE,kBAAkB,EAC1B,YAAY,GAAE,YAAiC,EAC/C,GAAG,GAAE,MAAkD;IAkB1D,kBAAkB;IAIlB,KAAK;IAKC,IAAI;IAOJ,OAAO;IAOpB,mFAAmF;IAC5E,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE;IAsBzD,mDAAmD;YACrC,yBAAyB;IAgCvC,sDAAsD;YACxC,2BAA2B;IAsCzC,+HAA+H;IAC/H,OAAO,CAAC,8BAA8B;IAqBtC,8GAA8G;IACvG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,IAAI;IAMhC;;;OAGG;IACI,2BAA2B,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAQ7D;;;OAGG;IACI,4BAA4B,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAQ9D,oIAAoI;IACpI,OAAO,CAAC,kBAAkB;CAM3B"}