@aztec/p2p 0.57.0 → 0.59.0

package/dest/client/p2p_client.js

@@ -1,8 +1,8 @@
-var _P2PClient_instances, _P2PClient_assertIsReady;
-import { __classPrivateFieldGet } from "tslib";
+import { __classPrivateFieldGet, __esDecorate, __runInitializers } from "tslib";
 import { L2BlockDownloader, } from '@aztec/circuit-types';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { Attributes, WithTracer, trackSpan } from '@aztec/telemetry-client';
 import { getP2PConfigEnvVars } from '../config.js';
 import { TX_REQ_PROTOCOL } from '../service/reqresp/interface.js';
 /**
@@ -18,354 +18,379 @@ export var P2PClientState;
 /**
  * The P2P client implementation.
  */
-export class P2PClient {
-    /**
-     * In-memory P2P client constructor.
-     * @param store - The client's instance of the KV store.
-     * @param l2BlockSource - P2P client's source for fetching existing blocks.
-     * @param txPool - The client's instance of a transaction pool. Defaults to in-memory implementation.
-     * @param p2pService - The concrete instance of p2p networking to use.
-     * @param keepProvenTxsFor - How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven).
-     * @param log - A logger.
-     */
-    constructor(store, l2BlockSource, txPool, attestationPool, epochProofQuotePool, p2pService, keepProvenTxsFor, log = createDebugLogger('aztec:p2p')) {
-        _P2PClient_instances.add(this);
-        this.l2BlockSource = l2BlockSource;
-        this.txPool = txPool;
-        this.attestationPool = attestationPool;
-        this.epochProofQuotePool = epochProofQuotePool;
-        this.p2pService = p2pService;
-        this.keepProvenTxsFor = keepProvenTxsFor;
-        this.log = log;
-        /** Property that indicates whether the client is running. */
-        this.stopping = false;
-        this.currentState = P2PClientState.IDLE;
-        this.syncPromise = Promise.resolve();
-        this.syncResolve = undefined;
-        this.latestBlockNumberAtStart = -1;
-        this.provenBlockNumberAtStart = -1;
-        const { blockCheckIntervalMS: checkInterval, l2QueueSize: p2pL2QueueSize } = getP2PConfigEnvVars();
-        const l2DownloaderOpts = { maxQueueSize: p2pL2QueueSize, pollIntervalMS: checkInterval };
-        // TODO(palla/prover-node): This effectively downloads blocks twice from the archiver, which is an issue
-        // if the archiver is remote. We should refactor this so the downloader keeps a single queue and handles
-        // latest/proven metadata, as well as block reorgs.
-        this.latestBlockDownloader = new L2BlockDownloader(l2BlockSource, l2DownloaderOpts);
-        this.provenBlockDownloader = new L2BlockDownloader(l2BlockSource, { ...l2DownloaderOpts, proven: true });
-        this.synchedLatestBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
-        this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
-    }
-    getEpochProofQuotes(epoch) {
-        return Promise.resolve(this.epochProofQuotePool.getQuotes(epoch));
-    }
-    broadcastEpochProofQuote(quote) {
-        __classPrivateFieldGet(this, _P2PClient_instances, "m", _P2PClient_assertIsReady).call(this);
-        this.epochProofQuotePool.addQuote(quote);
-        return this.p2pService.propagate(quote);
-    }
-    /**
-     * Starts the P2P client.
-     * @returns An empty promise signalling the synching process.
-     */
-    async start() {
-        if (this.currentState === P2PClientState.STOPPED) {
-            throw new Error('P2P client already stopped');
-        }
-        if (this.currentState !== P2PClientState.IDLE) {
-            return this.syncPromise;
-        }
-        // get the current latest block numbers
-        this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
-        this.provenBlockNumberAtStart = await this.l2BlockSource.getProvenBlockNumber();
-        const syncedLatestBlock = this.getSyncedLatestBlockNum() + 1;
-        const syncedProvenBlock = this.getSyncedProvenBlockNum() + 1;
-        // if there are blocks to be retrieved, go to a synching state
-        if (syncedLatestBlock <= this.latestBlockNumberAtStart || syncedProvenBlock <= this.provenBlockNumberAtStart) {
-            this.setCurrentState(P2PClientState.SYNCHING);
-            this.syncPromise = new Promise(resolve => {
-                this.syncResolve = resolve;
-            });
-            this.log.verbose(`Starting sync from ${syncedLatestBlock} (last proven ${syncedProvenBlock})`);
-        }
-        else {
-            // if no blocks to be retrieved, go straight to running
-            this.setCurrentState(P2PClientState.RUNNING);
-            this.syncPromise = Promise.resolve();
-            await this.p2pService.start();
-            this.log.verbose(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
-        }
-        // publish any txs in TxPool after its doing initial sync
-        this.syncPromise = this.syncPromise.then(() => this.publishStoredTxs());
-        // start looking for further blocks
-        const processLatest = async () => {
-            while (!this.stopping) {
-                await this.latestBlockDownloader.getBlocks(1).then(this.handleLatestL2Blocks.bind(this));
+let P2PClient = (() => {
+    var _P2PClient_instances, _a, _P2PClient_assertIsReady;
+    let _classSuper = WithTracer;
+    let _instanceExtraInitializers = [];
+    let _broadcastProposal_decorators;
+    return _a = class P2PClient extends _classSuper {
+            /**
+             * In-memory P2P client constructor.
+             * @param store - The client's instance of the KV store.
+             * @param l2BlockSource - P2P client's source for fetching existing blocks.
+             * @param txPool - The client's instance of a transaction pool. Defaults to in-memory implementation.
+             * @param p2pService - The concrete instance of p2p networking to use.
+             * @param keepProvenTxsFor - How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven).
+             * @param log - A logger.
+             */
+            constructor(store, l2BlockSource, mempools, p2pService, keepProvenTxsFor, telemetryClient, log = createDebugLogger('aztec:p2p')) {
+                super(telemetryClient, 'P2PClient');
+                _P2PClient_instances.add(this);
+                this.l2BlockSource = (__runInitializers(this, _instanceExtraInitializers), l2BlockSource);
+                this.p2pService = p2pService;
+                this.keepProvenTxsFor = keepProvenTxsFor;
+                this.log = log;
+                /** Property that indicates whether the client is running. */
+                this.stopping = false;
+                this.currentState = P2PClientState.IDLE;
+                this.syncPromise = Promise.resolve();
+                this.syncResolve = undefined;
+                this.latestBlockNumberAtStart = -1;
+                this.provenBlockNumberAtStart = -1;
+                const { blockCheckIntervalMS: checkInterval, l2QueueSize: p2pL2QueueSize } = getP2PConfigEnvVars();
+                const l2DownloaderOpts = { maxQueueSize: p2pL2QueueSize, pollIntervalMS: checkInterval };
+                // TODO(palla/prover-node): This effectively downloads blocks twice from the archiver, which is an issue
+                // if the archiver is remote. We should refactor this so the downloader keeps a single queue and handles
+                // latest/proven metadata, as well as block reorgs.
+                this.latestBlockDownloader = new L2BlockDownloader(l2BlockSource, l2DownloaderOpts);
+                this.provenBlockDownloader = new L2BlockDownloader(l2BlockSource, { ...l2DownloaderOpts, proven: true });
+                this.synchedLatestBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
+                this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
+                this.txPool = mempools.txPool;
+                this.attestationPool = mempools.attestationPool;
+                this.epochProofQuotePool = mempools.epochProofQuotePool;
             }
-        };
-        const processProven = async () => {
-            while (!this.stopping) {
-                await this.provenBlockDownloader.getBlocks(1).then(this.handleProvenL2Blocks.bind(this));
+            getEpochProofQuotes(epoch) {
+                return Promise.resolve(this.epochProofQuotePool.getQuotes(epoch));
             }
-        };
-        this.runningPromise = Promise.all([processLatest(), processProven()]).then(() => { });
-        this.latestBlockDownloader.start(syncedLatestBlock);
-        this.provenBlockDownloader.start(syncedLatestBlock);
-        this.log.verbose(`Started block downloader from block ${syncedLatestBlock}`);
-        return this.syncPromise;
-    }
-    /**
-     * Allows consumers to stop the instance of the P2P client.
-     * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
-     */
-    async stop() {
-        this.log.debug('Stopping p2p client...');
-        this.stopping = true;
-        await this.p2pService.stop();
-        this.log.debug('Stopped p2p service');
-        await this.latestBlockDownloader.stop();
-        await this.provenBlockDownloader.stop();
-        this.log.debug('Stopped block downloader');
-        await this.runningPromise;
-        this.setCurrentState(P2PClientState.STOPPED);
-        this.log.info('P2P client stopped.');
-    }
-    broadcastProposal(proposal) {
-        this.log.verbose(`Broadcasting proposal ${proposal.p2pMessageIdentifier()} to peers`);
-        return this.p2pService.propagate(proposal);
-    }
-    getAttestationsForSlot(slot, proposalId) {
-        return Promise.resolve(this.attestationPool.getAttestationsForSlot(slot, proposalId));
-    }
-    // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
-    // ^ This pattern is not my favorite (md)
-    registerBlockProposalHandler(handler) {
-        this.p2pService.registerBlockReceivedCallback(handler);
-    }
-    /**
-     * Requests the transactions with the given hashes from the network.
-     *
-     * If a transaction can be retrieved, it will be returned, if not an undefined
-     * will be returned. In place.
-     *
-     * @param txHashes - The hashes of the transactions to request.
-     * @returns A promise that resolves to an array of transactions or undefined.
-     */
-    requestTxs(txHashes) {
-        const requestPromises = txHashes.map(txHash => this.requestTxByHash(txHash));
-        return Promise.all(requestPromises);
-    }
-    /**
-     * Uses the Request Response protocol to request a transaction from the network.
-     *
-     * If the underlying request response protocol fails, then we return undefined.
-     * If it succeeds then we add the transaction to our transaction pool and return.
-     *
-     * @param txHash - The hash of the transaction to request.
-     * @returns A promise that resolves to a transaction or undefined.
-     */
-    async requestTxByHash(txHash) {
-        const tx = await this.p2pService.sendRequest(TX_REQ_PROTOCOL, txHash);
-        this.log.debug(`Requested ${txHash.toString()} from peer | success = ${!!tx}`);
-        if (tx) {
-            await this.txPool.addTxs([tx]);
-        }
-        return tx;
-    }
-    /**
-     * Returns all transactions in the transaction pool.
-     * @returns An array of Txs.
-     */
-    getTxs(filter) {
-        if (filter === 'all') {
-            return this.txPool.getAllTxs();
-        }
-        else if (filter === 'mined') {
-            return this.txPool
-                .getMinedTxHashes()
-                .map(txHash => this.txPool.getTxByHash(txHash))
-                .filter((tx) => !!tx);
-        }
-        else if (filter === 'pending') {
-            return this.txPool
-                .getPendingTxHashes()
-                .map(txHash => this.txPool.getTxByHash(txHash))
-                .filter((tx) => !!tx);
-        }
-        else {
-            const _ = filter;
-            throw new Error(`Unknown filter ${filter}`);
-        }
-    }
-    /**
-     * Returns a transaction in the transaction pool by its hash.
-     * @param txHash - Hash of the transaction to look for in the pool.
-     * @returns A single tx or undefined.
-     */
-    getTxByHash(txHash) {
-        return this.txPool.getTxByHash(txHash);
-    }
-    /**
-     * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
-     * @param tx - The tx to verify.
-     * @returns Empty promise.
-     **/
-    async sendTx(tx) {
-        __classPrivateFieldGet(this, _P2PClient_instances, "m", _P2PClient_assertIsReady).call(this);
-        await this.txPool.addTxs([tx]);
-        this.p2pService.propagate(tx);
-    }
-    /**
-     * Returns whether the given tx hash is flagged as pending or mined.
-     * @param txHash - Hash of the tx to query.
-     * @returns Pending or mined depending on its status, or undefined if not found.
-     */
-    getTxStatus(txHash) {
-        return this.txPool.getTxStatus(txHash);
-    }
-    getEnr() {
-        return this.p2pService.getEnr();
-    }
-    /**
-     * Deletes the 'txs' from the pool.
-     * NOT used if we use sendTx as reconcileTxPool will handle this.
-     * @param txHashes - Hashes of the transactions to delete.
-     * @returns Empty promise.
-     **/
-    async deleteTxs(txHashes) {
-        __classPrivateFieldGet(this, _P2PClient_instances, "m", _P2PClient_assertIsReady).call(this);
-        await this.txPool.deleteTxs(txHashes);
-    }
-    /**
-     * Public function to check if the p2p client is fully synced and ready to receive txs.
-     * @returns True if the P2P client is ready to receive txs.
-     */
-    isReady() {
-        return this.currentState === P2PClientState.RUNNING;
-    }
-    /**
-     * Public function to check the latest block number that the P2P client is synced to.
-     * @returns Block number of latest L2 Block we've synced with.
-     */
-    getSyncedLatestBlockNum() {
-        return this.synchedLatestBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
-    }
-    /**
-     * Public function to check the latest proven block number that the P2P client is synced to.
-     * @returns Block number of latest proven L2 Block we've synced with.
-     */
-    getSyncedProvenBlockNum() {
-        return this.synchedProvenBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
-    }
-    /**
-     * Method to check the status the p2p client.
-     * @returns Information about p2p client status: state & syncedToBlockNum.
-     */
-    getStatus() {
-        return Promise.resolve({
-            state: this.currentState,
-            syncedToL2Block: this.getSyncedLatestBlockNum(),
-        });
-    }
-    /**
-     * Mark all txs from these blocks as mined.
-     * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
-     * @returns Empty promise.
-     */
-    async markTxsAsMinedFromBlocks(blocks) {
-        for (const block of blocks) {
-            const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
-            await this.txPool.markAsMined(txHashes);
-        }
-    }
-    /**
-     * Deletes txs from these blocks.
-     * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
-     * @returns Empty promise.
-     */
-    async deleteTxsFromBlocks(blocks) {
-        this.log.debug(`Deleting txs from blocks ${blocks[0].number} to ${blocks[blocks.length - 1].number}`);
-        for (const block of blocks) {
-            const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
-            await this.txPool.deleteTxs(txHashes);
-        }
-    }
-    /**
-     * Handles new mined blocks by marking the txs in them as mined.
-     * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
-     * @returns Empty promise.
-     */
-    async handleLatestL2Blocks(blocks) {
-        if (!blocks.length) {
-            return Promise.resolve();
-        }
-        await this.markTxsAsMinedFromBlocks(blocks);
-        const lastBlockNum = blocks[blocks.length - 1].number;
-        await this.synchedLatestBlockNumber.set(lastBlockNum);
-        this.log.debug(`Synched to latest block ${lastBlockNum}`);
-        await this.startServiceIfSynched();
-    }
-    /**
-     * Handles new proven blocks by deleting the txs in them, or by deleting the txs in blocks `keepProvenTxsFor` ago.
-     * @param blocks - A list of proven L2 blocks.
-     * @returns Empty promise.
-     */
-    async handleProvenL2Blocks(blocks) {
-        if (!blocks.length) {
-            return Promise.resolve();
-        }
-        const firstBlockNum = blocks[0].number;
-        const lastBlockNum = blocks[blocks.length - 1].number;
-        if (this.keepProvenTxsFor === 0) {
-            await this.deleteTxsFromBlocks(blocks);
-        }
-        else if (lastBlockNum - this.keepProvenTxsFor >= INITIAL_L2_BLOCK_NUM) {
-            const fromBlock = Math.max(INITIAL_L2_BLOCK_NUM, firstBlockNum - this.keepProvenTxsFor);
-            const toBlock = lastBlockNum - this.keepProvenTxsFor;
-            const limit = toBlock - fromBlock + 1;
-            const blocksToDeleteTxsFrom = await this.l2BlockSource.getBlocks(fromBlock, limit, true);
-            await this.deleteTxsFromBlocks(blocksToDeleteTxsFrom);
-        }
-        await this.synchedProvenBlockNumber.set(lastBlockNum);
-        this.log.debug(`Synched to proven block ${lastBlockNum}`);
-        const provenEpochNumber = await this.l2BlockSource.getProvenL2EpochNumber();
-        if (provenEpochNumber !== undefined) {
-            this.epochProofQuotePool.deleteQuotesToEpoch(BigInt(provenEpochNumber));
-        }
-        await this.startServiceIfSynched();
-    }
-    async startServiceIfSynched() {
-        if (this.currentState === P2PClientState.SYNCHING &&
-            this.getSyncedLatestBlockNum() >= this.latestBlockNumberAtStart &&
-            this.getSyncedProvenBlockNum() >= this.provenBlockNumberAtStart) {
-            this.log.debug(`Synched to blocks at start`);
-            this.setCurrentState(P2PClientState.RUNNING);
-            if (this.syncResolve !== undefined) {
-                this.syncResolve();
-                await this.p2pService.start();
+            broadcastEpochProofQuote(quote) {
+                __classPrivateFieldGet(this, _P2PClient_instances, "m", _P2PClient_assertIsReady).call(this);
+                this.epochProofQuotePool.addQuote(quote);
+                return this.p2pService.propagate(quote);
             }
-        }
-    }
-    /**
-     * Method to set the value of the current state.
-     * @param newState - New state value.
-     */
-    setCurrentState(newState) {
-        this.currentState = newState;
-        this.log.debug(`Moved to state ${P2PClientState[this.currentState]}`);
-    }
-    async publishStoredTxs() {
-        if (!this.isReady()) {
-            return;
-        }
-        const txs = this.txPool.getAllTxs();
-        if (txs.length > 0) {
-            this.log.debug(`Publishing ${txs.length} previously stored txs`);
-            await Promise.all(txs.map(tx => this.p2pService.propagate(tx)));
-        }
-    }
-}
-_P2PClient_instances = new WeakSet(), _P2PClient_assertIsReady = function _P2PClient_assertIsReady() {
-    if (!this.isReady()) {
-        throw new Error('P2P client not ready');
-    }
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"p2p_client.js","sourceRoot":"","sources":["../../src/client/p2p_client.ts"],"names":[],"mappings":"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"}
+            /**
+             * Starts the P2P client.
+             * @returns An empty promise signalling the synching process.
+             */
+            async start() {
+                if (this.currentState === P2PClientState.STOPPED) {
+                    throw new Error('P2P client already stopped');
+                }
+                if (this.currentState !== P2PClientState.IDLE) {
+                    return this.syncPromise;
+                }
+                // get the current latest block numbers
+                this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
+                this.provenBlockNumberAtStart = await this.l2BlockSource.getProvenBlockNumber();
+                const syncedLatestBlock = this.getSyncedLatestBlockNum() + 1;
+                const syncedProvenBlock = this.getSyncedProvenBlockNum() + 1;
+                // if there are blocks to be retrieved, go to a synching state
+                if (syncedLatestBlock <= this.latestBlockNumberAtStart || syncedProvenBlock <= this.provenBlockNumberAtStart) {
+                    this.setCurrentState(P2PClientState.SYNCHING);
+                    this.syncPromise = new Promise(resolve => {
+                        this.syncResolve = resolve;
+                    });
+                    this.log.verbose(`Starting sync from ${syncedLatestBlock} (last proven ${syncedProvenBlock})`);
+                }
+                else {
+                    // if no blocks to be retrieved, go straight to running
+                    this.setCurrentState(P2PClientState.RUNNING);
+                    this.syncPromise = Promise.resolve();
+                    await this.p2pService.start();
+                    this.log.verbose(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
+                }
+                // publish any txs in TxPool after its doing initial sync
+                this.syncPromise = this.syncPromise.then(() => this.publishStoredTxs());
+                // start looking for further blocks
+                const processLatest = async () => {
+                    while (!this.stopping) {
+                        await this.latestBlockDownloader.getBlocks(1).then(this.handleLatestL2Blocks.bind(this));
+                    }
+                };
+                const processProven = async () => {
+                    while (!this.stopping) {
+                        await this.provenBlockDownloader.getBlocks(1).then(this.handleProvenL2Blocks.bind(this));
+                    }
+                };
+                this.runningPromise = Promise.all([processLatest(), processProven()]).then(() => { });
+                this.latestBlockDownloader.start(syncedLatestBlock);
+                this.provenBlockDownloader.start(syncedLatestBlock);
+                this.log.verbose(`Started block downloader from block ${syncedLatestBlock}`);
+                return this.syncPromise;
+            }
+            /**
+             * Allows consumers to stop the instance of the P2P client.
+             * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
+             */
+            async stop() {
+                this.log.debug('Stopping p2p client...');
+                this.stopping = true;
+                await this.p2pService.stop();
+                this.log.debug('Stopped p2p service');
+                await this.latestBlockDownloader.stop();
+                await this.provenBlockDownloader.stop();
+                this.log.debug('Stopped block downloader');
+                await this.runningPromise;
+                this.setCurrentState(P2PClientState.STOPPED);
+                this.log.info('P2P client stopped.');
+            }
+            broadcastProposal(proposal) {
+                this.log.verbose(`Broadcasting proposal ${proposal.p2pMessageIdentifier()} to peers`);
+                return this.p2pService.propagate(proposal);
+            }
+            getAttestationsForSlot(slot, proposalId) {
+                return Promise.resolve(this.attestationPool.getAttestationsForSlot(slot, proposalId));
+            }
+            // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
+            // ^ This pattern is not my favorite (md)
+            registerBlockProposalHandler(handler) {
+                this.p2pService.registerBlockReceivedCallback(handler);
+            }
+            /**
+             * Requests the transactions with the given hashes from the network.
+             *
+             * If a transaction can be retrieved, it will be returned, if not an undefined
+             * will be returned. In place.
+             *
+             * @param txHashes - The hashes of the transactions to request.
+             * @returns A promise that resolves to an array of transactions or undefined.
+             */
+            requestTxs(txHashes) {
+                const requestPromises = txHashes.map(txHash => this.requestTxByHash(txHash));
+                return Promise.all(requestPromises);
+            }
+            /**
+             * Uses the Request Response protocol to request a transaction from the network.
+             *
+             * If the underlying request response protocol fails, then we return undefined.
+             * If it succeeds then we add the transaction to our transaction pool and return.
+             *
+             * @param txHash - The hash of the transaction to request.
+             * @returns A promise that resolves to a transaction or undefined.
+             */
+            async requestTxByHash(txHash) {
+                const tx = await this.p2pService.sendRequest(TX_REQ_PROTOCOL, txHash);
+                this.log.debug(`Requested ${txHash.toString()} from peer | success = ${!!tx}`);
+                if (tx) {
+                    await this.txPool.addTxs([tx]);
+                }
+                return tx;
+            }
+            /**
+             * Returns all transactions in the transaction pool.
+             * @returns An array of Txs.
+             */
+            getTxs(filter) {
+                if (filter === 'all') {
+                    return this.txPool.getAllTxs();
+                }
+                else if (filter === 'mined') {
+                    return this.txPool
+                        .getMinedTxHashes()
+                        .map(txHash => this.txPool.getTxByHash(txHash))
+                        .filter((tx) => !!tx);
+                }
+                else if (filter === 'pending') {
+                    return this.txPool
+                        .getPendingTxHashes()
+                        .map(txHash => this.txPool.getTxByHash(txHash))
+                        .filter((tx) => !!tx);
+                }
+                else {
+                    const _ = filter;
+                    throw new Error(`Unknown filter ${filter}`);
+                }
+            }
+            /**
+             * Returns a transaction in the transaction pool by its hash.
+             * @param txHash - Hash of the transaction to look for in the pool.
+             * @returns A single tx or undefined.
+             */
+            getTxByHash(txHash) {
+                return this.txPool.getTxByHash(txHash);
+            }
+            /**
+             * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
+             * @param tx - The tx to verify.
+             * @returns Empty promise.
+             **/
+            async sendTx(tx) {
+                __classPrivateFieldGet(this, _P2PClient_instances, "m", _P2PClient_assertIsReady).call(this);
+                await this.txPool.addTxs([tx]);
+                this.p2pService.propagate(tx);
+            }
+            /**
+             * Returns whether the given tx hash is flagged as pending or mined.
+             * @param txHash - Hash of the tx to query.
+             * @returns Pending or mined depending on its status, or undefined if not found.
+             */
+            getTxStatus(txHash) {
+                return this.txPool.getTxStatus(txHash);
+            }
+            getEnr() {
+                return this.p2pService.getEnr();
+            }
+            /**
+             * Deletes the 'txs' from the pool.
+             * NOT used if we use sendTx as reconcileTxPool will handle this.
+             * @param txHashes - Hashes of the transactions to delete.
+             * @returns Empty promise.
+             **/
+            async deleteTxs(txHashes) {
+                __classPrivateFieldGet(this, _P2PClient_instances, "m", _P2PClient_assertIsReady).call(this);
+                await this.txPool.deleteTxs(txHashes);
+            }
+            /**
+             * Public function to check if the p2p client is fully synced and ready to receive txs.
+             * @returns True if the P2P client is ready to receive txs.
+             */
+            isReady() {
+                return this.currentState === P2PClientState.RUNNING;
+            }
+            /**
+             * Public function to check the latest block number that the P2P client is synced to.
+             * @returns Block number of latest L2 Block we've synced with.
+             */
+            getSyncedLatestBlockNum() {
+                return this.synchedLatestBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
+            }
+            /**
+             * Public function to check the latest proven block number that the P2P client is synced to.
+             * @returns Block number of latest proven L2 Block we've synced with.
+             */
+            getSyncedProvenBlockNum() {
+                return this.synchedProvenBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
+            }
+            /**
+             * Method to check the status the p2p client.
+             * @returns Information about p2p client status: state & syncedToBlockNum.
+             */
+            async getStatus() {
+                const blockNumber = this.getSyncedLatestBlockNum();
+                const blockHash = blockNumber == 0
+                    ? ''
+                    : await this.l2BlockSource.getBlockHeader(blockNumber).then(header => header?.hash().toString());
+                return Promise.resolve({
+                    state: this.currentState,
+                    syncedToL2Block: { number: blockNumber, hash: blockHash },
+                });
+            }
+            /**
+             * Mark all txs from these blocks as mined.
+             * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+             * @returns Empty promise.
+             */
+            async markTxsAsMinedFromBlocks(blocks) {
+                for (const block of blocks) {
+                    const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
+                    await this.txPool.markAsMined(txHashes);
+                }
+            }
+            /**
+             * Deletes txs from these blocks.
+             * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+             * @returns Empty promise.
+             */
+            async deleteTxsFromBlocks(blocks) {
+                this.log.debug(`Deleting txs from blocks ${blocks[0].number} to ${blocks[blocks.length - 1].number}`);
+                for (const block of blocks) {
+                    const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
+                    await this.txPool.deleteTxs(txHashes);
+                }
+            }
+            /**
+             * Handles new mined blocks by marking the txs in them as mined.
+             * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+             * @returns Empty promise.
+             */
+            async handleLatestL2Blocks(blocks) {
+                if (!blocks.length) {
+                    return Promise.resolve();
+                }
+                await this.markTxsAsMinedFromBlocks(blocks);
+                const lastBlockNum = blocks[blocks.length - 1].number;
+                await this.synchedLatestBlockNumber.set(lastBlockNum);
+                this.log.debug(`Synched to latest block ${lastBlockNum}`);
+                await this.startServiceIfSynched();
+            }
+            /**
+             * Handles new proven blocks by deleting the txs in them, or by deleting the txs in blocks `keepProvenTxsFor` ago.
+             * @param blocks - A list of proven L2 blocks.
+             * @returns Empty promise.
+             */
+            async handleProvenL2Blocks(blocks) {
+                if (!blocks.length) {
+                    return Promise.resolve();
+                }
+                const firstBlockNum = blocks[0].number;
+                const lastBlockNum = blocks[blocks.length - 1].number;
+                if (this.keepProvenTxsFor === 0) {
+                    await this.deleteTxsFromBlocks(blocks);
+                }
+                else if (lastBlockNum - this.keepProvenTxsFor >= INITIAL_L2_BLOCK_NUM) {
+                    const fromBlock = Math.max(INITIAL_L2_BLOCK_NUM, firstBlockNum - this.keepProvenTxsFor);
+                    const toBlock = lastBlockNum - this.keepProvenTxsFor;
+                    const limit = toBlock - fromBlock + 1;
+                    const blocksToDeleteTxsFrom = await this.l2BlockSource.getBlocks(fromBlock, limit, true);
+                    await this.deleteTxsFromBlocks(blocksToDeleteTxsFrom);
+                }
+                await this.synchedProvenBlockNumber.set(lastBlockNum);
+                this.log.debug(`Synched to proven block ${lastBlockNum}`);
+                const provenEpochNumber = await this.l2BlockSource.getProvenL2EpochNumber();
+                if (provenEpochNumber !== undefined) {
+                    this.epochProofQuotePool.deleteQuotesToEpoch(BigInt(provenEpochNumber));
+                }
+                await this.startServiceIfSynched();
+            }
+            async startServiceIfSynched() {
+                if (this.currentState === P2PClientState.SYNCHING &&
+                    this.getSyncedLatestBlockNum() >= this.latestBlockNumberAtStart &&
+                    this.getSyncedProvenBlockNum() >= this.provenBlockNumberAtStart) {
+                    this.log.debug(`Synched to blocks at start`);
+                    this.setCurrentState(P2PClientState.RUNNING);
+                    if (this.syncResolve !== undefined) {
+                        this.syncResolve();
+                        await this.p2pService.start();
+                    }
+                }
+            }
+            /**
+             * Method to set the value of the current state.
+             * @param newState - New state value.
+             */
+            setCurrentState(newState) {
+                this.currentState = newState;
+                this.log.debug(`Moved to state ${P2PClientState[this.currentState]}`);
+            }
+            async publishStoredTxs() {
+                if (!this.isReady()) {
+                    return;
+                }
+                const txs = this.txPool.getAllTxs();
+                if (txs.length > 0) {
+                    this.log.debug(`Publishing ${txs.length} previously stored txs`);
+                    await Promise.all(txs.map(tx => this.p2pService.propagate(tx)));
+                }
+            }
+        },
+        _P2PClient_instances = new WeakSet(),
+        _P2PClient_assertIsReady = function _P2PClient_assertIsReady() {
+            if (!this.isReady()) {
+                throw new Error('P2P client not ready');
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _broadcastProposal_decorators = [trackSpan('p2pClient.broadcastProposal', proposal => ({
+                    [Attributes.BLOCK_NUMBER]: proposal.payload.header.globalVariables.blockNumber.toNumber(),
+                    [Attributes.SLOT_NUMBER]: proposal.payload.header.globalVariables.slotNumber.toNumber(),
+                    [Attributes.BLOCK_ARCHIVE]: proposal.archive.toString(),
+                    [Attributes.P2P_ID]: proposal.p2pMessageIdentifier().toString(),
+                }))];
+            __esDecorate(_a, null, _broadcastProposal_decorators, { kind: "method", name: "broadcastProposal", static: false, private: false, access: { has: obj => "broadcastProposal" in obj, get: obj => obj.broadcastProposal }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { P2PClient };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"p2p_client.js","sourceRoot":"","sources":["../../src/client/p2p_client.ts"],"names":[],"mappings":";AAAA,OAAO,EAKL,iBAAiB,GAKlB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,UAAU,EAAwB,UAAU,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIlG,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAKnD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAGlE;;GAEG;AACH,MAAM,CAAN,IAAY,cAKX;AALD,WAAY,cAAc;IACxB,mDAAI,CAAA;IACJ,2DAAQ,CAAA;IACR,yDAAO,CAAA;IACP,yDAAO,CAAA;AACT,CAAC,EALW,cAAc,KAAd,cAAc,QAKzB;AAwID;;GAEG;IACU,SAAS;;sBAAS,UAAU;;;sBAA5B,SAAU,SAAQ,WAAU;YA0BvC;;;;;;;;eAQG;YACH,YACE,KAAmB,EACX,aAA4B,EACpC,QAAkB,EACV,UAAsB,EACtB,gBAAwB,EAChC,eAAgC,EACxB,MAAM,iBAAiB,CAAC,WAAW,CAAC;gBAE5C,KAAK,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;;gBAP5B,kBAAa,IArCZ,mDAAS,EAqCV,aAAa,EAAe;gBAE5B,eAAU,GAAV,UAAU,CAAY;gBACtB,qBAAgB,GAAhB,gBAAgB,CAAQ;gBAExB,QAAG,GAAH,GAAG,CAAiC;gBAnC9C,6DAA6D;gBACrD,aAAQ,GAAG,KAAK,CAAC;gBAKjB,iBAAY,GAAG,cAAc,CAAC,IAAI,CAAC;gBACnC,gBAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;gBAChC,gBAAW,GAAgB,SAAS,CAAC;gBACrC,6BAAwB,GAAG,CAAC,CAAC,CAAC;gBAC9B,6BAAwB,GAAG,CAAC,CAAC,CAAC;gBA6BpC,MAAM,EAAE,oBAAoB,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,GAAG,mBAAmB,EAAE,CAAC;gBACnG,MAAM,gBAAgB,GAAG,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;gBACzF,wGAAwG;gBACxG,wGAAwG;gBACxG,mDAAmD;gBACnD,IAAI,CAAC,qBAAqB,GAAG,IAAI,iBAAiB,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC;gBACpF,IAAI,CAAC,qBAAqB,GAAG,IAAI,iBAAiB,CAAC,aAAa,EAAE,EAAE,GAAG,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;gBAEzG,IAAI,CAAC,wBAAwB,GAAG,KAAK,CAAC,aAAa,CAAC,wBAAwB,CAAC,CAAC;gBAC9E,IAAI,CAAC,wBAAwB,GAAG,KAAK,CAAC,aAAa,CAAC,+BAA+B,CAAC,CAAC;gBAErF,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;gBAC9B,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC;gBAChD,IAAI,CAAC,mBAAmB,GAAG,QAAQ,CAAC,mBAAmB,CAAC;YAC1D,CAAC;YAQD,mBAAmB,CAAC,KAAa;gBAC/B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YACpE,CAAC;YAED,wBAAwB,CAAC,KAAsB;gBAC7C,uBAAA,IAAI,sDAAe,MAAnB,IAAI,CAAiB,CAAC;gBACtB,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBACzC,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YAC1C,CAAC;YAED;;;eAGG;YACI,KAAK,CAAC,KAAK;gBAChB,IAAI,IAAI,CAAC,YAAY,KAAK,cAAc,CAAC,OAAO,EAAE,CAAC;oBACjD,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;gBAChD,CAAC;gBACD,IAAI,IAAI,CAAC,YAAY,KAAK,cAAc,CAAC,IAAI,EAAE,CAAC;oBAC9C,OAAO,IAAI,CAAC,WAAW,CAAC;gBAC1B,CAAC;gBAED,uCAAuC;gBACvC,IAAI,CAAC,wBAAwB,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC;gBAC1E,IAAI,CAAC,wBAAwB,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,oBAAoB,EAAE,CAAC;gBAEhF,MAAM,iBAAiB,GAAG,IAAI,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC;gBAC7D,MAAM,iBAAiB,GAAG,IAAI,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC;gBAE7D,8DAA8D;gBAC9D,IAAI,iBAAiB,IAAI,IAAI,CAAC,wBAAwB,IAAI,iBAAiB,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;oBAC7G,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;oBAC9C,IAAI,CAAC,WAAW,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;wBACvC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;oBAC7B,CAAC,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,sBAAsB,iBAAiB,iBAAiB,iBAAiB,GAAG,CAAC,CAAC;gBACjG,CAAC;qBAAM,CAAC;oBACN,uDAAuD;oBACvD,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;oBAC7C,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;oBACrC,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;oBAC9B,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,iBAAiB,YAAY,iBAAiB,gCAAgC,CAAC,CAAC;gBAC5G,CAAC;gBAED,yDAAyD;gBACzD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;gBAExE,mCAAmC;gBACnC,MAAM,aAAa,GAAG,KAAK,IAAI,EAAE;oBAC/B,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;wBACtB,MAAM,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;oBAC3F,CAAC;gBACH,CAAC,CAAC;gBACF,MAAM,aAAa,GAAG,KAAK,IAAI,EAAE;oBAC/B,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;wBACtB,MAAM,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;oBAC3F,CAAC;gBACH,CAAC,CAAC;gBAEF,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;gBACrF,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;gBACpD,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;gBACpD,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,uCAAuC,iBAAiB,EAAE,CAAC,CAAC;gBAE7E,OAAO,IAAI,CAAC,WAAW,CAAC;YAC1B,CAAC;YAED;;;eAGG;YACI,KAAK,CAAC,IAAI;gBACf,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;gBACzC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACrB,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;gBAC7B,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;gBACtC,MAAM,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAAE,CAAC;gBACxC,MAAM,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAAE,CAAC;gBACxC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;gBAC3C,MAAM,IAAI,CAAC,cAAc,CAAC;gBAC1B,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;gBAC7C,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACvC,CAAC;YAQM,iBAAiB,CAAC,QAAuB;gBAC9C,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,yBAAyB,QAAQ,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC;gBACtF,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YAC7C,CAAC;YAEM,sBAAsB,CAAC,IAAY,EAAE,UAAkB;gBAC5D,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;YACxF,CAAC;YAED,sEAAsE;YACtE,yCAAyC;YAClC,4BAA4B,CAAC,OAAwE;gBAC1G,IAAI,CAAC,UAAU,CAAC,6BAA6B,CAAC,OAAO,CAAC,CAAC;YACzD,CAAC;YAED;;;;;;;;eAQG;YACI,UAAU,CAAC,QAAkB;gBAClC,MAAM,eAAe,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC7E,OAAO,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YACtC,CAAC;YAED;;;;;;;;eAQG;YACI,KAAK,CAAC,eAAe,CAAC,MAAc;gBACzC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;gBAEtE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,MAAM,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC/E,IAAI,EAAE,EAAE,CAAC;oBACP,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACjC,CAAC;gBAED,OAAO,EAAE,CAAC;YACZ,CAAC;YAED;;;eAGG;YACI,MAAM,CAAC,MAAmC;gBAC/C,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;oBACrB,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBACjC,CAAC;qBAAM,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;oBAC9B,OAAO,IAAI,CAAC,MAAM;yBACf,gBAAgB,EAAE;yBAClB,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;yBAC9C,MAAM,CAAC,CAAC,EAAE,EAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACpC,CAAC;qBAAM,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBAChC,OAAO,IAAI,CAAC,MAAM;yBACf,kBAAkB,EAAE;yBACpB,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;yBAC9C,MAAM,CAAC,CAAC,EAAE,EAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACpC,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,GAAU,MAAM,CAAC;oBACxB,MAAM,IAAI,KAAK,CAAC,kBAAkB,MAAM,EAAE,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC;YAED;;;;eAIG;YACH,WAAW,CAAC,MAAc;gBACxB,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACzC,CAAC;YAED;;;;gBAII;YACG,KAAK,CAAC,MAAM,CAAC,EAAM;gBACxB,uBAAA,IAAI,sDAAe,MAAnB,IAAI,CAAiB,CAAC;gBACtB,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC/B,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;YAChC,CAAC;YAED;;;;eAIG;YACI,WAAW,CAAC,MAAc;gBAC/B,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACzC,CAAC;YAEM,MAAM;gBACX,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YAClC,CAAC;YAED;;;;;gBAKI;YACG,KAAK,CAAC,SAAS,CAAC,QAAkB;gBACvC,uBAAA,IAAI,sDAAe,MAAnB,IAAI,CAAiB,CAAC;gBACtB,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACxC,CAAC;YAED;;;eAGG;YACI,OAAO;gBACZ,OAAO,IAAI,CAAC,YAAY,KAAK,cAAc,CAAC,OAAO,CAAC;YACtD,CAAC;YAED;;;eAGG;YACI,uBAAuB;gBAC5B,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,EAAE,IAAI,oBAAoB,GAAG,CAAC,CAAC;YACzE,CAAC;YAED;;;eAGG;YACI,uBAAuB;gBAC5B,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,EAAE,IAAI,oBAAoB,GAAG,CAAC,CAAC;YACzE,CAAC;YAED;;;eAGG;YACI,KAAK,CAAC,SAAS;gBACpB,MAAM,WAAW,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;gBACnD,MAAM,SAAS,GACb,WAAW,IAAI,CAAC;oBACd,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACrG,OAAO,OAAO,CAAC,OAAO,CAAC;oBACrB,KAAK,EAAE,IAAI,CAAC,YAAY;oBACxB,eAAe,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;iBAC1C,CAAC,CAAC;YACrB,CAAC;YAED;;;;eAIG;YACK,KAAK,CAAC,wBAAwB,CAAC,MAAiB;gBACtD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;oBAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBACvE,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;gBAC1C,CAAC;YACH,CAAC;YAED;;;;eAIG;YACK,KAAK,CAAC,mBAAmB,CAAC,MAAiB;gBACjD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,4BAA4B,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;gBACtG,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;oBAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBACvE,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;YAED;;;;eAIG;YACK,KAAK,CAAC,oBAAoB,CAAC,MAAiB;gBAClD,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;oBACnB,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;gBAC3B,CAAC;gBACD,MAAM,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;gBAC5C,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;gBACtD,MAAM,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;gBACtD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,2BAA2B,YAAY,EAAE,CAAC,CAAC;gBAC1D,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACrC,CAAC;YAED;;;;eAIG;YACK,KAAK,CAAC,oBAAoB,CAAC,MAAiB;gBAClD,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;oBACnB,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;gBAC3B,CAAC;gBAED,MAAM,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;gBACvC,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;gBAEtD,IAAI,IAAI,CAAC,gBAAgB,KAAK,CAAC,EAAE,CAAC;oBAChC,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;gBACzC,CAAC;qBAAM,IAAI,YAAY,GAAG,IAAI,CAAC,gBAAgB,IAAI,oBAAoB,EAAE,CAAC;oBACxE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,oBAAoB,EAAE,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC;oBACxF,MAAM,OAAO,GAAG,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC;oBACrD,MAAM,KAAK,GAAG,OAAO,GAAG,SAAS,GAAG,CAAC,CAAC;oBACtC,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;oBACzF,MAAM,IAAI,CAAC,mBAAmB,CAAC,qBAAqB,CAAC,CAAC;gBACxD,CAAC;gBAED,MAAM,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;gBACtD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,2BAA2B,YAAY,EAAE,CAAC,CAAC;gBAC1D,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,sBAAsB,EAAE,CAAC;gBAC5E,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;oBACpC,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;gBAC1E,CAAC;gBACD,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACrC,CAAC;YAEO,KAAK,CAAC,qBAAqB;gBACjC,IACE,IAAI,CAAC,YAAY,KAAK,cAAc,CAAC,QAAQ;oBAC7C,IAAI,CAAC,uBAAuB,EAAE,IAAI,IAAI,CAAC,wBAAwB;oBAC/D,IAAI,CAAC,uBAAuB,EAAE,IAAI,IAAI,CAAC,wBAAwB,EAC/D,CAAC;oBACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;oBAC7C,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;oBAC7C,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;wBACnC,IAAI,CAAC,WAAW,EAAE,CAAC;wBACnB,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;oBAChC,CAAC;gBACH,CAAC;YACH,CAAC;YAED;;;eAGG;YACK,eAAe,CAAC,QAAwB;gBAC9C,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC;gBAC7B,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,kBAAkB,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;YACxE,CAAC;YAEO,KAAK,CAAC,gBAAgB;gBAC5B,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;oBACpB,OAAO;gBACT,CAAC;gBAED,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBACpC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACnB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,MAAM,wBAAwB,CAAC,CAAC;oBACjE,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAClE,CAAC;YACH,CAAC;;;;YAtWC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;gBACpB,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;;;6CAsFA,SAAS,CAAC,6BAA6B,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;oBACrD,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,WAAW,CAAC,QAAQ,EAAE;oBACzF,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE;oBACvF,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE;oBACvD,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,oBAAoB,EAAE,CAAC,QAAQ,EAAE;iBAChE,CAAC,CAAC;YACH,oMAAO,iBAAiB,6DAGvB;;;;;SAjKU,SAAS"}