@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/dest/services/tx_collection/slow_tx_collection.js

@@ -0,0 +1,177 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { chunk } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { boundInclusive } from '@aztec/foundation/number';
+import { RunningPromise } from '@aztec/foundation/promise';
+import { DateProvider } from '@aztec/foundation/timer';
+import { getEpochAtSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { TxHash } from '@aztec/stdlib/tx';
+import { ReqRespSubProtocol } from '../reqresp/interface.js';
+import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
+export class SlowTxCollection {
+    reqResp;
+    nodes;
+    txCollectionSink;
+    fastCollection;
+    constants;
+    config;
+    dateProvider;
+    log;
+    /** Map from tx hash to missing tx info to collect via slow loop */ missingTxs;
+    /** One slow collection loop for each node tx source we have */ nodesSlowCollectionLoops;
+    /** Slow collection loop for reqresp which collects txs from peers */ reqrespSlowCollectionLoop;
+    constructor(reqResp, nodes, txCollectionSink, fastCollection, constants, config, dateProvider = new DateProvider(), log = createLogger('p2p:tx_collection_service')){
+        this.reqResp = reqResp;
+        this.nodes = nodes;
+        this.txCollectionSink = txCollectionSink;
+        this.fastCollection = fastCollection;
+        this.constants = constants;
+        this.config = config;
+        this.dateProvider = dateProvider;
+        this.log = log;
+        this.missingTxs = new Map();
+        this.nodesSlowCollectionLoops = this.nodes.map((node)=>new RunningPromise(()=>this.collectMissingTxsFromNode(node), this.log, this.config.txCollectionSlowNodesIntervalMs));
+        this.reqrespSlowCollectionLoop = new RunningPromise(()=>this.collectMissingTxsViaReqResp(), this.log, this.config.txCollectionSlowReqRespIntervalMs);
+    }
+    getMissingTxHashes() {
+        return Array.from(this.missingTxs.keys()).map(TxHash.fromString);
+    }
+    start() {
+        this.nodesSlowCollectionLoops.forEach((loop)=>loop.start());
+        this.reqrespSlowCollectionLoop.start();
+    }
+    async stop() {
+        await Promise.all([
+            this.reqrespSlowCollectionLoop.stop(),
+            ...this.nodesSlowCollectionLoops.map((loop)=>loop.stop())
+        ]);
+    }
+    async trigger() {
+        await Promise.all([
+            this.reqrespSlowCollectionLoop.trigger(),
+            ...this.nodesSlowCollectionLoops.map((loop)=>loop.trigger())
+        ]);
+    }
+    /** Starts collecting the given tx hashes for the given L2Block in the slow loop */ startCollecting(block, txHashes) {
+        const slot = block.header.getSlot();
+        const deadline = this.getDeadlineForSlot(slot);
+        if (+deadline < this.dateProvider.now()) {
+            this.log.debug(`Skipping collection of txs for block ${block.number} at slot ${slot} as it is already expired`, {
+                blockNumber: block.number,
+                slot: slot.toString(),
+                txHashes: txHashes.map((txHash)=>txHash.toString()),
+                deadline: +deadline,
+                now: this.dateProvider.now()
+            });
+        }
+        for (const txHash of txHashes){
+            this.missingTxs.set(txHash.toString(), {
+                blockNumber: block.number,
+                deadline: this.getDeadlineForSlot(block.header.getSlot()),
+                readyForReqResp: this.nodes.length === 0
+            });
+        }
+    }
+    /** Entrypoint for the node slow collection loop */ async collectMissingTxsFromNode(node) {
+        // If we have any fast requests, we skip the slow collection for this node if configured to do so
+        const requests = this.fastCollection.getFastCollectionRequests();
+        if (this.config.txCollectionDisableSlowDuringFastRequests && requests.size > 0) {
+            this.log.trace(`Skipping node slow collection due to active fast requests`);
+            return;
+        }
+        // Gather all missing txs that are not in fast collection and request them from the node
+        const missingTxs = this.getMissingTxsForSlowCollection();
+        const missingTxHashes = missingTxs.map(([txHash])=>txHash).map(TxHash.fromString);
+        if (missingTxHashes.length === 0) {
+            return;
+        }
+        // Request in chunks to avoid hitting RPC limits
+        for (const batch of chunk(missingTxHashes, this.config.txCollectionNodeRpcMaxBatchSize)){
+            await this.txCollectionSink.collect((txHashes)=>node.getTxsByHash(txHashes), batch, {
+                description: `node ${node.getInfo()}`,
+                node: node.getInfo(),
+                method: 'slow-node-rpc'
+            });
+        }
+        // Mark every tx that is still missing as ready for reqresp.
+        // Note that we can just mark all requested txs as ready for reqresp, without filtering out the ones
+        // we retrieved, since the ones already found will have been removed from `missingTxs`.
+        missingTxs.forEach(([_txHash, info])=>{
+            info.readyForReqResp = true;
+        });
+    }
+    /** Entrypoint for the reqresp slow collection loop */ async collectMissingTxsViaReqResp() {
+        // If we have any fast requests, we skip the slow collection if configured to do so
+        const requests = this.fastCollection.getFastCollectionRequests();
+        if (this.config.txCollectionDisableSlowDuringFastRequests && requests.size > 0) {
+            this.log.trace(`Skipping reqresp slow collection due to active fast requests`);
+            return;
+        }
+        // Gather all missing txs that are not in fast collection and are ready for reqresp
+        // A tx is flagged as ready for reqresp if it has been requested from a node at least once
+        const missingTxs = this.getMissingTxsForSlowCollection({
+            onlyReqRespReady: true
+        });
+        if (missingTxs.length === 0) {
+            return;
+        }
+        const pinnedPeer = undefined;
+        const timeoutMs = this.config.txCollectionSlowReqRespTimeoutMs;
+        const maxPeers = boundInclusive(Math.ceil(missingTxs.length / 3), 4, 16);
+        const maxRetryAttempts = 3;
+        // Send a batch request via reqresp for the missing txs
+        await this.txCollectionSink.collect(async (txHashes)=>{
+            const txs = await this.reqResp.sendBatchRequest(ReqRespSubProtocol.TX, chunkTxHashesRequest(txHashes), pinnedPeer, timeoutMs, maxPeers, maxRetryAttempts);
+            return txs.flat();
+        }, missingTxs.map(([txHash])=>TxHash.fromString(txHash)), {
+            description: 'slow reqresp',
+            timeoutMs,
+            method: 'slow-req-resp'
+        });
+    }
+    /** Retrieves all missing txs for the slow collection process. This is, all missing txs that are not part of a fast request. */ getMissingTxsForSlowCollection(opts = {}) {
+        // Remove expired txs from missingTxs
+        const now = this.dateProvider.now();
+        const expiredTxs = Array.from(this.missingTxs.entries()).filter(([_, value])=>+value.deadline < now);
+        expiredTxs.forEach(([txHash])=>this.missingTxs.delete(txHash));
+        // Gather all txs that are marked for fast collection, we do not want to collect them via slow collection.
+        // There are some situations where a tx is in both slow and fast collection, for example when a prover node
+        // is fast-collecting missing txs for proving an epoch, and still has the tx in the slow collection loops
+        // from mined unproven blocks it has seen in the past.
+        const fastRequests = this.fastCollection.getFastCollectionRequests();
+        const fastCollectionTxs = new Set(...Array.from(fastRequests.values()).flatMap((r)=>r.missingTxHashes));
+        // Return all missing txs that are not in fastCollectionTxs and are ready for reqresp if requested
+        return Array.from(this.missingTxs.entries()).filter(([txHash, _])=>!fastCollectionTxs.has(txHash)).filter(([_, value])=>!opts.onlyReqRespReady || value.readyForReqResp);
+    }
+    /** Stop collecting the given txs since we have found them. Called whenever tx pool emits a tx-added event. */ foundTxs(txs) {
+        for (const txHash of txs.map((tx)=>tx.txHash)){
+            this.missingTxs.delete(txHash.toString());
+        }
+    }
+    /**
+   * 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 [txHash, info] of this.missingTxs.entries()){
+            if (info.blockNumber <= blockNumber) {
+                this.missingTxs.delete(txHash);
+            }
+        }
+    }
+    /**
+   * 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 [txHash, info] of this.missingTxs.entries()){
+            if (info.blockNumber > blockNumber) {
+                this.missingTxs.delete(txHash);
+            }
+        }
+    }
+    /** Computes the proof submission deadline for a given slot, a tx mined in this slot is no longer interesting after this deadline */ getDeadlineForSlot(slotNumber) {
+        const epoch = getEpochAtSlot(slotNumber, this.constants);
+        const submissionEndEpoch = EpochNumber(epoch + this.constants.proofSubmissionEpochs);
+        const submissionEndTimestamp = getTimestampRangeForEpoch(submissionEndEpoch, this.constants)[1];
+        return new Date(Number(submissionEndTimestamp) * 1000);
+    }
+}

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

@@ -0,0 +1,110 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger } from '@aztec/foundation/log';
+import { type PromiseWithResolvers } from '@aztec/foundation/promise';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { PeerId } from '@libp2p/interface';
+import type { TxPool } from '../../mem_pools/index.js';
+import type { TxPoolEvents } from '../../mem_pools/tx_pool/tx_pool.js';
+import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
+import type { TxCollectionConfig } from './config.js';
+import { FastTxCollection } from './fast_tx_collection.js';
+import { SlowTxCollection } from './slow_tx_collection.js';
+import type { TxSource } from './tx_source.js';
+export type CollectionMethod = 'fast-req-resp' | 'fast-node-rpc' | 'slow-req-resp' | 'slow-node-rpc';
+export type MissingTxInfo = {
+    blockNumber: BlockNumber;
+    deadline: Date;
+    readyForReqResp: boolean;
+};
+export type FastCollectionRequestInput = {
+    type: 'block';
+    block: L2Block;
+} | {
+    type: 'proposal';
+    blockProposal: BlockProposal;
+    blockNumber: BlockNumber;
+};
+export type FastCollectionRequest = FastCollectionRequestInput & {
+    missingTxHashes: Set<string>;
+    deadline: Date;
+    blockInfo: L2BlockInfo;
+    promise: PromiseWithResolvers<void>;
+    foundTxs: Map<string, Tx>;
+};
+/**
+ * Coordinates tx collection from remote RPC nodes and reqresp.
+ *
+ * The slow collection loops are used for periodically collecting missing txs from mined blocks,
+ * from remote RPC nodes and via reqresp. The fast collection methods are used to quickly gather
+ * txs, usually for attesting to block proposals or preparing to prove an epoch. The slow and fast
+ * collection instances both send their txs to the collection sink, which handles metrics and adds
+ * them to the tx pool. Whenever a tx is added to either the sink or the pool, this service is notified
+ * via events and notifies the slow and fast collection loops to stop collecting that tx, so that we don't
+ * collect the same tx multiple times.
+ */
+export declare class TxCollection {
+    private readonly p2pService;
+    private readonly nodes;
+    private readonly constants;
+    private readonly txPool;
+    private readonly config;
+    private readonly dateProvider;
+    private readonly log;
+    /** Slow collection background loops */
+    protected readonly slowCollection: SlowTxCollection;
+    /** Fast collection methods */
+    protected readonly fastCollection: FastTxCollection;
+    /** Loop for periodically reconciling found transactions from the tx pool in case we missed some */
+    private readonly reconcileFoundTxsLoop;
+    /** Handles txs found by the slow and fast collection loops */
+    private readonly txCollectionSink;
+    /** Handler for the txs-added event from the tx pool */
+    protected readonly handleTxsAddedToPool: TxPoolEvents['txs-added'];
+    /** Handler for the txs-added event from the tx collection sink */
+    protected readonly handleTxsFound: TxPoolEvents['txs-added'];
+    constructor(p2pService: BatchTxRequesterLibP2PService, nodes: TxSource[], constants: L1RollupConstants, txPool: TxPool, config: TxCollectionConfig, dateProvider?: DateProvider, telemetryClient?: TelemetryClient, log?: Logger);
+    /** Starts all collection loops. */
+    start(): Promise<void>;
+    /** Stops all activity. */
+    stop(): Promise<void>;
+    /** Force trigger the slow collection and reconciliation loops */
+    trigger(): Promise<void>;
+    /** Returns L1 rollup constants. */
+    getConstants(): L1RollupConstants;
+    /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
+    startCollecting(block: L2Block, txHashes: TxHash[]): void;
+    /** Collects the set of txs for the given block proposal as fast as possible */
+    collectFastForProposal(blockProposal: BlockProposal, blockNumber: BlockNumber, txHashes: TxHash[] | string[], opts: {
+        deadline: Date;
+        pinnedPeer?: PeerId;
+    }): Promise<Tx[]>;
+    /** Collects the set of txs for the given mined block as fast as possible */
+    collectFastForBlock(block: L2Block, txHashes: TxHash[] | string[], opts: {
+        deadline: Date;
+        pinnedPeer?: PeerId;
+    }): Promise<Tx[]>;
+    /** Collects the set of txs for the given proposal or block as fast as possible */
+    collectFastFor(input: FastCollectionRequestInput, txHashes: TxHash[] | string[], opts: {
+        deadline: Date;
+        pinnedPeer?: PeerId;
+    }): Promise<Tx[]>;
+    /** Mark the given txs as found. Stops collecting them. */
+    private foundTxs;
+    /**
+     * 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: BlockNumber): 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: BlockNumber): void;
+    private reconcileFoundTxsWithPool;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_collection.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/tx_collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,KAAK,oBAAoB,EAAkB,MAAM,2BAA2B,CAAC;AACtF,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAChG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,eAAe,GAAG,eAAe,GAAG,eAAe,CAAC;AAErG,MAAM,MAAM,aAAa,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAAC;AAEnG,MAAM,MAAM,0BAA0B,GAClC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,aAAa,EAAE,aAAa,CAAC;IAAC,WAAW,EAAE,WAAW,CAAA;CAAE,CAAC;AAEjF,MAAM,MAAM,qBAAqB,GAAG,0BAA0B,GAAG;IAC/D,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,QAAQ,EAAE,IAAI,CAAC;IACf,SAAS,EAAE,WAAW,CAAC;IACvB,OAAO,EAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACpC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IAoBrB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAE7B,OAAO,CAAC,QAAQ,CAAC,GAAG;IA1BtB,uCAAuC;IACvC,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,gBAAgB,CAAC;IAEpD,8BAA8B;IAC9B,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,gBAAgB,CAAC;IAEpD,mGAAmG;IACnG,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IAEpD,uDAAuD;IACvD,SAAS,CAAC,QAAQ,CAAC,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;IAEnE,kEAAkE;IAClE,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;IAE7D,YACmB,UAAU,EAAE,6BAA6B,EACzC,KAAK,EAAE,QAAQ,EAAE,EACjB,SAAS,EAAE,iBAAiB,EAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,kBAAkB,EAC1B,YAAY,GAAE,YAAiC,EAChE,eAAe,GAAE,eAAsC,EACtC,GAAG,GAAE,MAAkD,EA0CzE;IAED,mCAAmC;IAC5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAM5B;IAED,0BAA0B;IACb,IAAI,kBAKhB;IAED,iEAAiE;IACpD,OAAO,kBAEnB;IAED,mCAAmC;IAC5B,YAAY,IAAI,iBAAiB,CAEvC;IAED,mFAAmF;IAC5E,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAExD;IAED,+EAA+E;IACxE,sBAAsB,CAC3B,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAC7B,IAAI,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,iBAG9C;IAED,4EAA4E;IACrE,mBAAmB,CACxB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAC7B,IAAI,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,iBAG9C;IAED,kFAAkF;IAC3E,cAAc,CACnB,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,iBAG9C;IAED,0DAA0D;IAC1D,OAAO,CAAC,QAAQ;IAKhB;;;OAGG;IACI,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAGjE;IAED;;;OAGG;IACI,4BAA4B,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAGlE;YAGa,yBAAyB;CAUxC"}

package/dest/services/tx_collection/tx_collection.js

@@ -0,0 +1,128 @@
+import { compactArray } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+import { DateProvider } from '@aztec/foundation/timer';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { FastTxCollection } from './fast_tx_collection.js';
+import { SlowTxCollection } from './slow_tx_collection.js';
+import { TxCollectionSink } from './tx_collection_sink.js';
+/**
+ * Coordinates tx collection from remote RPC nodes and reqresp.
+ *
+ * The slow collection loops are used for periodically collecting missing txs from mined blocks,
+ * from remote RPC nodes and via reqresp. The fast collection methods are used to quickly gather
+ * txs, usually for attesting to block proposals or preparing to prove an epoch. The slow and fast
+ * collection instances both send their txs to the collection sink, which handles metrics and adds
+ * them to the tx pool. Whenever a tx is added to either the sink or the pool, this service is notified
+ * via events and notifies the slow and fast collection loops to stop collecting that tx, so that we don't
+ * collect the same tx multiple times.
+ */ export class TxCollection {
+    p2pService;
+    nodes;
+    constants;
+    txPool;
+    config;
+    dateProvider;
+    log;
+    /** Slow collection background loops */ slowCollection;
+    /** Fast collection methods */ fastCollection;
+    /** Loop for periodically reconciling found transactions from the tx pool in case we missed some */ reconcileFoundTxsLoop;
+    /** Handles txs found by the slow and fast collection loops */ txCollectionSink;
+    /** Handler for the txs-added event from the tx pool */ handleTxsAddedToPool;
+    /** Handler for the txs-added event from the tx collection sink */ handleTxsFound;
+    constructor(p2pService, nodes, constants, txPool, config, dateProvider = new DateProvider(), telemetryClient = getTelemetryClient(), log = createLogger('p2p:tx_collection_service')){
+        this.p2pService = p2pService;
+        this.nodes = nodes;
+        this.constants = constants;
+        this.txPool = txPool;
+        this.config = config;
+        this.dateProvider = dateProvider;
+        this.log = log;
+        this.txCollectionSink = new TxCollectionSink(this.txPool, telemetryClient, this.log);
+        this.fastCollection = new FastTxCollection(this.p2pService, this.nodes, this.txCollectionSink, this.config, this.dateProvider, this.log);
+        this.slowCollection = new SlowTxCollection(this.p2pService.reqResp, this.nodes, this.txCollectionSink, this.fastCollection, constants, this.config, this.dateProvider, this.log);
+        this.reconcileFoundTxsLoop = new RunningPromise(()=>this.reconcileFoundTxsWithPool(), this.log, this.config.txCollectionReconcileIntervalMs);
+        this.handleTxsFound = (args)=>{
+            this.foundTxs(args.txs);
+        };
+        this.txCollectionSink.on('txs-added', this.handleTxsFound);
+        this.handleTxsAddedToPool = (args)=>{
+            const { txs, source } = args;
+            if (source !== 'tx-collection') {
+                this.foundTxs(txs);
+            }
+        };
+        this.txPool.on('txs-added', this.handleTxsAddedToPool);
+    }
+    /** Starts all collection loops. */ start() {
+        this.slowCollection.start();
+        this.reconcileFoundTxsLoop.start();
+        // TODO(palla/txs): Collect mined unproven tx hashes for txs we dont have in the pool and populate missingTxs on startup
+        return Promise.resolve();
+    }
+    /** Stops all activity. */ async stop() {
+        await Promise.all([
+            this.slowCollection.stop(),
+            this.fastCollection.stop(),
+            this.reconcileFoundTxsLoop.stop()
+        ]);
+        this.txPool.removeListener('txs-added', this.handleTxsAddedToPool);
+        this.txCollectionSink.removeListener('txs-added', this.handleTxsFound);
+    }
+    /** Force trigger the slow collection and reconciliation loops */ async trigger() {
+        await Promise.all([
+            this.reconcileFoundTxsLoop.trigger(),
+            this.slowCollection.trigger()
+        ]);
+    }
+    /** Returns L1 rollup constants. */ getConstants() {
+        return this.constants;
+    }
+    /** Starts collecting the given tx hashes for the given L2Block in the slow loop */ startCollecting(block, txHashes) {
+        return this.slowCollection.startCollecting(block, txHashes);
+    }
+    /** Collects the set of txs for the given block proposal as fast as possible */ collectFastForProposal(blockProposal, blockNumber, txHashes, opts) {
+        return this.collectFastFor({
+            type: 'proposal',
+            blockProposal,
+            blockNumber
+        }, txHashes, opts);
+    }
+    /** Collects the set of txs for the given mined block as fast as possible */ collectFastForBlock(block, txHashes, opts) {
+        return this.collectFastFor({
+            type: 'block',
+            block
+        }, txHashes, opts);
+    }
+    /** Collects the set of txs for the given proposal or block as fast as possible */ collectFastFor(input, txHashes, opts) {
+        return this.fastCollection.collectFastFor(input, txHashes, opts);
+    }
+    /** Mark the given txs as found. Stops collecting them. */ foundTxs(txs) {
+        this.slowCollection.foundTxs(txs);
+        this.fastCollection.foundTxs(txs);
+    }
+    /**
+   * 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) {
+        this.slowCollection.stopCollectingForBlocksUpTo(blockNumber);
+        this.fastCollection.stopCollectingForBlocksUpTo(blockNumber);
+    }
+    /**
+   * 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) {
+        this.slowCollection.stopCollectingForBlocksAfter(blockNumber);
+        this.fastCollection.stopCollectingForBlocksAfter(blockNumber);
+    }
+    /** Every now and then, check if the pool has received one of the txs we are looking for, just to catch any race conditions */ async reconcileFoundTxsWithPool() {
+        const missingTxHashes = this.slowCollection.getMissingTxHashes();
+        const foundTxs = compactArray(await this.txPool.getTxsByHash(missingTxHashes));
+        if (foundTxs.length > 0) {
+            this.log.verbose(`Found ${foundTxs.length} txs in the pool during reconciliation`, {
+                foundTxs: foundTxs.map((t)=>t.getTxHash().toString())
+            });
+            this.foundTxs(foundTxs);
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
+import { Tx, type TxHash } from '@aztec/stdlib/tx';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+import type { TxPool, TxPoolEvents } from '../../mem_pools/tx_pool/tx_pool.js';
+import type { CollectionMethod } from './tx_collection.js';
+declare const TxCollectionSink_base: new () => TypedEventEmitter<TxPoolEvents>;
+/**
+ * Executes collection requests from the fast and slow collection loops, and handles collected txs
+ * by adding them to the tx pool and emitting events, as well as handling logging and metrics.
+ */
+export declare class TxCollectionSink extends TxCollectionSink_base {
+    private readonly txPool;
+    private readonly log;
+    private readonly instrumentation;
+    constructor(txPool: TxPool, telemetryClient: TelemetryClient, log: Logger);
+    collect(collectValidTxsFn: (txHashes: TxHash[]) => Promise<(Tx | undefined)[]>, requested: TxHash[], info: Record<string, any> & {
+        description: string;
+        method: CollectionMethod;
+    }): Promise<{
+        txs: Tx[];
+        requested: TxHash[];
+        duration: number;
+    } | {
+        txs: Tx[];
+    }>;
+    private foundTxs;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfY29sbGVjdGlvbl9zaW5rLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvdHhfY29sbGVjdGlvbi90eF9jb2xsZWN0aW9uX3NpbmsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsRUFBRSxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFJL0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRS9FLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBRTNEOzs7R0FHRztBQUNILHFCQUFhLGdCQUFpQixTQUFRLHFCQUEyRDtJQUk3RixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFFdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHO0lBTHRCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUE4QjtJQUU5RCxZQUNtQixNQUFNLEVBQUUsTUFBTSxFQUMvQixlQUFlLEVBQUUsZUFBZSxFQUNmLEdBQUcsRUFBRSxNQUFNLEVBSTdCO0lBRVksT0FBTyxDQUNsQixpQkFBaUIsRUFBRSxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsS0FBSyxPQUFPLENBQUMsQ0FBQyxFQUFFLEdBQUcsU0FBUyxDQUFDLEVBQUUsQ0FBQyxFQUN0RSxTQUFTLEVBQUUsTUFBTSxFQUFFLEVBQ25CLElBQUksRUFBRSxNQUFNLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxHQUFHO1FBQUUsV0FBVyxFQUFFLE1BQU0sQ0FBQztRQUFDLE1BQU0sRUFBRSxnQkFBZ0IsQ0FBQTtLQUFFOzs7Ozs7T0F1RTlFO1lBRWEsUUFBUTtDQXdCdkIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_collection_sink.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/tx_collection_sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAI/D,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAE/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;;AAE3D;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,qBAA2D;IAI7F,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IALtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA8B;IAE9D,YACmB,MAAM,EAAE,MAAM,EAC/B,eAAe,EAAE,eAAe,EACf,GAAG,EAAE,MAAM,EAI7B;IAEY,OAAO,CAClB,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC,EACtE,SAAS,EAAE,MAAM,EAAE,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,gBAAgB,CAAA;KAAE;;;;;;OAuE9E;YAEa,QAAQ;CAwBvB"}

package/dest/services/tx_collection/tx_collection_sink.js

@@ -0,0 +1,111 @@
+import { elapsed } from '@aztec/foundation/timer';
+import EventEmitter from 'node:events';
+import { TxCollectionInstrumentation } from './instrumentation.js';
+/**
+ * Executes collection requests from the fast and slow collection loops, and handles collected txs
+ * by adding them to the tx pool and emitting events, as well as handling logging and metrics.
+ */ export class TxCollectionSink extends EventEmitter {
+    txPool;
+    log;
+    instrumentation;
+    constructor(txPool, telemetryClient, log){
+        super(), this.txPool = txPool, this.log = log;
+        this.instrumentation = new TxCollectionInstrumentation(telemetryClient, 'TxCollection');
+    }
+    async collect(collectValidTxsFn, requested, info) {
+        this.log.trace(`Requesting ${requested.length} txs via ${info.description}`, {
+            ...info,
+            requestedTxs: requested.map((t)=>t.toString())
+        });
+        // Execute collection function and measure the time taken, catching any errors.
+        const [duration, txs] = await elapsed(async ()=>{
+            try {
+                const response = await collectValidTxsFn(requested);
+                return response.filter((tx)=>tx !== undefined);
+            } catch (err) {
+                this.log.error(`Error collecting txs via ${info.description}`, err, {
+                    ...info,
+                    requestedTxs: requested.map((hash)=>hash.toString())
+                });
+                return [];
+            }
+        });
+        if (txs.length === 0) {
+            this.log.trace(`No txs found via ${info.description}`, {
+                ...info,
+                requestedTxs: requested.map((t)=>t.toString())
+            });
+            return {
+                txs,
+                requested,
+                duration
+            };
+        }
+        // Validate tx hashes for all collected txs from external sources
+        const validTxs = [];
+        const invalidTxHashes = [];
+        await Promise.all(txs.map(async (tx)=>{
+            const isValid = await tx.validateTxHash();
+            if (isValid) {
+                validTxs.push(tx);
+            } else {
+                invalidTxHashes.push(tx.getTxHash().toString());
+            }
+        }));
+        if (invalidTxHashes.length > 0) {
+            this.log.warn(`Rejecting ${invalidTxHashes.length} txs with invalid hashes from ${info.description}`, {
+                ...info,
+                invalidTxHashes
+            });
+        }
+        if (validTxs.length === 0) {
+            this.log.trace(`No valid txs found via ${info.description} after validation`, {
+                ...info,
+                requestedTxs: requested.map((t)=>t.toString()),
+                invalidTxHashes
+            });
+            return {
+                txs: [],
+                requested,
+                duration
+            };
+        }
+        this.log.verbose(`Collected ${validTxs.length} txs out of ${requested.length} requested via ${info.description} in ${duration}ms`, {
+            ...info,
+            duration,
+            txs: validTxs.map((t)=>t.getTxHash().toString()),
+            requestedTxs: requested.map((t)=>t.toString()),
+            rejectedCount: invalidTxHashes.length
+        });
+        return await this.foundTxs(validTxs, {
+            ...info,
+            duration
+        });
+    }
+    async foundTxs(txs, info) {
+        // Report metrics for the collection
+        this.instrumentation.increaseTxsFor(info.method, txs.length, info.duration);
+        // Mark txs as found in the slow missing txs set and all fast requests
+        this.emit('txs-added', {
+            txs
+        });
+        // Add the txs to the tx pool (should not fail, but we catch it just in case)
+        try {
+            await this.txPool.addTxs(txs, {
+                source: `tx-collection`
+            });
+        } catch (err) {
+            this.log.error(`Error adding txs to the pool via ${info.description}`, err, {
+                ...info,
+                txs: txs.map((tx)=>tx.txHash.toString())
+            });
+            // Return no txs since none have been added
+            return {
+                txs: []
+            };
+        }
+        return {
+            txs
+        };
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { ChainConfig } from '@aztec/stdlib/config';
+import { type AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type ComponentsVersions } from '@aztec/stdlib/versioning';
+export interface TxSource {
+    getInfo(): string;
+    getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+}
+export declare class NodeRpcTxSource implements TxSource {
+    private readonly client;
+    private readonly info;
+    constructor(client: Pick<AztecNode, 'getTxsByHash'>, info: string);
+    static fromUrl(nodeUrl: string, versions: ComponentsVersions): NodeRpcTxSource;
+    getInfo(): string;
+    getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+}
+export declare function createNodeRpcTxSources(urls: string[], chainConfig: ChainConfig): NodeRpcTxSource[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfc291cmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvdHhfY29sbGVjdGlvbi90eF9zb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUF5QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3hGLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsS0FBSyxrQkFBa0IsRUFBbUMsTUFBTSwwQkFBMEIsQ0FBQztBQUdwRyxNQUFNLFdBQVcsUUFBUTtJQUN2QixPQUFPLElBQUksTUFBTSxDQUFDO0lBQ2xCLFlBQVksQ0FBQyxRQUFRLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDLENBQUMsRUFBRSxHQUFHLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQztDQUMvRDtBQUVELHFCQUFhLGVBQWdCLFlBQVcsUUFBUTtJQUU1QyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJO0lBRnZCLFlBQ21CLE1BQU0sRUFBRSxJQUFJLENBQUMsU0FBUyxFQUFFLGNBQWMsQ0FBQyxFQUN2QyxJQUFJLEVBQUUsTUFBTSxFQUMzQjtJQUVKLE9BQWMsT0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLGtCQUFrQixHQUFHLGVBQWUsQ0FHcEY7SUFFTSxPQUFPLFdBRWI7SUFFTSxZQUFZLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxDQUFDLEVBQUUsR0FBRyxTQUFTLENBQUMsRUFBRSxDQUFDLENBRW5FO0NBQ0Y7QUFFRCx3QkFBZ0Isc0JBQXNCLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxFQUFFLFdBQVcsRUFBRSxXQUFXLHFCQUc5RSJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_source.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/tx_source.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,KAAK,SAAS,EAAyB,MAAM,iCAAiC,CAAC;AACxF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,KAAK,kBAAkB,EAAmC,MAAM,0BAA0B,CAAC;AAGpG,MAAM,WAAW,QAAQ;IACvB,OAAO,IAAI,MAAM,CAAC;IAClB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;CAC/D;AAED,qBAAa,eAAgB,YAAW,QAAQ;IAE5C,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFvB,YACmB,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,EACvC,IAAI,EAAE,MAAM,EAC3B;IAEJ,OAAc,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,GAAG,eAAe,CAGpF;IAEM,OAAO,WAEb;IAEM,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC,CAEnE;CACF;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,WAAW,qBAG9E"}

package/dest/services/tx_collection/tx_source.js

@@ -0,0 +1,31 @@
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
+import { makeTracedFetch } from '@aztec/telemetry-client';
+export class NodeRpcTxSource {
+    client;
+    info;
+    constructor(client, info){
+        this.client = client;
+        this.info = info;
+    }
+    static fromUrl(nodeUrl, versions) {
+        const client = createAztecNodeClient(nodeUrl, versions, makeTracedFetch([
+            1,
+            2,
+            3
+        ], false));
+        return new NodeRpcTxSource(client, nodeUrl);
+    }
+    getInfo() {
+        return this.info;
+    }
+    getTxsByHash(txHashes) {
+        return this.client.getTxsByHash(txHashes);
+    }
+}
+export function createNodeRpcTxSources(urls, chainConfig) {
+    const versions = getComponentsVersionsFromConfig(chainConfig, protocolContractsHash, getVKTreeRoot());
+    return urls.map((url)=>NodeRpcTxSource.fromUrl(url, versions));
+}