@aztec/p2p 0.0.1-commit.96dac018d → 0.0.1-commit.993d240

package/dest/services/tx_collection/tx_collection.js

@@ -1,24 +1,21 @@
-import { compactArray } from '@aztec/foundation/collection';
+import { times } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/promise';
 import { sleep } from '@aztec/foundation/sleep';
-import { DateProvider } from '@aztec/foundation/timer';
+import { DateProvider, elapsed } from '@aztec/foundation/timer';
 import { TxHash } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
-import { FastTxCollection } from './fast_tx_collection.js';
+import { BatchTxRequester } from '../reqresp/batch-tx-requester/batch_tx_requester.js';
 import { FileStoreTxCollection } from './file_store_tx_collection.js';
-import { SlowTxCollection, getProofDeadlineForSlot } from './slow_tx_collection.js';
+import { RequestTracker } from './request_tracker.js';
 import { TxCollectionSink } from './tx_collection_sink.js';
 /**
- * Coordinates tx collection from remote RPC nodes and reqresp.
+ * Coordinates tx collection from remote RPC nodes, reqresp, and file store.
  *
- * 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.
+ * Runs a sequential pipeline: node RPC → reqresp → file store. Node collection starts immediately,
+ * reqresp starts after a configured delay, and file store (if configured) starts after a further
+ * delay. All paths send txs to the collection sink, which handles metrics and adds them to the
+ * tx pool. Whenever a tx is added to the sink or the pool, this service is notified and stops
+ * collecting that tx across all in-flight requests.
  */ export class TxCollection {
     p2pService;
     nodes;
@@ -27,16 +24,13 @@ import { TxCollectionSink } from './tx_collection_sink.js';
     config;
     dateProvider;
     log;
-    /** Slow collection background loops */ slowCollection;
-    /** Fast collection methods */ fastCollection;
-    /** File store collection for slow (mined block) path */ fileStoreSlowCollection;
-    /** File store collection for fast (proposal/proving) path */ fileStoreFastCollection;
-    /** 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;
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    requests;
+    /** The collector for txs via reqresp */ reqRespTxsCollector;
+    /** File store collection for the fast (proposal/proving) path */ fileStoreFastCollection;
+    /** Handles txs found by collection paths before adding to the pool */ txCollectionSink;
     /** Handler for the txs-added event from the tx pool */ handleTxsAddedToPool;
     /** Handler for the txs-added event from the tx collection sink */ handleTxsFound;
-    /** Whether the service has been started. */ started;
-    /** Whether file store sources are configured. */ hasFileStoreSources;
     constructor(p2pService, nodes, constants, txPool, config, fileStoreSources = [], dateProvider = new DateProvider(), telemetryClient = getTelemetryClient(), log = createLogger('p2p:tx_collection_service')){
         this.p2pService = p2pService;
         this.nodes = nodes;
@@ -45,22 +39,14 @@ import { TxCollectionSink } from './tx_collection_sink.js';
         this.config = config;
         this.dateProvider = dateProvider;
         this.log = log;
-        this.started = false;
+        this.requests = new Set();
         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.hasFileStoreSources = fileStoreSources.length > 0;
-        this.fileStoreSlowCollection = new FileStoreTxCollection(fileStoreSources, this.txCollectionSink, {
-            workerCount: config.txCollectionFileStoreSlowWorkerCount,
-            backoffBaseMs: config.txCollectionFileStoreSlowBackoffBaseMs,
-            backoffMaxMs: config.txCollectionFileStoreSlowBackoffMaxMs
-        }, this.dateProvider, this.log);
+        this.reqRespTxsCollector = (requestTracker, blockTxsSource, pinnedPeer)=>BatchTxRequester.collectAllTxs(new BatchTxRequester(requestTracker, blockTxsSource, pinnedPeer, this.p2pService, this.log, this.dateProvider).run());
         this.fileStoreFastCollection = new FileStoreTxCollection(fileStoreSources, this.txCollectionSink, {
             workerCount: config.txCollectionFileStoreFastWorkerCount,
             backoffBaseMs: config.txCollectionFileStoreFastBackoffBaseMs,
             backoffMaxMs: config.txCollectionFileStoreFastBackoffMaxMs
         }, this.dateProvider, this.log);
-        this.reconcileFoundTxsLoop = new RunningPromise(()=>this.reconcileFoundTxsWithPool(), this.log, this.config.txCollectionReconcileIntervalMs);
         this.handleTxsFound = (args)=>{
             this.foundTxs(args.txs);
         };
@@ -73,128 +59,298 @@ import { TxCollectionSink } from './tx_collection_sink.js';
         };
         this.txPool.on('txs-added', this.handleTxsAddedToPool);
     }
-    /** Starts all collection loops. */ start() {
-        this.started = true;
-        this.slowCollection.start();
-        this.fileStoreSlowCollection.start();
-        this.fileStoreFastCollection.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() {
-        this.started = false;
-        await Promise.all([
-            this.slowCollection.stop(),
-            this.fastCollection.stop(),
-            this.fileStoreSlowCollection.stop(),
-            this.fileStoreFastCollection.stop(),
-            this.reconcileFoundTxsLoop.stop()
-        ]);
+    /** Stops all activity. Cancels in-flight requests; file store workers self-terminate. */ stop() {
+        this.requests.forEach((request)=>{
+            request.requestTracker.cancel();
+        });
         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) {
-        this.slowCollection.startCollecting(block, txHashes);
-        // Delay file store collection to give P2P methods time to find txs first
-        if (this.hasFileStoreSources) {
-            const context = {
-                type: 'mined',
-                block
-            };
-            const deadline = getProofDeadlineForSlot(block.header.getSlot(), this.constants);
-            sleep(this.config.txCollectionFileStoreSlowDelayMs).then(()=>{
-                if (this.started) {
-                    // Only queue txs that are still missing after the delay
-                    const stillMissing = new Set(this.slowCollection.getMissingTxHashes().map((h)=>h.toString()));
-                    const remaining = txHashes.filter((h)=>stillMissing.has(h.toString()));
-                    if (remaining.length > 0) {
-                        this.fileStoreSlowCollection.startCollecting(remaining, context, deadline);
-                    }
-                }
-            }).catch((err)=>this.log.error('Error in file store slow delay', err));
-        }
-    }
-    /** 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) {
+    /** Collects the set of txs for the given proposal or block as fast as possible */ 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 hashes = txHashes.map((h)=>typeof h === 'string' ? TxHash.fromString(h) : h);
-        // Delay file store collection to give P2P methods time to find txs first
-        if (this.hasFileStoreSources) {
-            const context = this.getAddContextForInput(input);
-            sleep(this.config.txCollectionFileStoreFastDelayMs).then(()=>{
-                if (this.started) {
-                    this.fileStoreFastCollection.startCollecting(hashes, context, opts.deadline);
+        const blockInfo = input.type === 'proposal' ? {
+            ...input.blockProposal.toBlockInfo(),
+            blockNumber: input.blockNumber
+        } : {
+            ...input.block.toBlockInfo()
+        };
+        const request = {
+            ...input,
+            blockInfo,
+            requestTracker: RequestTracker.create(hashes, opts.deadline, this.dateProvider)
+        };
+        const [duration] = await elapsed(()=>this.collectFast(request, {
+                pinnedPeer: opts.pinnedPeer
+            }));
+        this.log.verbose(`Collected ${request.requestTracker.collectedTxs.length} txs out of ${hashes.length} for ${input.type} at slot ${blockInfo.slotNumber}`, {
+            ...blockInfo,
+            duration,
+            requestType: input.type,
+            missingTxs: [
+                ...request.requestTracker.missingTxHashes
+            ]
+        });
+        return request.requestTracker.collectedTxs;
+    }
+    async collectFast(request, opts) {
+        this.requests.add(request);
+        const { blockInfo } = request;
+        this.log.debug(`Starting fast collection of ${request.requestTracker.numberOfMissingTxs} txs for ${request.type} at slot ${blockInfo.slotNumber}`, {
+            ...blockInfo,
+            requestType: request.type,
+            deadline: request.requestTracker.deadline
+        });
+        try {
+            // 1. Start node collection in the background.
+            // Note: this will be a noop if no nodes are configured.
+            const nodeCollectionPromise = this.collectFastFromNodes(request);
+            // 2. Wait before starting reqresp, interruptible by cancellation or node exhaustion.
+            await Promise.race([
+                request.requestTracker.cancellationToken,
+                sleep(this.config.txCollectionFastNodesTimeoutBeforeReqRespMs),
+                nodeCollectionPromise
+            ]);
+            // 3. Start reqresp in the background (runs in parallel with node collection).
+            // Note: this will be a noop if all TXs were already found.
+            const reqRespPromise = this.collectFastViaReqResp(request, opts);
+            // 4. Wait before starting file store, interruptible by cancellation.
+            await Promise.race([
+                request.requestTracker.cancellationToken,
+                sleep(this.config.txCollectionFileStoreFastDelayMs),
+                reqRespPromise
+            ]);
+            // 5. Start file store collection in the background. Self-terminates on tracker cancel / all-found.
+            // Note: this will be a noop if all TXs were already found.
+            const fileStorePromise = this.fileStoreFastCollection.startCollecting(request.requestTracker, this.getAddContext(request));
+            // 6. Wait for all paths to settle.
+            // NOTE: The request will automatically be cancelled after `opt.deadline` is reached.
+            await Promise.allSettled([
+                reqRespPromise,
+                nodeCollectionPromise,
+                fileStorePromise
+            ]);
+        } catch (err) {
+            this.log.error(`Error collecting txs for ${request.type} for slot ${blockInfo.slotNumber}`, err, {
+                ...blockInfo,
+                missingTxs: request.requestTracker.missingTxHashes.values().map((txHash)=>txHash.toString())
+            });
+        } finally{
+            request.requestTracker.cancel();
+            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) {
+        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.requestTracker.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)));
+    }
+    async collectFastFromNode(request, node, attemptsPerTx) {
+        const notFinished = ()=>!request.requestTracker.checkCancelled();
+        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.requestTracker.isMissing(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 already 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++;
+                    }
                 }
-            }).catch((err)=>this.log.error('Error in file store fast delay', err));
+                // 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;
+                }
+                const txHashes = batch.map(({ txHash })=>txHash);
+                // Collect this batch from the node
+                await this.txCollectionSink.collect(async ()=>{
+                    const result = await node.getTxsByHash(txHashes.map(TxHash.fromString));
+                    for (const tx of result.validTxs){
+                        request.requestTracker.markFetched(tx);
+                    }
+                    return result;
+                }, txHashes, {
+                    description: `fast ${node.getInfo()}`,
+                    node: node.getInfo(),
+                    method: 'fast-node-rpc',
+                    ...request.blockInfo
+                }, this.getAddContext(request));
+                // 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, but wake up immediately on cancellation
+                if (notFinished()) {
+                    await Promise.race([
+                        sleep(this.config.txCollectionFastNodeIntervalMs),
+                        request.requestTracker.cancellationToken
+                    ]);
+                }
+            }
+        };
+        // Kick off N parallel requests to the node, up to the maxParallelRequests limit
+        await Promise.all(times(maxParallelRequests, processBatch));
+    }
+    async collectFastViaReqResp(request, opts) {
+        const pinnedPeer = opts.pinnedPeer;
+        const blockInfo = request.blockInfo;
+        const slotNumber = blockInfo.slotNumber;
+        if (request.requestTracker.timeoutMs < 100) {
+            this.log.warn(`Not initiating fast reqresp for txs for ${request.type} at slot ${blockInfo.slotNumber} due to timeout`, {
+                timeoutMs: request.requestTracker.timeoutMs,
+                ...blockInfo
+            });
+            return;
+        }
+        if (request.requestTracker.checkCancelled()) {
+            this.log.debug(`No txs to collect via reqresp for ${request.type} at slot ${blockInfo.slotNumber}`, {
+                ...blockInfo
+            });
+            return;
+        }
+        this.log.debug(`Starting fast reqresp for ${request.requestTracker.numberOfMissingTxs} txs for ${request.type} at slot ${blockInfo.slotNumber}`, {
+            ...blockInfo,
+            timeoutMs: request.requestTracker.timeoutMs,
+            pinnedPeer
+        });
+        try {
+            await this.txCollectionSink.collect(async ()=>{
+                let blockTxsSource;
+                if (request.type === 'proposal') {
+                    blockTxsSource = request.blockProposal;
+                } else if (request.type === 'block') {
+                    blockTxsSource = {
+                        txHashes: request.block.body.txEffects.map((e)=>e.txHash),
+                        archive: request.block.archive.root
+                    };
+                } else {
+                    throw new Error(`Unknown request type: ${request.type}`);
+                }
+                const result = await this.reqRespTxsCollector(request.requestTracker, blockTxsSource, pinnedPeer);
+                return {
+                    validTxs: result,
+                    invalidTxHashes: []
+                };
+            }, Array.from(request.requestTracker.missingTxHashes), {
+                description: `reqresp for slot ${slotNumber}`,
+                method: 'fast-req-resp',
+                ...opts,
+                ...request.blockInfo
+            }, this.getAddContext(request));
+        } catch (err) {
+            this.log.error(`Error sending fast reqresp request for txs`, err, {
+                txs: [
+                    ...request.requestTracker.missingTxHashes
+                ],
+                ...blockInfo
+            });
         }
-        return this.fastCollection.collectFastFor(input, txHashes, opts);
     }
-    /** Returns the TxAddContext for the given fast collection request input */ getAddContextForInput(input) {
-        if (input.type === 'proposal') {
+    /** Returns the TxAddContext for the given request, used by the sink to add txs to the pool correctly. */ getAddContext(request) {
+        if (request.type === 'proposal') {
             return {
                 type: 'proposal',
-                blockHeader: input.blockProposal.blockHeader
+                blockHeader: request.blockProposal.blockHeader
             };
         } else {
             return {
                 type: 'mined',
-                block: input.block
+                block: request.block
             };
         }
     }
-    /** Mark the given txs as found. Stops collecting them. */ foundTxs(txs) {
-        this.slowCollection.foundTxs(txs);
-        this.fastCollection.foundTxs(txs);
-        this.fileStoreSlowCollection.foundTxs(txs);
-        this.fileStoreFastCollection.foundTxs(txs);
+    /** Mark the given txs as found. Stops collecting them across all in-flight requests. */ foundTxs(txs) {
+        for (const request of this.requests){
+            for (const tx of txs){
+                if (request.requestTracker.markFetched(tx)) {
+                    this.log.trace(`Found tx ${tx.txHash.toString()} for fast collection request`, {
+                        ...request.blockInfo,
+                        txHash: tx.txHash.toString(),
+                        type: request.type
+                    });
+                    if (request.requestTracker.allFetched()) {
+                        this.log.trace(`All txs found for fast collection request`, {
+                            ...request.blockInfo,
+                            type: request.type
+                        });
+                        break;
+                    }
+                }
+            }
+        }
     }
     /**
-   * Stop collecting all txs for blocks less than or requal to the block number specified.
+   * Stop collecting all txs for blocks less than or equal 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);
-        this.fileStoreSlowCollection.clearPending();
-        this.fileStoreFastCollection.clearPending();
+        for (const request of this.requests){
+            if (request.blockInfo.blockNumber <= blockNumber) {
+                request.requestTracker.cancel();
+            }
+        }
     }
     /**
    * 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);
-        this.fileStoreSlowCollection.clearPending();
-        this.fileStoreFastCollection.clearPending();
-    }
-    /** 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);
+        for (const request of this.requests){
+            if (request.blockInfo.blockNumber > blockNumber) {
+                request.requestTracker.cancel();
+            }
         }
     }
 }

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

@@ -16,7 +16,7 @@ export type TxAddContext = {
 };
 declare const TxCollectionSink_base: new () => TypedEventEmitter<TxPoolV2Events>;
 /**
- * Executes collection requests from the fast and slow collection loops, and handles collected txs
+ * Executes collection requests from fast collection paths, 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 {

package/dest/services/tx_collection/tx_collection_sink.js

@@ -2,7 +2,7 @@ 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
+ * Executes collection requests from fast collection paths, 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;
@@ -76,7 +76,7 @@ import { TxCollectionInstrumentation } from './instrumentation.js';
     async foundTxs(txs, info, context) {
         // 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
+        // Mark txs as found in all in-flight collection requests
         this.emit('txs-added', {
             txs
         });

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

@@ -1,6 +1,6 @@
 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 { Tx, TxHash, TxValidator } from '@aztec/stdlib/tx';
 import { type ComponentsVersions } from '@aztec/stdlib/versioning';
 export type TxSourceCollectionResult = {
     validTxs: Tx[];
@@ -12,12 +12,13 @@ export interface TxSource {
 }
 export declare class NodeRpcTxSource implements TxSource {
     private readonly client;
+    private readonly txValidator;
     private readonly info;
-    constructor(client: Pick<AztecNode, 'getTxsByHash'>, info: string);
-    static fromUrl(nodeUrl: string, versions: ComponentsVersions): NodeRpcTxSource;
+    constructor(client: Pick<AztecNode, 'getTxsByHash'>, txValidator: TxValidator, info: string);
+    static fromUrl(nodeUrl: string, txValidator: TxValidator, versions: ComponentsVersions): NodeRpcTxSource;
     getInfo(): string;
     getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult>;
     private verifyTxs;
 }
-export declare function createNodeRpcTxSources(urls: string[], chainConfig: ChainConfig): NodeRpcTxSource[];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfc291cmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvdHhfY29sbGVjdGlvbi90eF9zb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUF5QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3hGLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsS0FBSyxrQkFBa0IsRUFBbUMsTUFBTSwwQkFBMEIsQ0FBQztBQUdwRyxNQUFNLE1BQU0sd0JBQXdCLEdBQUc7SUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUM7SUFBQyxlQUFlLEVBQUUsTUFBTSxFQUFFLENBQUE7Q0FBRSxDQUFDO0FBRXJGLE1BQU0sV0FBVyxRQUFRO0lBQ3ZCLE9BQU8sSUFBSSxNQUFNLENBQUM7SUFDbEIsWUFBWSxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsR0FBRyxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0FBQztDQUNyRTtBQUVELHFCQUFhLGVBQWdCLFlBQVcsUUFBUTtJQUU1QyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJO0lBRnZCLFlBQ21CLE1BQU0sRUFBRSxJQUFJLENBQUMsU0FBUyxFQUFFLGNBQWMsQ0FBQyxFQUN2QyxJQUFJLEVBQUUsTUFBTSxFQUMzQjtJQUVKLE9BQWMsT0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLGtCQUFrQixHQUFHLGVBQWUsQ0FHcEY7SUFFTSxPQUFPLFdBRWI7SUFFWSxZQUFZLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyx3QkFBd0IsQ0FBQyxDQUUvRTtZQUVhLFNBQVM7Q0FnQnhCO0FBRUQsd0JBQWdCLHNCQUFzQixDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsRUFBRSxXQUFXLEVBQUUsV0FBVyxxQkFHOUUifQ==
+export declare function createNodeRpcTxSources(urls: string[], txValidator: TxValidator, chainConfig: ChainConfig): NodeRpcTxSource[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfc291cmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvdHhfY29sbGVjdGlvbi90eF9zb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUF5QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3hGLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDaEUsT0FBTyxFQUFFLEtBQUssa0JBQWtCLEVBQW1DLE1BQU0sMEJBQTBCLENBQUM7QUFHcEcsTUFBTSxNQUFNLHdCQUF3QixHQUFHO0lBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQUMsZUFBZSxFQUFFLE1BQU0sRUFBRSxDQUFBO0NBQUUsQ0FBQztBQUVyRixNQUFNLFdBQVcsUUFBUTtJQUN2QixPQUFPLElBQUksTUFBTSxDQUFDO0lBQ2xCLFlBQVksQ0FBQyxRQUFRLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDLHdCQUF3QixDQUFDLENBQUM7Q0FDckU7QUFFRCxxQkFBYSxlQUFnQixZQUFXLFFBQVE7SUFFNUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxRQUFRLENBQUMsV0FBVztJQUM1QixPQUFPLENBQUMsUUFBUSxDQUFDLElBQUk7SUFIdkIsWUFDbUIsTUFBTSxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsY0FBYyxDQUFDLEVBQ3ZDLFdBQVcsRUFBRSxXQUFXLEVBQ3hCLElBQUksRUFBRSxNQUFNLEVBQzNCO0lBRUosT0FBYyxPQUFPLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsV0FBVyxFQUFFLFFBQVEsRUFBRSxrQkFBa0IsR0FBRyxlQUFlLENBRzlHO0lBRU0sT0FBTyxXQUViO0lBRVksWUFBWSxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsR0FBRyxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0FFL0U7WUFFYSxTQUFTO0NBZ0J4QjtBQUVELHdCQUFnQixzQkFBc0IsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxXQUFXLEVBQUUsV0FBVyxxQkFHeEcifQ==

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

@@ -1 +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,MAAM,wBAAwB,GAAG;IAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAErF,MAAM,WAAW,QAAQ;IACvB,OAAO,IAAI,MAAM,CAAC;IAClB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACrE;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;IAEY,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAE/E;YAEa,SAAS;CAgBxB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,WAAW,qBAG9E"}
+{"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,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,KAAK,kBAAkB,EAAmC,MAAM,0BAA0B,CAAC;AAGpG,MAAM,MAAM,wBAAwB,GAAG;IAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAErF,MAAM,WAAW,QAAQ;IACvB,OAAO,IAAI,MAAM,CAAC;IAClB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACrE;AAED,qBAAa,eAAgB,YAAW,QAAQ;IAE5C,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHvB,YACmB,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,EACvC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,EAC3B;IAEJ,OAAc,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,kBAAkB,GAAG,eAAe,CAG9G;IAEM,OAAO,WAEb;IAEY,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAE/E;YAEa,SAAS;CAgBxB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,qBAGxG"}

package/dest/services/tx_collection/tx_source.js

@@ -5,18 +5,20 @@ import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 import { makeTracedFetch } from '@aztec/telemetry-client';
 export class NodeRpcTxSource {
     client;
+    txValidator;
     info;
-    constructor(client, info){
+    constructor(client, txValidator, info){
         this.client = client;
+        this.txValidator = txValidator;
         this.info = info;
     }
-    static fromUrl(nodeUrl, versions) {
+    static fromUrl(nodeUrl, txValidator, versions) {
         const client = createAztecNodeClient(nodeUrl, versions, makeTracedFetch([
             1,
             2,
             3
         ], false));
-        return new NodeRpcTxSource(client, nodeUrl);
+        return new NodeRpcTxSource(client, txValidator, nodeUrl);
     }
     getInfo() {
         return this.info;
@@ -29,8 +31,8 @@ export class NodeRpcTxSource {
         const validTxs = [];
         const invalidTxHashes = [];
         await Promise.all(txs.map(async (tx)=>{
-            const isValid = await tx.validateTxHash();
-            if (isValid) {
+            const validation = await this.txValidator.validateTx(tx);
+            if (validation.result === 'valid') {
                 validTxs.push(tx);
             } else {
                 invalidTxHashes.push(tx.getTxHash().toString());
@@ -42,7 +44,7 @@ export class NodeRpcTxSource {
         };
     }
 }
-export function createNodeRpcTxSources(urls, chainConfig) {
+export function createNodeRpcTxSources(urls, txValidator, chainConfig) {
     const versions = getComponentsVersionsFromConfig(chainConfig, protocolContractsHash, getVKTreeRoot());
-    return urls.map((url)=>NodeRpcTxSource.fromUrl(url, versions));
+    return urls.map((url)=>NodeRpcTxSource.fromUrl(url, txValidator, versions));
 }

package/dest/services/tx_file_store/tx_file_store.d.ts

@@ -20,8 +20,6 @@ export declare class TxFileStore {
     private readonly handleTxsAdded;
     /** Recently uploaded tx hashes for deduplication. */
     private recentUploads;
-    private recentUploadsOrder;
-    private readonly maxRecentUploads;
     private constructor();
     /**
      * Creates and initializes the file store.
@@ -45,4 +43,4 @@ export declare class TxFileStore {
     /** Returns the number of pending uploads (queued + in-flight). */
     getPendingUploadCount(): number;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfZmlsZV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL3R4X2ZpbGVfc3RvcmUvdHhfZmlsZV9zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFJbEUsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFtQixNQUFNLDBCQUEwQixDQUFDO0FBRTNFLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRixPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUdyRDs7O0dBR0c7QUFDSCxxQkFBYSxXQUFXO0lBWXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZUFBZTtJQUNoQyxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUc7SUFDcEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRO0lBaEIzQixPQUFPLENBQUMsV0FBVyxDQUFZO0lBQy9CLE9BQU8sQ0FBQyxhQUFhLENBQUs7SUFDMUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQWlCO0lBQ2hELE9BQU8sQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFpRDtJQUVoRixxREFBcUQ7SUFDckQsT0FBTyxDQUFDLGFBQWEsQ0FBMEI7SUFDL0MsT0FBTyxDQUFDLGtCQUFrQixDQUFnQjtJQUMxQyxPQUFPLENBQUMsUUFBUSxDQUFDLGdCQUFnQixDQUFRO0lBRXpDLE9BQU8sZUFZTjtJQUVEOzs7Ozs7OztPQVFHO0lBQ0gsT0FBYSxNQUFNLENBQ2pCLE1BQU0sRUFBRSxRQUFRLEVBQ2hCLE1BQU0sRUFBRSxpQkFBaUIsRUFDekIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsR0FBRyxHQUFFLE1BQTBDLEVBQy9DLFNBQVMsR0FBRSxlQUFzQyxFQUNqRCxpQkFBaUIsQ0FBQyxFQUFFLFNBQVMsR0FDNUIsT0FBTyxDQUFDLFdBQVcsR0FBRyxTQUFTLENBQUMsQ0FvQmxDO0lBRUQsMkRBQTJEO0lBQ3BELEtBQUssSUFBSSxJQUFJLENBT25CO0lBRUQsaUVBQWlFO0lBQ3BELElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBSWpDO0lBRUQsT0FBTyxDQUFDLFVBQVU7WUFnQkosaUJBQWlCO1lBWWpCLFFBQVE7SUF1Q3RCLDJFQUEyRTtJQUM5RCxLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUlsQztJQUVELGtFQUFrRTtJQUMzRCxxQkFBcUIsSUFBSSxNQUFNLENBRXJDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfZmlsZV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL3R4X2ZpbGVfc3RvcmUvdHhfZmlsZV9zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFJbEUsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFtQixNQUFNLDBCQUEwQixDQUFDO0FBRTNFLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRixPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUtyRDs7O0dBR0c7QUFDSCxxQkFBYSxXQUFXO0lBVXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZUFBZTtJQUNoQyxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUc7SUFDcEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRO0lBZDNCLE9BQU8sQ0FBQyxXQUFXLENBQVk7SUFDL0IsT0FBTyxDQUFDLGFBQWEsQ0FBSztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBaUI7SUFDaEQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQWlEO0lBRWhGLHFEQUFxRDtJQUNyRCxPQUFPLENBQUMsYUFBYSxDQUFpRDtJQUV0RSxPQUFPLGVBWU47SUFFRDs7Ozs7Ozs7T0FRRztJQUNILE9BQWEsTUFBTSxDQUNqQixNQUFNLEVBQUUsUUFBUSxFQUNoQixNQUFNLEVBQUUsaUJBQWlCLEVBQ3pCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLEdBQUcsR0FBRSxNQUEwQyxFQUMvQyxTQUFTLEdBQUUsZUFBc0MsRUFDakQsaUJBQWlCLENBQUMsRUFBRSxTQUFTLEdBQzVCLE9BQU8sQ0FBQyxXQUFXLEdBQUcsU0FBUyxDQUFDLENBb0JsQztJQUVELDJEQUEyRDtJQUNwRCxLQUFLLElBQUksSUFBSSxDQU9uQjtJQUVELGlFQUFpRTtJQUNwRCxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUlqQztJQUVELE9BQU8sQ0FBQyxVQUFVO1lBZ0JKLGlCQUFpQjtZQVlqQixRQUFRO0lBMEJ0QiwyRUFBMkU7SUFDOUQsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FJbEM7SUFFRCxrRUFBa0U7SUFDM0QscUJBQXFCLElBQUksTUFBTSxDQUVyQztDQUNGIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"tx_file_store.d.ts","sourceRoot":"","sources":["../../../src/services/tx_file_store/tx_file_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,0BAA0B,CAAC;AAE3E,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrD;;;GAGG;AACH,qBAAa,WAAW;IAYpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAhB3B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiD;IAEhF,qDAAqD;IACrD,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,kBAAkB,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IAEzC,OAAO,eAYN;IAED;;;;;;;;OAQG;IACH,OAAa,MAAM,CACjB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,MAAM,EAChB,GAAG,GAAE,MAA0C,EAC/C,SAAS,GAAE,eAAsC,EACjD,iBAAiB,CAAC,EAAE,SAAS,GAC5B,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAoBlC;IAED,2DAA2D;IACpD,KAAK,IAAI,IAAI,CAOnB;IAED,iEAAiE;IACpD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAIjC;IAED,OAAO,CAAC,UAAU;YAgBJ,iBAAiB;YAYjB,QAAQ;IAuCtB,2EAA2E;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAIlC;IAED,kEAAkE;IAC3D,qBAAqB,IAAI,MAAM,CAErC;CACF"}
+{"version":3,"file":"tx_file_store.d.ts","sourceRoot":"","sources":["../../../src/services/tx_file_store/tx_file_store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,0BAA0B,CAAC;AAE3E,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAKrD;;;GAGG;AACH,qBAAa,WAAW;IAUpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAd3B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiD;IAEhF,qDAAqD;IACrD,OAAO,CAAC,aAAa,CAAiD;IAEtE,OAAO,eAYN;IAED;;;;;;;;OAQG;IACH,OAAa,MAAM,CACjB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,MAAM,EAChB,GAAG,GAAE,MAA0C,EAC/C,SAAS,GAAE,eAAsC,EACjD,iBAAiB,CAAC,EAAE,SAAS,GAC5B,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAoBlC;IAED,2DAA2D;IACpD,KAAK,IAAI,IAAI,CAOnB;IAED,iEAAiE;IACpD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAIjC;IAED,OAAO,CAAC,UAAU;YAgBJ,iBAAiB;YAYjB,QAAQ;IA0BtB,2EAA2E;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAIlC;IAED,kEAAkE;IAC3D,qBAAqB,IAAI,MAAM,CAErC;CACF"}