@aztec/p2p 0.0.1-commit.86469d5 → 0.0.1-commit.8655d4a

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts

@@ -1,64 +0,0 @@
-import type { PeerId } from '@libp2p/interface';
-import type { ConnectionSampler } from './connection_sampler.js';
-/**
- * Manages batches of peers for parallel request processing.
- * Tracks active peers and provides deterministic peer assignment for requests.
- *
- * Example with 3 peers and 10 requests:
- *
- * Peers:    [P1]      [P2]     [P3]
- *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
- * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
- *
- * Each peer handles a bucket of consecutive requests.
- * If a peer fails, it is replaced while maintaining the same bucket.
- */
-export declare class BatchConnectionSampler {
-    private readonly connectionSampler;
-    private readonly logger;
-    private readonly batch;
-    private readonly requestsPerPeer;
-    /** Tracks peer-index combinations that returned empty/invalid responses */
-    private readonly failedPeerIndices;
-    constructor(connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number, exclude?: PeerId[], logger?: import("@aztec/foundation/log").Logger);
-    /**
-     * Gets the peer responsible for handling a specific request index.
-     * If the primary peer has previously failed for this index, tries other peers.
-     * If all batch peers have failed, attempts to sample a new peer.
-     *
-     * @param index - The request index
-     * @returns The peer assigned to handle this request, or undefined if no peer available
-     */
-    getPeerForRequest(index: number): PeerId | undefined;
-    /**
-     * Attempts to sample a new peer that isn't already in the batch.
-     * If successful, adds the peer to the batch.
-     *
-     * @returns The new peer if one was sampled, undefined otherwise
-     */
-    private sampleNewPeer;
-    /**
-     * Marks that a peer returned an empty/invalid response for a specific request index.
-     * The peer will not be assigned this index again.
-     *
-     * @param peerId - The peer that failed
-     * @param index - The request index that failed
-     */
-    markPeerFailedForIndex(peerId: PeerId, index: number): void;
-    /**
-     * Removes a peer and replaces it with a new one, maintaining the same position
-     * in the batch array to keep request distribution consistent
-     *
-     * @param peerId - The peer to remove and replace
-     */
-    removePeerAndReplace(peerId: PeerId): void;
-    /**
-     * Gets the number of active peers
-     */
-    get activePeerCount(): number;
-    /**
-     * Gets the number of requests each peer is assigned to handle
-     */
-    get requestsPerBucket(): number;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF0Y2hfY29ubmVjdGlvbl9zYW1wbGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9jb25uZWN0aW9uLXNhbXBsZXIvYmF0Y2hfY29ubmVjdGlvbl9zYW1wbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWhELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFakU7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gscUJBQWEsc0JBQXNCO0lBTy9CLE9BQU8sQ0FBQyxRQUFRLENBQUMsaUJBQWlCO0lBSWxDLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQVZ6QixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBZ0I7SUFDdEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQVM7SUFDekMsMkVBQTJFO0lBQzNFLE9BQU8sQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQXVDO0lBRXpFLFlBQ21CLGlCQUFpQixFQUFFLGlCQUFpQixFQUNyRCxTQUFTLEVBQUUsTUFBTSxFQUNqQixRQUFRLEVBQUUsTUFBTSxFQUNoQixPQUFPLENBQUMsRUFBRSxNQUFNLEVBQUUsRUFDRCxNQUFNLHlDQUF1RCxFQWUvRTtJQUVEOzs7Ozs7O09BT0c7SUFDSCxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxTQUFTLENBMkJuRDtJQUVEOzs7OztPQUtHO0lBQ0gsT0FBTyxDQUFDLGFBQWE7SUFjckI7Ozs7OztPQU1HO0lBQ0gsc0JBQXNCLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FTMUQ7SUFFRDs7Ozs7T0FLRztJQUNILG9CQUFvQixDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQWlCekM7SUFFRDs7T0FFRztJQUNILElBQUksZUFBZSxJQUFJLE1BQU0sQ0FFNUI7SUFFRDs7T0FFRztJQUNILElBQUksaUJBQWlCLElBQUksTUFBTSxDQUU5QjtDQUNGIn0=

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch_connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/batch_connection_sampler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IAO/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAIlC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuC;IAEzE,YACmB,iBAAiB,EAAE,iBAAiB,EACrD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAAE,EACD,MAAM,yCAAuD,EAe/E;IAED;;;;;;;OAOG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA2BnD;IAED;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAcrB;;;;;;OAMG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAS1D;IAED;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiBzC;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;CACF"}

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.js

@@ -1,151 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-/**
- * Manages batches of peers for parallel request processing.
- * Tracks active peers and provides deterministic peer assignment for requests.
- *
- * Example with 3 peers and 10 requests:
- *
- * Peers:    [P1]      [P2]     [P3]
- *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
- * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
- *
- * Each peer handles a bucket of consecutive requests.
- * If a peer fails, it is replaced while maintaining the same bucket.
- */ export class BatchConnectionSampler {
-    connectionSampler;
-    logger;
-    batch;
-    requestsPerPeer;
-    /** Tracks peer-index combinations that returned empty/invalid responses */ failedPeerIndices;
-    constructor(connectionSampler, batchSize, maxPeers, exclude, logger = createLogger('p2p:reqresp:batch-connection-sampler')){
-        this.connectionSampler = connectionSampler;
-        this.logger = logger;
-        this.batch = [];
-        this.failedPeerIndices = new Map();
-        if (maxPeers <= 0) {
-            throw new Error('Max peers cannot be 0');
-        }
-        if (batchSize <= 0) {
-            throw new Error('Batch size cannot be 0');
-        }
-        // Calculate how many requests each peer should handle, cannot be 0
-        this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
-        // Sample initial peers
-        const excluding = exclude && new Map(exclude.map((peerId)=>[
-                peerId.toString(),
-                true
-            ]));
-        this.batch = this.connectionSampler.samplePeersBatch(maxPeers, excluding);
-    }
-    /**
-   * Gets the peer responsible for handling a specific request index.
-   * If the primary peer has previously failed for this index, tries other peers.
-   * If all batch peers have failed, attempts to sample a new peer.
-   *
-   * @param index - The request index
-   * @returns The peer assigned to handle this request, or undefined if no peer available
-   */ getPeerForRequest(index) {
-        if (this.batch.length === 0) {
-            return undefined;
-        }
-        // Calculate which peer bucket this index belongs to
-        const primaryPeerIndex = Math.floor(index / this.requestsPerPeer) % this.batch.length;
-        // Try peers starting from primary, wrapping around
-        for(let offset = 0; offset < this.batch.length; offset++){
-            const peerIndex = (primaryPeerIndex + offset) % this.batch.length;
-            const peer = this.batch[peerIndex];
-            const peerKey = peer.toString();
-            const failedIndices = this.failedPeerIndices.get(peerKey);
-            if (!failedIndices || !failedIndices.has(index)) {
-                return peer;
-            }
-        }
-        // All batch peers have failed for this index - try to sample a new peer
-        const newPeer = this.sampleNewPeer();
-        if (newPeer) {
-            return newPeer;
-        }
-        return undefined;
-    }
-    /**
-   * Attempts to sample a new peer that isn't already in the batch.
-   * If successful, adds the peer to the batch.
-   *
-   * @returns The new peer if one was sampled, undefined otherwise
-   */ sampleNewPeer() {
-        // Exclude all current batch peers
-        const excluding = new Map(this.batch.map((p)=>[
-                p.toString(),
-                true
-            ]));
-        const newPeer = this.connectionSampler.getPeer(excluding);
-        if (newPeer) {
-            this.batch.push(newPeer);
-            this.logger.trace('Sampled new peer for exhausted index', {
-                newPeer: newPeer.toString()
-            });
-            return newPeer;
-        }
-        return undefined;
-    }
-    /**
-   * Marks that a peer returned an empty/invalid response for a specific request index.
-   * The peer will not be assigned this index again.
-   *
-   * @param peerId - The peer that failed
-   * @param index - The request index that failed
-   */ markPeerFailedForIndex(peerId, index) {
-        const peerKey = peerId.toString();
-        let failedIndices = this.failedPeerIndices.get(peerKey);
-        if (!failedIndices) {
-            failedIndices = new Set();
-            this.failedPeerIndices.set(peerKey, failedIndices);
-        }
-        failedIndices.add(index);
-        this.logger.trace('Marked peer failed for index', {
-            peerId: peerKey,
-            index
-        });
-    }
-    /**
-   * Removes a peer and replaces it with a new one, maintaining the same position
-   * in the batch array to keep request distribution consistent
-   *
-   * @param peerId - The peer to remove and replace
-   */ removePeerAndReplace(peerId) {
-        const index = this.batch.findIndex((p)=>p === peerId);
-        if (index === -1) {
-            return;
-        }
-        const excluding = new Map([
-            [
-                peerId.toString(),
-                true
-            ]
-        ]);
-        const newPeer = this.connectionSampler.getPeer(excluding); // Q: Shouldn't we accumulate all excluded peers? Otherwise the sampler could return us a previously excluded peer?
-        if (newPeer) {
-            this.batch[index] = newPeer;
-            this.logger.trace('Replaced peer', {
-                peerId,
-                newPeer
-            });
-        } else {
-            // If we couldn't get a replacement, remove the peer and compact the array
-            this.batch.splice(index, 1);
-            this.logger.trace('Removed peer', {
-                peerId
-            });
-        }
-    }
-    /**
-   * Gets the number of active peers
-   */ get activePeerCount() {
-        return this.batch.length;
-    }
-    /**
-   * Gets the number of requests each peer is assigned to handle
-   */ get requestsPerBucket() {
-        return this.requestsPerPeer;
-    }
-}

package/dest/services/reqresp/protocols/block.d.ts

@@ -1,9 +0,0 @@
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ReqRespSubProtocolHandler } from '../interface.js';
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */
-export declare function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2suZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9yZXFyZXNwL3Byb3RvY29scy9ibG9jay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUl6RCxPQUFPLEtBQUssRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBR2pFOzs7O0tBSUs7QUFDTCx3QkFBZ0IsbUJBQW1CLENBQUMsYUFBYSxFQUFFLGFBQWEsR0FBRyx5QkFBeUIsQ0FzQjNGIn0=

package/dest/services/reqresp/protocols/block.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/block.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAGjE;;;;KAIK;AACL,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,yBAAyB,CAsB3F"}

package/dest/services/reqresp/protocols/block.js

@@ -1,32 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { ReqRespStatus, ReqRespStatusError } from '../status.js';
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */ export function reqRespBlockHandler(l2BlockSource) {
-    /**
-   * @param peerId - the peer ID of the requester
-   * @param msg - the block request message, which is expected to contain valid block number as a Buffer
-   * @returns a Buffer containing the requested block data, or an empty Buffer if the block is not found
-   * @throws  ReqRespStatusError if the input msg is not a valid block number
-   * */ return async (_peerId, msg)=>{
-        let blockNumber;
-        try {
-            blockNumber = Fr.fromBuffer(msg);
-        } catch (err) {
-            throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, {
-                cause: err
-            });
-        }
-        try {
-            const foundBlock = await l2BlockSource.getBlock(BlockNumber(Number(blockNumber)));
-            return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
-        } catch (err) {
-            throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, {
-                cause: err
-            });
-        }
-    };
-}

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

@@ -1,53 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-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 { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
-import type { TxCollectionConfig } from './config.js';
-import { type ProposalTxCollector } from './proposal_tx_collector.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 p2pService;
-    private nodes;
-    private txCollectionSink;
-    private config;
-    private dateProvider;
-    private log;
-    protected requests: Set<FastCollectionRequest>;
-    private proposalTxCollector;
-    constructor(p2pService: BatchTxRequesterLibP2PService, nodes: TxSource[], txCollectionSink: TxCollectionSink, config: TxCollectionConfig, dateProvider?: DateProvider, log?: Logger, proposalTxCollector?: ProposalTxCollector);
-    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>;
-    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: 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;
-}
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +0,0 @@
-{"version":3,"file":"fast_tx_collection.d.ts","sourceRoot":"","sources":["../../../src/services/tx_collection/fast_tx_collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAG9D,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;AAGhD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAGhG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,4BAA4B,CAAC;AACpC,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;IAMzB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,GAAG;IATb,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAa;IAC3D,OAAO,CAAC,mBAAmB,CAAsB;IAEjD,YACU,UAAU,EAAE,6BAA6B,EACzC,KAAK,EAAE,QAAQ,EAAE,EACjB,gBAAgB,EAAE,gBAAgB,EAClC,MAAM,EAAE,kBAAkB,EAC1B,YAAY,GAAE,YAAiC,EAC/C,GAAG,GAAE,MAAkD,EAC/D,mBAAmB,CAAC,EAAE,mBAAmB,EAS1C;IAEY,IAAI,kBAGhB;IAEM,yBAAyB,+BAE/B;IAEY,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,iBA0C9C;IAED,UAAgB,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,iBA+CxE;YAQa,oBAAoB;YAYpB,mBAAmB;YAiFnB,qBAAqB;IAmDnC;;;OAGG;IACI,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,QAwBxB;IAED;;;OAGG;IACI,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAOjE;IAED;;;OAGG;IACI,4BAA4B,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAOlE;CACF"}

package/dest/services/tx_collection/fast_tx_collection.js

@@ -1,311 +0,0 @@
-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';
-import { BatchTxRequesterCollector, SendBatchRequestCollector } from './proposal_tx_collector.js';
-export class FastTxCollection {
-    p2pService;
-    nodes;
-    txCollectionSink;
-    config;
-    dateProvider;
-    log;
-    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-    requests;
-    proposalTxCollector;
-    constructor(p2pService, nodes, txCollectionSink, config, dateProvider = new DateProvider(), log = createLogger('p2p:tx_collection_service'), proposalTxCollector){
-        this.p2pService = p2pService;
-        this.nodes = nodes;
-        this.txCollectionSink = txCollectionSink;
-        this.config = config;
-        this.dateProvider = dateProvider;
-        this.log = log;
-        this.requests = new Set();
-        const batchTxRequesterConfig = this.config;
-        const proposalCollectorType = this.config.txCollectionProposalTxCollectorType;
-        this.proposalTxCollector = proposalTxCollector ?? (proposalCollectorType === 'old' ? new SendBatchRequestCollector(p2pService) : new BatchTxRequesterCollector(p2pService, log, dateProvider, undefined, batchTxRequesterConfig));
-    }
-    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(),
-            blockNumber: input.blockNumber
-        } : {
-            ...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)=>{
-                if (request.type === 'proposal') {
-                    return await this.proposalTxCollector.collectTxs(txHashes, request.blockProposal, pinnedPeer, timeoutMs);
-                } else if (request.type === 'block') {
-                    const txs = await this.p2pService.reqResp.sendBatchRequest(ReqRespSubProtocol.TX, chunkTxHashesRequest(txHashes), pinnedPeer, timeoutMs, maxPeers, maxRetryAttempts);
-                    return txs.flat();
-                } else {
-                    throw new Error(`Unknown request type: ${request.type}`);
-                }
-            }, 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);
-            }
-        }
-    }
-}