@aztec/ethereum 0.74.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/l1_tx_utils.js

@@ -1,15 +1,15 @@
 import { compactArray, times } from '@aztec/foundation/collection';
-import { bigintConfigHelper, getDefaultConfig, numberConfigHelper, } from '@aztec/foundation/config';
+import { bigintConfigHelper, getDefaultConfig, numberConfigHelper } from '@aztec/foundation/config';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
-import { MethodNotFoundRpcError, MethodNotSupportedRpcError, formatGwei, getContractError, hexToBytes, } from 'viem';
+import { MethodNotFoundRpcError, MethodNotSupportedRpcError, formatGwei, getContractError, hexToBytes } from 'viem';
 import { formatViemError } from './utils.js';
 // 1_000_000_000 Gwei = 1 ETH
 // 1_000_000_000 Wei = 1 Gwei
 // 1_000_000_000_000_000_000 Wei = 1 ETH
-const WEI_CONST = 1000000000n;
+const WEI_CONST = 1_000_000_000n;
 // @note using this large gas limit to avoid the issue of `gas limit too low` when estimating gas in reth
-const LARGE_GAS_LIMIT = 10000000n;
+const LARGE_GAS_LIMIT = 10_000_000n;
 // setting a minimum bump percentage to 10% due to geth's implementation
 // https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/legacypool/list.go#L298
 const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10;
@@ -17,79 +17,84 @@ const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10;
 // https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/blobpool/config.go#L34
 const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
 // Avg ethereum block time is ~12s
-const BLOCK_TIME_MS = 12000;
+const BLOCK_TIME_MS = 12_000;
 export const l1TxUtilsConfigMappings = {
     gasLimitBufferPercentage: {
         description: 'How much to increase calculated gas limit by (percentage)',
         env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
-        ...numberConfigHelper(20),
+        ...numberConfigHelper(20)
     },
     minGwei: {
         description: 'Minimum gas price in gwei',
         env: 'L1_GAS_PRICE_MIN',
-        ...bigintConfigHelper(1n),
+        ...bigintConfigHelper(1n)
     },
     maxGwei: {
         description: 'Maximum gas price in gwei',
         env: 'L1_GAS_PRICE_MAX',
-        ...bigintConfigHelper(100n),
+        ...bigintConfigHelper(100n)
     },
     maxBlobGwei: {
         description: 'Maximum blob fee per gas in gwei',
         env: 'L1_BLOB_FEE_PER_GAS_MAX',
-        ...bigintConfigHelper(1500n),
+        ...bigintConfigHelper(1_500n)
     },
     priorityFeeBumpPercentage: {
         description: 'How much to increase priority fee by each attempt (percentage)',
         env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
-        ...numberConfigHelper(20),
+        ...numberConfigHelper(20)
     },
     priorityFeeRetryBumpPercentage: {
         description: 'How much to increase priority fee by each retry attempt (percentage)',
         env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
-        ...numberConfigHelper(50),
+        ...numberConfigHelper(50)
     },
     fixedPriorityFeePerGas: {
         description: 'Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage',
         env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
-        ...numberConfigHelper(0),
+        ...numberConfigHelper(0)
     },
     maxAttempts: {
         description: 'Maximum number of speed-up attempts',
         env: 'L1_TX_MONITOR_MAX_ATTEMPTS',
-        ...numberConfigHelper(3),
+        ...numberConfigHelper(3)
     },
     checkIntervalMs: {
         description: 'How often to check tx status',
         env: 'L1_TX_MONITOR_CHECK_INTERVAL_MS',
-        ...numberConfigHelper(10000),
+        ...numberConfigHelper(10_000)
     },
     stallTimeMs: {
         description: 'How long before considering tx stalled',
         env: 'L1_TX_MONITOR_STALL_TIME_MS',
-        ...numberConfigHelper(45000),
+        ...numberConfigHelper(45_000)
     },
     txTimeoutMs: {
         description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
         env: 'L1_TX_MONITOR_TX_TIMEOUT_MS',
-        ...numberConfigHelper(300000), // 5 mins
+        ...numberConfigHelper(300_000)
     },
     txPropagationMaxQueryAttempts: {
         description: 'How many attempts will be done to get a tx after it was sent',
         env: 'L1_TX_PROPAGATION_MAX_QUERY_ATTEMPTS',
-        ...numberConfigHelper(3),
-    },
+        ...numberConfigHelper(3)
+    }
 };
 export const defaultL1TxUtilsConfig = getDefaultConfig(l1TxUtilsConfigMappings);
 export class L1TxUtils {
-    constructor(publicClient, walletClient, logger, config) {
+    publicClient;
+    walletClient;
+    logger;
+    config;
+    interrupted;
+    constructor(publicClient, walletClient, logger, config){
         this.publicClient = publicClient;
         this.walletClient = walletClient;
         this.logger = logger;
         this.interrupted = false;
         this.config = {
             ...defaultL1TxUtilsConfig,
-            ...(config || {}),
+            ...config || {}
         };
     }
     interrupt() {
@@ -108,20 +113,21 @@ export class L1TxUtils {
         return this.publicClient.getBlockNumber();
     }
     /**
-     * Sends a transaction with gas estimation and pricing
-     * @param request - The transaction request (to, data, value)
-     * @param gasConfig - Optional gas configuration
-     * @returns The transaction hash and parameters used
-     */
-    async sendTransaction(request, _gasConfig, blobInputs) {
+   * Sends a transaction with gas estimation and pricing
+   * @param request - The transaction request (to, data, value)
+   * @param gasConfig - Optional gas configuration
+   * @returns The transaction hash and parameters used
+   */ async sendTransaction(request, _gasConfig, blobInputs) {
         try {
-            const gasConfig = { ...this.config, ..._gasConfig };
+            const gasConfig = {
+                ...this.config,
+                ..._gasConfig
+            };
             const account = this.walletClient.account;
             let gasLimit;
             if (gasConfig.gasLimit) {
                 gasLimit = gasConfig.gasLimit;
-            }
-            else {
+            } else {
                 gasLimit = await this.estimateGas(account, request);
             }
             const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
@@ -136,46 +142,56 @@ export class L1TxUtils {
                     gas: gasLimit,
                     maxFeePerGas: gasPrice.maxFeePerGas,
                     maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-                    maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
+                    maxFeePerBlobGas: gasPrice.maxFeePerBlobGas
                 });
-            }
-            else {
+            } else {
                 txHash = await this.walletClient.sendTransaction({
                     ...request,
                     gas: gasLimit,
                     maxFeePerGas: gasPrice.maxFeePerGas,
-                    maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
+                    maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas
                 });
             }
             this.logger?.verbose(`Sent L1 transaction ${txHash}`, {
                 gasLimit,
                 maxFeePerGas: formatGwei(gasPrice.maxFeePerGas),
                 maxPriorityFeePerGas: formatGwei(gasPrice.maxPriorityFeePerGas),
-                ...(gasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(gasPrice.maxFeePerBlobGas) }),
+                ...gasPrice.maxFeePerBlobGas && {
+                    maxFeePerBlobGas: formatGwei(gasPrice.maxFeePerBlobGas)
+                }
             });
-            return { txHash, gasLimit, gasPrice };
-        }
-        catch (err) {
+            return {
+                txHash,
+                gasLimit,
+                gasPrice
+            };
+        } catch (err) {
             const viemError = formatViemError(err);
-            this.logger?.error(`Failed to send L1 transaction`, viemError.message, { metaMessages: viemError.metaMessages });
+            this.logger?.error(`Failed to send L1 transaction`, viemError.message, {
+                metaMessages: viemError.metaMessages
+            });
             throw viemError;
         }
     }
     /**
-     * Monitors a transaction until completion, handling speed-ups if needed
-     * @param request - Original transaction request (needed for speed-ups)
-     * @param initialTxHash - Hash of the initial transaction
-     * @param params - Parameters used in the initial transaction
-     * @param gasConfig - Optional gas configuration
-     */
-    async monitorTransaction(request, initialTxHash, params, _gasConfig, _blobInputs, isCancelTx = false) {
+   * Monitors a transaction until completion, handling speed-ups if needed
+   * @param request - Original transaction request (needed for speed-ups)
+   * @param initialTxHash - Hash of the initial transaction
+   * @param params - Parameters used in the initial transaction
+   * @param gasConfig - Optional gas configuration
+   */ async monitorTransaction(request, initialTxHash, params, _gasConfig, _blobInputs, isCancelTx = false) {
         const isBlobTx = !!_blobInputs;
-        const gasConfig = { ...this.config, ..._gasConfig };
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
         const account = this.walletClient.account;
         const blobInputs = _blobInputs || {};
-        const makeGetTransactionBackoff = () => makeBackoff(times(gasConfig.txPropagationMaxQueryAttempts ?? 3, i => i + 1));
+        const makeGetTransactionBackoff = ()=>makeBackoff(times(gasConfig.txPropagationMaxQueryAttempts ?? 3, (i)=>i + 1));
         // Retry a few times, in case the tx is not yet propagated.
-        const tx = await retry(() => this.publicClient.getTransaction({ hash: initialTxHash }), `Getting L1 transaction ${initialTxHash}`, makeGetTransactionBackoff(), this.logger, true);
+        const tx = await retry(()=>this.publicClient.getTransaction({
+                hash: initialTxHash
+            }), `Getting L1 transaction ${initialTxHash}`, makeGetTransactionBackoff(), this.logger, true);
         if (!tx) {
             throw new Error(`Failed to get L1 transaction ${initialTxHash} to monitor`);
         }
@@ -183,39 +199,40 @@ export class L1TxUtils {
             throw new Error(`Failed to get L1 transaction ${initialTxHash} nonce`);
         }
         const nonce = tx.nonce;
-        const txHashes = new Set([initialTxHash]);
+        const txHashes = new Set([
+            initialTxHash
+        ]);
         let currentTxHash = initialTxHash;
         let attempts = 0;
         let lastAttemptSent = Date.now();
         let lastGasPrice = {
             maxFeePerGas: tx.maxFeePerGas,
             maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-            maxFeePerBlobGas: tx.maxFeePerBlobGas,
+            maxFeePerBlobGas: tx.maxFeePerBlobGas
         };
         const initialTxTime = lastAttemptSent;
         let txTimedOut = false;
-        const isTimedOut = () => (gasConfig.txTimeoutAt && Date.now() > gasConfig.txTimeoutAt.getTime()) ||
-            (gasConfig.txTimeoutMs !== undefined && Date.now() - initialTxTime > gasConfig.txTimeoutMs) ||
-            this.interrupted ||
-            false;
-        while (!txTimedOut) {
+        const isTimedOut = ()=>gasConfig.txTimeoutAt && Date.now() > gasConfig.txTimeoutAt.getTime() || gasConfig.txTimeoutMs !== undefined && Date.now() - initialTxTime > gasConfig.txTimeoutMs || this.interrupted || false;
+        while(!txTimedOut){
             try {
-                const currentNonce = await this.publicClient.getTransactionCount({ address: account.address });
+                const currentNonce = await this.publicClient.getTransactionCount({
+                    address: account.address
+                });
                 if (currentNonce > nonce) {
-                    for (const hash of txHashes) {
+                    for (const hash of txHashes){
                         try {
-                            const receipt = await this.publicClient.getTransactionReceipt({ hash });
+                            const receipt = await this.publicClient.getTransactionReceipt({
+                                hash
+                            });
                             if (receipt) {
                                 if (receipt.status === 'reverted') {
                                     this.logger?.error(`L1 transaction ${hash} reverted`, receipt);
-                                }
-                                else {
+                                } else {
                                     this.logger?.debug(`L1 transaction ${hash} mined`);
                                 }
                                 return receipt;
                             }
-                        }
-                        catch (err) {
+                        } catch (err) {
                             if (err instanceof Error && err.message.includes('reverted')) {
                                 throw formatViemError(err);
                             }
@@ -223,7 +240,9 @@ export class L1TxUtils {
                     }
                 }
                 // Retry a few times, in case the tx is not yet propagated.
-                const tx = await retry(() => this.publicClient.getTransaction({ hash: currentTxHash }), `Getting L1 transaction ${currentTxHash}`, makeGetTransactionBackoff(), this.logger, true);
+                const tx = await retry(()=>this.publicClient.getTransaction({
+                        hash: currentTxHash
+                    }), `Getting L1 transaction ${currentTxHash}`, makeGetTransactionBackoff(), this.logger, true);
                 const timePassed = Date.now() - lastAttemptSent;
                 if (tx && timePassed < gasConfig.stallTimeMs) {
                     this.logger?.debug(`L1 transaction ${currentTxHash} pending. Time passed: ${timePassed}ms.`);
@@ -237,19 +256,18 @@ export class L1TxUtils {
                 }
                 if (timePassed > gasConfig.stallTimeMs && attempts < gasConfig.maxAttempts) {
                     attempts++;
-                    const newGasPrice = await this.getGasPrice(gasConfig, isBlobTx, attempts, tx.maxFeePerGas && tx.maxPriorityFeePerGas
-                        ? {
-                            maxFeePerGas: tx.maxFeePerGas,
-                            maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-                            maxFeePerBlobGas: tx.maxFeePerBlobGas,
-                        }
-                        : undefined);
+                    const newGasPrice = await this.getGasPrice(gasConfig, isBlobTx, attempts, tx.maxFeePerGas && tx.maxPriorityFeePerGas ? {
+                        maxFeePerGas: tx.maxFeePerGas,
+                        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+                        maxFeePerBlobGas: tx.maxFeePerBlobGas
+                    } : undefined);
                     lastGasPrice = newGasPrice;
-                    this.logger?.debug(`L1 transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` +
-                        `with new priority fee ${formatGwei(newGasPrice.maxPriorityFeePerGas)} gwei`, {
+                    this.logger?.debug(`L1 transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` + `with new priority fee ${formatGwei(newGasPrice.maxPriorityFeePerGas)} gwei`, {
                         maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
                         maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
-                        ...(newGasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas) }),
+                        ...newGasPrice.maxFeePerBlobGas && {
+                            maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas)
+                        }
                     });
                     currentTxHash = await this.walletClient.sendTransaction({
                         ...request,
@@ -257,14 +275,13 @@ export class L1TxUtils {
                         nonce,
                         gas: params.gasLimit,
                         maxFeePerGas: newGasPrice.maxFeePerGas,
-                        maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas,
+                        maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas
                     });
                     txHashes.add(currentTxHash);
                     lastAttemptSent = Date.now();
                 }
                 await sleep(gasConfig.checkIntervalMs);
-            }
-            catch (err) {
+            } catch (err) {
                 const viemError = formatViemError(err);
                 this.logger?.warn(`Error monitoring L1 transaction ${currentTxHash}:`, viemError.message);
                 if (viemError.message?.includes('reverted')) {
@@ -277,60 +294,68 @@ export class L1TxUtils {
         }
         if (!isCancelTx) {
             // Fire cancellation without awaiting to avoid blocking the main thread
-            this.attemptTxCancellation(nonce, isBlobTx, lastGasPrice, attempts)
-                .then(cancelTxHash => {
+            this.attemptTxCancellation(nonce, isBlobTx, lastGasPrice, attempts).then((cancelTxHash)=>{
                 this.logger?.debug(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`);
-            })
-                .catch(err => {
+            }).catch((err)=>{
                 const viemError = formatViemError(err);
                 this.logger?.error(`Failed to send cancellation for timed out tx ${currentTxHash}:`, viemError.message, {
-                    metaMessages: viemError.metaMessages,
+                    metaMessages: viemError.metaMessages
                 });
             });
             this.logger?.error(`L1 transaction ${currentTxHash} timed out`, {
                 txHash: currentTxHash,
-                ...tx,
+                ...tx
             });
         }
         throw new Error(`L1 transaction ${currentTxHash} timed out`);
     }
     /**
-     * Sends a transaction and monitors it until completion
-     * @param request - The transaction request (to, data, value)
-     * @param gasConfig - Optional gas configuration
-     * @returns The receipt of the successful transaction
-     */
-    async sendAndMonitorTransaction(request, gasConfig, blobInputs) {
+   * Sends a transaction and monitors it until completion
+   * @param request - The transaction request (to, data, value)
+   * @param gasConfig - Optional gas configuration
+   * @returns The receipt of the successful transaction
+   */ async sendAndMonitorTransaction(request, gasConfig, blobInputs) {
         const { txHash, gasLimit, gasPrice } = await this.sendTransaction(request, gasConfig, blobInputs);
-        const receipt = await this.monitorTransaction(request, txHash, { gasLimit }, gasConfig, blobInputs);
-        return { receipt, gasPrice };
+        const receipt = await this.monitorTransaction(request, txHash, {
+            gasLimit
+        }, gasConfig, blobInputs);
+        return {
+            receipt,
+            gasPrice
+        };
     }
     /**
-     * Gets the current gas price with bounds checking
-     */
-    async getGasPrice(_gasConfig, isBlobTx = false, attempt = 0, previousGasPrice) {
-        const gasConfig = { ...this.config, ..._gasConfig };
-        const block = await this.publicClient.getBlock({ blockTag: 'latest' });
+   * Gets the current gas price with bounds checking
+   */ async getGasPrice(_gasConfig, isBlobTx = false, attempt = 0, previousGasPrice) {
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
+        const block = await this.publicClient.getBlock({
+            blockTag: 'latest'
+        });
         const baseFee = block.baseFeePerGas ?? 0n;
         // Get blob base fee if available
         let blobBaseFee = 0n;
         try {
-            const blobBaseFeeHex = await this.publicClient.request({ method: 'eth_blobBaseFee' });
+            const blobBaseFeeHex = await this.publicClient.request({
+                method: 'eth_blobBaseFee'
+            });
             blobBaseFee = BigInt(blobBaseFeeHex);
-            this.logger?.debug('L1 Blob base fee:', { blobBaseFee: formatGwei(blobBaseFee) });
-        }
-        catch {
+            this.logger?.debug('L1 Blob base fee:', {
+                blobBaseFee: formatGwei(blobBaseFee)
+            });
+        } catch  {
             this.logger?.warn('Failed to get L1 blob base fee', attempt);
         }
         let priorityFee;
         if (gasConfig.fixedPriorityFeePerGas) {
             this.logger?.debug('Using fixed priority fee per L1 gas', {
-                fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas,
+                fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas
             });
             // try to maintain precision up to 1000000 wei
-            priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1000000) * (WEI_CONST / 1000000n);
-        }
-        else {
+            priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1_000_000) * (WEI_CONST / 1_000_000n);
+        } else {
             // Get initial priority fee from the network
             priorityFee = await this.publicClient.estimateMaxPriorityFeePerGas();
         }
@@ -338,11 +363,11 @@ export class L1TxUtils {
         let maxFeePerBlobGas = blobBaseFee;
         // Bump base fee so it's valid for next blocks if it stalls
         const numBlocks = Math.ceil(gasConfig.stallTimeMs / BLOCK_TIME_MS);
-        for (let i = 0; i < numBlocks; i++) {
+        for(let i = 0; i < numBlocks; i++){
             // each block can go up 12.5% from previous baseFee
-            maxFeePerGas = (maxFeePerGas * (1000n + 125n)) / 1000n;
+            maxFeePerGas = maxFeePerGas * (1_000n + 125n) / 1_000n;
             // same for blob gas fee
-            maxFeePerBlobGas = (maxFeePerBlobGas * (1000n + 125n)) / 1000n;
+            maxFeePerBlobGas = maxFeePerBlobGas * (1_000n + 125n) / 1_000n;
         }
         if (attempt > 0) {
             const configBump = gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage;
@@ -351,19 +376,18 @@ export class L1TxUtils {
             const bumpPercentage = configBump > minBumpPercentage ? configBump : minBumpPercentage;
             // Calculate minimum required fees based on previous attempt
             // multiply by 100 & divide by 100 to maintain some precision
-            const minPriorityFee = (previousGasPrice.maxPriorityFeePerGas * (10000n + BigInt(bumpPercentage * 100))) / 10000n;
-            const minMaxFee = (previousGasPrice.maxFeePerGas * (10000n + BigInt(bumpPercentage * 100))) / 10000n;
+            const minPriorityFee = previousGasPrice.maxPriorityFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
+            const minMaxFee = previousGasPrice.maxFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
             // Add priority fee to maxFeePerGas
             maxFeePerGas += priorityFee;
             // Use maximum between current network values and minimum required values
             priorityFee = priorityFee > minPriorityFee ? priorityFee : minPriorityFee;
             maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
-        }
-        else {
+        } else {
             // first attempt, just bump priority fee, unless it's a fixed config
             // multiply by 100 & divide by 100 to maintain some precision
             if (!gasConfig.fixedPriorityFeePerGas) {
-                priorityFee = (priorityFee * (10000n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 100))) / 10000n;
+                priorityFee = priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
             }
             maxFeePerGas += priorityFee;
         }
@@ -378,11 +402,9 @@ export class L1TxUtils {
         // Ensure priority fee doesn't exceed max fee
         const maxPriorityFeePerGas = priorityFee > maxFeePerGas ? maxFeePerGas : priorityFee;
         if (attempt > 0 && previousGasPrice?.maxFeePerBlobGas) {
-            const bumpPercentage = gasConfig.priorityFeeRetryBumpPercentage > MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE
-                ? gasConfig.priorityFeeRetryBumpPercentage
-                : MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE;
+            const bumpPercentage = gasConfig.priorityFeeRetryBumpPercentage > MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE ? gasConfig.priorityFeeRetryBumpPercentage : MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE;
             // calculate min blob fee based on previous attempt
-            const minBlobFee = (previousGasPrice.maxFeePerBlobGas * (10000n + BigInt(bumpPercentage * 100))) / 10000n;
+            const minBlobFee = previousGasPrice.maxFeePerBlobGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
             // use max between current network values and min required values
             maxFeePerBlobGas = maxFeePerBlobGas > minBlobFee ? maxFeePerBlobGas : minBlobFee;
         }
@@ -391,19 +413,25 @@ export class L1TxUtils {
             baseFee: formatGwei(baseFee),
             maxFeePerGas: formatGwei(maxFeePerGas),
             maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
-            ...(maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(maxFeePerBlobGas) }),
+            ...maxFeePerBlobGas && {
+                maxFeePerBlobGas: formatGwei(maxFeePerBlobGas)
+            }
         });
         return {
             maxFeePerGas,
             maxPriorityFeePerGas,
-            ...(maxFeePerBlobGas && { maxFeePerBlobGas: maxFeePerBlobGas }),
+            ...maxFeePerBlobGas && {
+                maxFeePerBlobGas: maxFeePerBlobGas
+            }
         };
     }
     /**
-     * Estimates gas and adds buffer
-     */
-    async estimateGas(account, request, _gasConfig, _blobInputs) {
-        const gasConfig = { ...this.config, ..._gasConfig };
+   * Estimates gas and adds buffer
+   */ async estimateGas(account, request, _gasConfig, _blobInputs) {
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
         let initialEstimate = 0n;
         if (_blobInputs) {
             // @note requests with blobs also require maxFeePerBlobGas to be set
@@ -413,12 +441,15 @@ export class L1TxUtils {
                 ...request,
                 ..._blobInputs,
                 maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
-                gas: LARGE_GAS_LIMIT,
+                gas: LARGE_GAS_LIMIT
             });
             this.logger?.debug(`L1 gas used in estimateGas by blob tx: ${initialEstimate}`);
-        }
-        else {
-            initialEstimate = await this.publicClient.estimateGas({ account, ...request, gas: LARGE_GAS_LIMIT });
+        } else {
+            initialEstimate = await this.publicClient.estimateGas({
+                account,
+                ...request,
+                gas: LARGE_GAS_LIMIT
+            });
             this.logger?.debug(`L1 gas used in estimateGas by non-blob tx: ${initialEstimate}`);
         }
         // Add buffer based on either fixed amount or percentage
@@ -426,7 +457,9 @@ export class L1TxUtils {
         return withBuffer;
     }
     async getTransactionStats(txHash) {
-        const tx = await this.publicClient.getTransaction({ hash: txHash });
+        const tx = await this.publicClient.getTransaction({
+            hash: txHash
+        });
         if (!tx) {
             return undefined;
         }
@@ -435,7 +468,7 @@ export class L1TxUtils {
             sender: tx.from.toString(),
             transactionHash: tx.hash,
             calldataSize: calldata.length,
-            calldataGas: getCalldataGasUsage(calldata),
+            calldataGas: getCalldataGasUsage(calldata)
         };
     }
     async tryGetErrorFromRevertedTx(data, args, blobInputs, stateOverride = []) {
@@ -443,43 +476,42 @@ export class L1TxUtils {
             await this.publicClient.simulateContract({
                 ...args,
                 account: this.walletClient.account,
-                stateOverride,
+                stateOverride
+            });
+            this.logger?.trace('Simulated blob tx', {
+                blobInputs
             });
-            this.logger?.trace('Simulated blob tx', { blobInputs });
             // If the above passes, we have a blob error. We cannot simulate blob txs, and failed txs no longer throw errors.
             // Strangely, the only way to throw the revert reason as an error and provide blobs is prepareTransactionRequest.
             // See: https://github.com/wevm/viem/issues/2075
             // This throws a EstimateGasExecutionError with the custom error information:
-            const request = blobInputs
-                ? {
-                    account: this.walletClient.account,
-                    to: args.address,
-                    data,
-                    blobs: blobInputs.blobs,
-                    kzg: blobInputs.kzg,
-                    maxFeePerBlobGas: blobInputs.maxFeePerBlobGas,
-                }
-                : {
-                    account: this.walletClient.account,
-                    to: args.address,
-                    data,
-                };
-            this.logger?.trace('Preparing tx', { request });
+            const request = blobInputs ? {
+                account: this.walletClient.account,
+                to: args.address,
+                data,
+                blobs: blobInputs.blobs,
+                kzg: blobInputs.kzg,
+                maxFeePerBlobGas: blobInputs.maxFeePerBlobGas
+            } : {
+                account: this.walletClient.account,
+                to: args.address,
+                data
+            };
+            this.logger?.trace('Preparing tx', {
+                request
+            });
             await this.walletClient.prepareTransactionRequest(request);
             this.logger?.trace('Prepared tx');
             return undefined;
-        }
-        catch (simulationErr) {
+        } catch (simulationErr) {
             // If we don't have a ContractFunctionExecutionError, we have a blob related error => use getContractError to get the error msg.
-            const contractErr = simulationErr.name === 'ContractFunctionExecutionError'
-                ? simulationErr
-                : getContractError(simulationErr, {
-                    args: [],
-                    abi: args.abi,
-                    functionName: args.functionName,
-                    address: args.address,
-                    sender: this.walletClient.account.address,
-                });
+            const contractErr = simulationErr.name === 'ContractFunctionExecutionError' ? simulationErr : getContractError(simulationErr, {
+                args: [],
+                abi: args.abi,
+                functionName: args.functionName,
+                address: args.address,
+                sender: this.walletClient.account.address
+            });
             if (contractErr.name === 'ContractFunctionExecutionError') {
                 const execErr = contractErr;
                 return tryGetCustomErrorNameContractFunction(execErr);
@@ -488,9 +520,14 @@ export class L1TxUtils {
         }
     }
     async simulateGasUsed(request, blockOverrides = {}, stateOverrides = [], _gasConfig) {
-        const gasConfig = { ...this.config, ..._gasConfig };
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
         const gasPrice = await this.getGasPrice(gasConfig, false);
-        const nonce = await this.publicClient.getTransactionCount({ address: this.walletClient.account.address });
+        const nonce = await this.publicClient.getTransactionCount({
+            address: this.walletClient.account.address
+        });
         try {
             const result = await this.publicClient.simulate({
                 validation: true,
@@ -506,24 +543,23 @@ export class L1TxUtils {
                                 maxFeePerGas: gasPrice.maxFeePerGas,
                                 maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
                                 gas: request.gas ?? LARGE_GAS_LIMIT,
-                                nonce,
-                            },
-                        ],
-                    },
-                ],
+                                nonce
+                            }
+                        ]
+                    }
+                ]
             });
             this.logger?.debug(`L1 gas used in simulation: ${result[0].calls[0].gasUsed}`, {
-                result,
+                result
             });
             if (result[0].calls[0].status === 'failure') {
                 this.logger?.error('L1 transaction Simulation failed', {
-                    error: result[0].calls[0].error,
+                    error: result[0].calls[0].error
                 });
                 throw new Error(`L1 transaction simulation failed with error: ${result[0].calls[0].error.message}`);
             }
             return result[0].gasUsed;
-        }
-        catch (err) {
+        } catch (err) {
             if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
                 if (gasConfig.fallbackGasEstimate) {
                     this.logger?.warn(`Node does not support eth_simulateV1 API. Using fallback gas estimate: ${gasConfig.fallbackGasEstimate}`);
@@ -535,17 +571,19 @@ export class L1TxUtils {
         }
     }
     bumpGasLimit(gasLimit, _gasConfig) {
-        const gasConfig = { ...this.config, ..._gasConfig };
-        return gasLimit + (gasLimit * BigInt((gasConfig?.gasLimitBufferPercentage || 0) * 100)) / 10000n;
+        const gasConfig = {
+            ...this.config,
+            ..._gasConfig
+        };
+        return gasLimit + gasLimit * BigInt((gasConfig?.gasLimitBufferPercentage || 0) * 1_00) / 100_00n;
     }
     /**
-     * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
-     * @param nonce - The nonce of the transaction to cancel
-     * @param previousGasPrice - The gas price of the previous transaction
-     * @param attempts - The number of attempts to cancel the transaction
-     * @returns The hash of the cancellation transaction
-     */
-    async attemptTxCancellation(nonce, isBlobTx = false, previousGasPrice, attempts = 0) {
+   * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
+   * @param nonce - The nonce of the transaction to cancel
+   * @param previousGasPrice - The gas price of the previous transaction
+   * @param attempts - The number of attempts to cancel the transaction
+   * @returns The hash of the cancellation transaction
+   */ async attemptTxCancellation(nonce, isBlobTx = false, previousGasPrice, attempts = 0) {
         if (isBlobTx) {
             throw new Error('Cannot cancel blob transactions, please use L1TxUtilsWithBlobsClass');
         }
@@ -554,37 +592,40 @@ export class L1TxUtils {
         const cancelGasPrice = await this.getGasPrice({
             ...this.config,
             // Use high bump for cancellation to ensure it replaces the original tx
-            priorityFeeRetryBumpPercentage: 150, // 150% bump should be enough to replace any tx
+            priorityFeeRetryBumpPercentage: 150
         }, isBlobTx, attempts + 1, previousGasPrice);
         this.logger?.debug(`Attempting to cancel transaction with nonce ${nonce}`, {
             maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
-            maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas),
+            maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas)
         });
         const request = {
             to: account.address,
-            value: 0n,
+            value: 0n
         };
         // Send 0-value tx to self with higher gas price
         const cancelTxHash = await this.walletClient.sendTransaction({
             ...request,
             nonce,
-            gas: 21000n, // Standard ETH transfer gas
+            gas: 21_000n,
             maxFeePerGas: cancelGasPrice.maxFeePerGas,
-            maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas,
+            maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas
         });
-        const receipt = await this.monitorTransaction(request, cancelTxHash, { gasLimit: 21000n }, undefined, undefined, true);
+        const receipt = await this.monitorTransaction(request, cancelTxHash, {
+            gasLimit: 21_000n
+        }, undefined, undefined, true);
         return receipt.transactionHash;
     }
 }
 export function tryGetCustomErrorNameContractFunction(err) {
-    return compactArray([err.shortMessage, ...(err.metaMessages ?? []).slice(0, 2).map(s => s.trim())]).join(' ');
+    return compactArray([
+        err.shortMessage,
+        ...(err.metaMessages ?? []).slice(0, 2).map((s)=>s.trim())
+    ]).join(' ');
 }
 /*
  * Returns cost of calldata usage in Ethereum.
  * @param data - Calldata.
  * @returns 4 for each zero byte, 16 for each nonzero.
- */
-export function getCalldataGasUsage(data) {
-    return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
+ */ export function getCalldataGasUsage(data) {
+    return data.filter((byte)=>byte === 0).length * 4 + data.filter((byte)=>byte !== 0).length * 16;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"l1_tx_utils.js","sourceRoot":"","sources":["../src/l1_tx_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAEL,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,EAWL,sBAAsB,EACtB,0BAA0B,EAI1B,UAAU,EACV,gBAAgB,EAChB,UAAU,GACX,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,6BAA6B;AAC7B,6BAA6B;AAC7B,wCAAwC;AAExC,MAAM,SAAS,GAAG,WAAc,CAAC;AAEjC,yGAAyG;AACzG,MAAM,eAAe,GAAG,SAAW,CAAC;AAEpC,wEAAwE;AACxE,4HAA4H;AAC5H,MAAM,+BAA+B,GAAG,EAAE,CAAC;AAE3C,yEAAyE;AACzE,2HAA2H;AAC3H,MAAM,oCAAoC,GAAG,GAAG,CAAC;AAEjD,kCAAkC;AAClC,MAAM,aAAa,GAAG,KAAM,CAAC;AAsD7B,MAAM,CAAC,MAAM,uBAAuB,GAAwC;IAC1E,wBAAwB,EAAE;QACxB,WAAW,EAAE,2DAA2D;QACxE,GAAG,EAAE,gCAAgC;QACrC,GAAG,kBAAkB,CAAC,EAAE,CAAC;KAC1B;IACD,OAAO,EAAE;QACP,WAAW,EAAE,2BAA2B;QACxC,GAAG,EAAE,kBAAkB;QACvB,GAAG,kBAAkB,CAAC,EAAE,CAAC;KAC1B;IACD,OAAO,EAAE;QACP,WAAW,EAAE,2BAA2B;QACxC,GAAG,EAAE,kBAAkB;QACvB,GAAG,kBAAkB,CAAC,IAAI,CAAC;KAC5B;IACD,WAAW,EAAE;QACX,WAAW,EAAE,kCAAkC;QAC/C,GAAG,EAAE,yBAAyB;QAC9B,GAAG,kBAAkB,CAAC,KAAM,CAAC;KAC9B;IACD,yBAAyB,EAAE;QACzB,WAAW,EAAE,gEAAgE;QAC7E,GAAG,EAAE,iCAAiC;QACtC,GAAG,kBAAkB,CAAC,EAAE,CAAC;KAC1B;IACD,8BAA8B,EAAE;QAC9B,WAAW,EAAE,sEAAsE;QACnF,GAAG,EAAE,uCAAuC;QAC5C,GAAG,kBAAkB,CAAC,EAAE,CAAC;KAC1B;IACD,sBAAsB,EAAE;QACtB,WAAW,EAAE,gFAAgF;QAC7F,GAAG,EAAE,+BAA+B;QACpC,GAAG,kBAAkB,CAAC,CAAC,CAAC;KACzB;IACD,WAAW,EAAE;QACX,WAAW,EAAE,qCAAqC;QAClD,GAAG,EAAE,4BAA4B;QACjC,GAAG,kBAAkB,CAAC,CAAC,CAAC;KACzB;IACD,eAAe,EAAE;QACf,WAAW,EAAE,8BAA8B;QAC3C,GAAG,EAAE,iCAAiC;QACtC,GAAG,kBAAkB,CAAC,KAAM,CAAC;KAC9B;IACD,WAAW,EAAE;QACX,WAAW,EAAE,wCAAwC;QACrD,GAAG,EAAE,6BAA6B;QAClC,GAAG,kBAAkB,CAAC,KAAM,CAAC;KAC9B;IACD,WAAW,EAAE;QACX,WAAW,EAAE,8EAA8E;QAC3F,GAAG,EAAE,6BAA6B;QAClC,GAAG,kBAAkB,CAAC,MAAO,CAAC,EAAE,SAAS;KAC1C;IACD,6BAA6B,EAAE;QAC7B,WAAW,EAAE,8DAA8D;QAC3E,GAAG,EAAE,sCAAsC;QAC3C,GAAG,kBAAkB,CAAC,CAAC,CAAC;KACzB;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,gBAAgB,CAAkB,uBAAuB,CAAC,CAAC;AAiCjG,MAAM,OAAO,SAAS;IAIpB,YACS,YAAuC,EACvC,YAAyD,EAC7C,MAAe,EAClC,MAAiC;QAH1B,iBAAY,GAAZ,YAAY,CAA2B;QACvC,iBAAY,GAAZ,YAAY,CAA6C;QAC7C,WAAM,GAAN,MAAM,CAAS;QAL5B,gBAAW,GAAG,KAAK,CAAC;QAQ1B,IAAI,CAAC,MAAM,GAAG;YACZ,GAAG,sBAAsB;YACzB,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC;SAClB,CAAC;IACJ,CAAC;IAEM,SAAS;QACd,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAEM,gBAAgB;QACrB,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC;IAC3C,CAAC;IAEM,QAAQ;QACb,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;IACtC,CAAC;IAEM,cAAc;QACnB,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,eAAe,CAC1B,OAAoB,EACpB,UAAwB,EACxB,UAAyB;QAEzB,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;YACpD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YAC1C,IAAI,QAAgB,CAAC;YAErB,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;gBACvB,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC;YAChC,CAAC;iBAAM,CAAC;gBACN,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YACtD,CAAC;YAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;YAEjE,IAAI,SAAS,CAAC,WAAW,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC;gBAC1E,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YAC1D,CAAC;YAED,IAAI,MAAW,CAAC;YAChB,IAAI,UAAU,EAAE,CAAC;gBACf,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;oBAC/C,GAAG,OAAO;oBACV,GAAG,UAAU;oBACb,GAAG,EAAE,QAAQ;oBACb,YAAY,EAAE,QAAQ,CAAC,YAAY;oBACnC,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB;oBACnD,gBAAgB,EAAE,QAAQ,CAAC,gBAAiB;iBAC7C,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;oBAC/C,GAAG,OAAO;oBACV,GAAG,EAAE,QAAQ;oBACb,YAAY,EAAE,QAAQ,CAAC,YAAY;oBACnC,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB;iBACpD,CAAC,CAAC;YACL,CAAC;YACD,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,uBAAuB,MAAM,EAAE,EAAE;gBACpD,QAAQ;gBACR,YAAY,EAAE,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAC/C,oBAAoB,EAAE,UAAU,CAAC,QAAQ,CAAC,oBAAoB,CAAC;gBAC/D,GAAG,CAAC,QAAQ,CAAC,gBAAgB,IAAI,EAAE,gBAAgB,EAAE,UAAU,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;aAC9F,CAAC,CAAC;YAEH,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;QACxC,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAClB,MAAM,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;YACvC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,+BAA+B,EAAE,SAAS,CAAC,OAAO,EAAE,EAAE,YAAY,EAAE,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;YACjH,MAAM,SAAS,CAAC;QAClB,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,kBAAkB,CAC7B,OAAoB,EACpB,aAAkB,EAClB,MAA4B,EAC5B,UAA8D,EAC9D,WAA0B,EAC1B,aAAsB,KAAK;QAE3B,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,CAAC;QAC/B,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAC1C,MAAM,UAAU,GAAG,WAAW,IAAI,EAAE,CAAC;QACrC,MAAM,yBAAyB,GAAG,GAAG,EAAE,CACrC,WAAW,CAAC,KAAK,CAAC,SAAS,CAAC,6BAA6B,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAE/E,2DAA2D;QAC3D,MAAM,EAAE,GAAG,MAAM,KAAK,CACpB,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,EAC/D,0BAA0B,aAAa,EAAE,EACzC,yBAAyB,EAAE,EAC3B,IAAI,CAAC,MAAM,EACX,IAAI,CACL,CAAC;QAEF,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CAAC,gCAAgC,aAAa,aAAa,CAAC,CAAC;QAC9E,CAAC;QAED,IAAI,EAAE,EAAE,KAAK,KAAK,SAAS,IAAI,EAAE,EAAE,KAAK,KAAK,IAAI,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,gCAAgC,aAAa,QAAQ,CAAC,CAAC;QACzE,CAAC;QACD,MAAM,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC;QAEvB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAM,CAAC,aAAa,CAAC,CAAC,CAAC;QAC/C,IAAI,aAAa,GAAG,aAAa,CAAC;QAClC,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,IAAI,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACjC,IAAI,YAAY,GAAa;YAC3B,YAAY,EAAE,EAAE,CAAC,YAAa;YAC9B,oBAAoB,EAAE,EAAE,CAAC,oBAAqB;YAC9C,gBAAgB,EAAE,EAAE,CAAC,gBAAiB;SACvC,CAAC;QACF,MAAM,aAAa,GAAG,eAAe,CAAC;QAEtC,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,MAAM,UAAU,GAAG,GAAG,EAAE,CACtB,CAAC,SAAS,CAAC,WAAW,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YACvE,CAAC,SAAS,CAAC,WAAW,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,aAAa,GAAG,SAAS,CAAC,WAAW,CAAC;YAC3F,IAAI,CAAC,WAAW;YAChB,KAAK,CAAC;QAER,OAAO,CAAC,UAAU,EAAE,CAAC;YACnB,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;gBAC/F,IAAI,YAAY,GAAG,KAAK,EAAE,CAAC;oBACzB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;wBAC5B,IAAI,CAAC;4BACH,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;4BACxE,IAAI,OAAO,EAAE,CAAC;gCACZ,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;oCAClC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kBAAkB,IAAI,WAAW,EAAE,OAAO,CAAC,CAAC;gCACjE,CAAC;qCAAM,CAAC;oCACN,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kBAAkB,IAAI,QAAQ,CAAC,CAAC;gCACrD,CAAC;gCACD,OAAO,OAAO,CAAC;4BACjB,CAAC;wBACH,CAAC;wBAAC,OAAO,GAAG,EAAE,CAAC;4BACb,IAAI,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gCAC7D,MAAM,eAAe,CAAC,GAAG,CAAC,CAAC;4BAC7B,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,2DAA2D;gBAC3D,MAAM,EAAE,GAAG,MAAM,KAAK,CACpB,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,EAC/D,0BAA0B,aAAa,EAAE,EACzC,yBAAyB,EAAE,EAC3B,IAAI,CAAC,MAAM,EACX,IAAI,CACL,CAAC;gBACF,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC;gBAEhD,IAAI,EAAE,IAAI,UAAU,GAAG,SAAS,CAAC,WAAY,EAAE,CAAC;oBAC9C,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kBAAkB,aAAa,0BAA0B,UAAU,KAAK,CAAC,CAAC;oBAE7F,kCAAkC;oBAClC,UAAU,GAAG,UAAU,EAAE,CAAC;oBAC1B,IAAI,UAAU,EAAE,CAAC;wBACf,MAAM;oBACR,CAAC;oBAED,MAAM,KAAK,CAAC,SAAS,CAAC,eAAgB,CAAC,CAAC;oBACxC,SAAS;gBACX,CAAC;gBAED,IAAI,UAAU,GAAG,SAAS,CAAC,WAAY,IAAI,QAAQ,GAAG,SAAS,CAAC,WAAY,EAAE,CAAC;oBAC7E,QAAQ,EAAE,CAAC;oBACX,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CACxC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,EAAE,CAAC,YAAY,IAAI,EAAE,CAAC,oBAAoB;wBACxC,CAAC,CAAC;4BACE,YAAY,EAAE,EAAE,CAAC,YAAY;4BAC7B,oBAAoB,EAAE,EAAE,CAAC,oBAAoB;4BAC7C,gBAAgB,EAAE,EAAE,CAAC,gBAAgB;yBACtC;wBACH,CAAC,CAAC,SAAS,CACd,CAAC;oBACF,YAAY,GAAG,WAAW,CAAC;oBAE3B,IAAI,CAAC,MAAM,EAAE,KAAK,CAChB,kBAAkB,aAAa,uCAAuC,QAAQ,IAAI,SAAS,CAAC,WAAW,GAAG;wBACxG,yBAAyB,UAAU,CAAC,WAAW,CAAC,oBAAoB,CAAC,OAAO,EAC9E;wBACE,YAAY,EAAE,UAAU,CAAC,WAAW,CAAC,YAAY,CAAC;wBAClD,oBAAoB,EAAE,UAAU,CAAC,WAAW,CAAC,oBAAoB,CAAC;wBAClE,GAAG,CAAC,WAAW,CAAC,gBAAgB,IAAI,EAAE,gBAAgB,EAAE,UAAU,CAAC,WAAW,CAAC,gBAAgB,CAAC,EAAE,CAAC;qBACpG,CACF,CAAC;oBAEF,aAAa,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;wBACtD,GAAG,OAAO;wBACV,GAAG,UAAU;wBACb,KAAK;wBACL,GAAG,EAAE,MAAM,CAAC,QAAQ;wBACpB,YAAY,EAAE,WAAW,CAAC,YAAY;wBACtC,oBAAoB,EAAE,WAAW,CAAC,oBAAoB;qBACvD,CAAC,CAAC;oBAEH,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;oBAC5B,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAC/B,CAAC;gBACD,MAAM,KAAK,CAAC,SAAS,CAAC,eAAgB,CAAC,CAAC;YAC1C,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAClB,MAAM,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;gBACvC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,mCAAmC,aAAa,GAAG,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;gBAC1F,IAAI,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;oBAC5C,MAAM,SAAS,CAAC;gBAClB,CAAC;gBACD,MAAM,KAAK,CAAC,SAAS,CAAC,eAAgB,CAAC,CAAC;YAC1C,CAAC;YACD,6BAA6B;YAC7B,UAAU,GAAG,UAAU,EAAE,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,uEAAuE;YACvE,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,CAAC;iBAChE,IAAI,CAAC,YAAY,CAAC,EAAE;gBACnB,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,wBAAwB,YAAY,qBAAqB,aAAa,EAAE,CAAC,CAAC;YAC/F,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,CAAC,EAAE;gBACX,MAAM,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;gBACvC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,gDAAgD,aAAa,GAAG,EAAE,SAAS,CAAC,OAAO,EAAE;oBACtG,YAAY,EAAE,SAAS,CAAC,YAAY;iBACrC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEL,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kBAAkB,aAAa,YAAY,EAAE;gBAC9D,MAAM,EAAE,aAAa;gBACrB,GAAG,EAAE;aACN,CAAC,CAAC;QACL,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,kBAAkB,aAAa,YAAY,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,yBAAyB,CACpC,OAAoB,EACpB,SAAuB,EACvB,UAAyB;QAEzB,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QAClG,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACpG,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;IAC/B,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,WAAW,CACtB,UAA4B,EAC5B,WAAoB,KAAK,EACzB,UAAkB,CAAC,EACnB,gBAA8D;QAE9D,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;QACvE,MAAM,OAAO,GAAG,KAAK,CAAC,aAAa,IAAI,EAAE,CAAC;QAE1C,iCAAiC;QACjC,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC;YACH,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;YACtF,WAAW,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;YACrC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,mBAAmB,EAAE,EAAE,WAAW,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACpF,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,gCAAgC,EAAE,OAAO,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,WAAmB,CAAC;QACxB,IAAI,SAAS,CAAC,sBAAsB,EAAE,CAAC;YACrC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,qCAAqC,EAAE;gBACxD,sBAAsB,EAAE,SAAS,CAAC,sBAAsB;aACzD,CAAC,CAAC;YACH,8CAA8C;YAC9C,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,sBAAsB,GAAG,OAAS,CAAC,GAAG,CAAC,SAAS,GAAG,QAAU,CAAC,CAAC;QAChG,CAAC;aAAM,CAAC;YACN,4CAA4C;YAC5C,WAAW,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,4BAA4B,EAAE,CAAC;QACvE,CAAC;QACD,IAAI,YAAY,GAAG,OAAO,CAAC;QAE3B,IAAI,gBAAgB,GAAG,WAAW,CAAC;QAEnC,2DAA2D;QAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,WAAY,GAAG,aAAa,CAAC,CAAC;QACpE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACnC,mDAAmD;YACnD,YAAY,GAAG,CAAC,YAAY,GAAG,CAAC,KAAM,GAAG,IAAI,CAAC,CAAC,GAAG,KAAM,CAAC;YACzD,wBAAwB;YACxB,gBAAgB,GAAG,CAAC,gBAAgB,GAAG,CAAC,KAAM,GAAG,IAAI,CAAC,CAAC,GAAG,KAAM,CAAC;QACnE,CAAC;QACD,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAChB,MAAM,UAAU,GACd,SAAS,CAAC,8BAA8B,IAAI,sBAAsB,CAAC,8BAA+B,CAAC;YAErG,gEAAgE;YAChE,MAAM,iBAAiB,GAAG,QAAQ,CAAC,CAAC,CAAC,oCAAoC,CAAC,CAAC,CAAC,+BAA+B,CAAC;YAE5G,MAAM,cAAc,GAAG,UAAU,GAAG,iBAAiB,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,iBAAiB,CAAC;YACvF,4DAA4D;YAC5D,6DAA6D;YAC7D,MAAM,cAAc,GAClB,CAAC,gBAAiB,CAAC,oBAAoB,GAAG,CAAC,MAAO,GAAG,MAAM,CAAC,cAAc,GAAG,GAAI,CAAC,CAAC,CAAC,GAAG,MAAO,CAAC;YACjG,MAAM,SAAS,GAAG,CAAC,gBAAiB,CAAC,YAAY,GAAG,CAAC,MAAO,GAAG,MAAM,CAAC,cAAc,GAAG,GAAI,CAAC,CAAC,CAAC,GAAG,MAAO,CAAC;YAEzG,mCAAmC;YACnC,YAAY,IAAI,WAAW,CAAC;YAE5B,yEAAyE;YACzE,WAAW,GAAG,WAAW,GAAG,cAAc,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC;YAC1E,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC;QACrE,CAAC;aAAM,CAAC;YACN,oEAAoE;YACpE,6DAA6D;YAC7D,IAAI,CAAC,SAAS,CAAC,sBAAsB,EAAE,CAAC;gBACtC,WAAW,GAAG,CAAC,WAAW,GAAG,CAAC,MAAO,GAAG,MAAM,CAAC,CAAC,SAAS,CAAC,yBAAyB,IAAI,CAAC,CAAC,GAAG,GAAI,CAAC,CAAC,CAAC,GAAG,MAAO,CAAC;YAChH,CAAC;YACD,YAAY,IAAI,WAAW,CAAC;QAC9B,CAAC;QAED,iCAAiC;QACjC,MAAM,YAAY,GAAG,SAAS,CAAC,OAAQ,GAAG,SAAS,CAAC;QACpD,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC;QAEzE,qCAAqC;QACrC,IAAI,gBAAgB,EAAE,CAAC;YACrB,MAAM,gBAAgB,GAAG,SAAS,CAAC,WAAY,GAAG,SAAS,CAAC;YAC5D,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,gBAAgB,CAAC;QAC/F,CAAC;QAED,6CAA6C;QAC7C,MAAM,oBAAoB,GAAG,WAAW,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC;QAErF,IAAI,OAAO,GAAG,CAAC,IAAI,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;YACtD,MAAM,cAAc,GAClB,SAAS,CAAC,8BAA+B,GAAG,oCAAoC;gBAC9E,CAAC,CAAC,SAAS,CAAC,8BAA+B;gBAC3C,CAAC,CAAC,oCAAoC,CAAC;YAE3C,mDAAmD;YACnD,MAAM,UAAU,GAAG,CAAC,gBAAgB,CAAC,gBAAgB,GAAG,CAAC,MAAO,GAAG,MAAM,CAAC,cAAc,GAAG,GAAI,CAAC,CAAC,CAAC,GAAG,MAAO,CAAC;YAE7G,iEAAiE;YACjE,gBAAgB,GAAG,gBAAgB,GAAG,UAAU,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,UAAU,CAAC;QACnF,CAAC;QAED,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,uBAAuB,EAAE;YAC1C,OAAO;YACP,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC;YAC5B,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC;YACtC,oBAAoB,EAAE,UAAU,CAAC,oBAAoB,CAAC;YACtD,GAAG,CAAC,gBAAgB,IAAI,EAAE,gBAAgB,EAAE,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC;SAC5E,CAAC,CAAC;QAEH,OAAO;YACL,YAAY;YACZ,oBAAoB;YACpB,GAAG,CAAC,gBAAgB,IAAI,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;SAChE,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,WAAW,CACtB,OAAsB,EACtB,OAAoB,EACpB,UAA4B,EAC5B,WAA0B;QAE1B,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,IAAI,eAAe,GAAG,EAAE,CAAC;QACzB,IAAI,WAAW,EAAE,CAAC;YAChB,oEAAoE;YACpE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAC5D,eAAe,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;gBACpD,OAAO;gBACP,GAAG,OAAO;gBACV,GAAG,WAAW;gBACd,gBAAgB,EAAE,QAAQ,CAAC,gBAAiB;gBAC5C,GAAG,EAAE,eAAe;aACrB,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,0CAA0C,eAAe,EAAE,CAAC,CAAC;QAClF,CAAC;aAAM,CAAC;YACN,eAAe,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,CAAC,CAAC;YACrG,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,8CAA8C,eAAe,EAAE,CAAC,CAAC;QACtF,CAAC;QAED,wDAAwD;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;QAEjE,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,MAAc;QACtC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,MAAa,EAAE,CAAC,CAAC;QAC3E,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,QAAQ,GAAG,UAAU,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACtC,OAAO;YACL,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE;YAC1B,eAAe,EAAE,EAAE,CAAC,IAAI;YACxB,YAAY,EAAE,QAAQ,CAAC,MAAM;YAC7B,WAAW,EAAE,mBAAmB,CAAC,QAAQ,CAAC;SAC3C,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,yBAAyB,CACpC,IAAS,EACT,IAKC,EACD,UAAqE,EACrE,gBAA+B,EAAE;QAEjC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC;gBACvC,GAAG,IAAI;gBACP,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO;gBAClC,aAAa;aACd,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,mBAAmB,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;YACxD,iHAAiH;YACjH,iHAAiH;YACjH,gDAAgD;YAChD,6EAA6E;YAC7E,MAAM,OAAO,GAAG,UAAU;gBACxB,CAAC,CAAC;oBACE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO;oBAClC,EAAE,EAAE,IAAI,CAAC,OAAO;oBAChB,IAAI;oBACJ,KAAK,EAAE,UAAU,CAAC,KAAK;oBACvB,GAAG,EAAE,UAAU,CAAC,GAAG;oBACnB,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;iBAC9C;gBACH,CAAC,CAAC;oBACE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO;oBAClC,EAAE,EAAE,IAAI,CAAC,OAAO;oBAChB,IAAI;iBACL,CAAC;YACN,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;YAChD,MAAM,IAAI,CAAC,YAAY,CAAC,yBAAyB,CAAC,OAAO,CAAC,CAAC;YAC3D,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;YAClC,OAAO,SAAS,CAAC;QACnB,CAAC;QAAC,OAAO,aAAkB,EAAE,CAAC;YAC5B,gIAAgI;YAChI,MAAM,WAAW,GACf,aAAa,CAAC,IAAI,KAAK,gCAAgC;gBACrD,CAAC,CAAC,aAAa;gBACf,CAAC,CAAC,gBAAgB,CAAC,aAA0B,EAAE;oBAC3C,IAAI,EAAE,EAAE;oBACR,GAAG,EAAE,IAAI,CAAC,GAAG;oBACb,YAAY,EAAE,IAAI,CAAC,YAAY;oBAC/B,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO;iBAC1C,CAAC,CAAC;YACT,IAAI,WAAW,CAAC,IAAI,KAAK,gCAAgC,EAAE,CAAC;gBAC1D,MAAM,OAAO,GAAG,WAA6C,CAAC;gBAC9D,OAAO,qCAAqC,CAAC,OAAO,CAAC,CAAC;YACxD,CAAC;YACD,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,qCAAqC,EAAE,aAAa,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,OAAuC,EACvC,iBAAiD,EAAE,EACnD,iBAAgC,EAAE,EAClC,UAA+D;QAE/D,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAE1D,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAE1G,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;gBAC9C,UAAU,EAAE,IAAI;gBAChB,MAAM,EAAE;oBACN;wBACE,cAAc;wBACd,cAAc;wBACd,KAAK,EAAE;4BACL;gCACE,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO;gCACvC,EAAE,EAAE,OAAO,CAAC,EAAG;gCACf,IAAI,EAAE,OAAO,CAAC,IAAI;gCAClB,YAAY,EAAE,QAAQ,CAAC,YAAY;gCACnC,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB;gCACnD,GAAG,EAAE,OAAO,CAAC,GAAG,IAAI,eAAe;gCACnC,KAAK;6BACN;yBACF;qBACF;iBACF;aACF,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,8BAA8B,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC7E,MAAM;aACP,CAAC,CAAC;YACH,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAC5C,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kCAAkC,EAAE;oBACrD,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK;iBAChC,CAAC,CAAC;gBACH,MAAM,IAAI,KAAK,CAAC,gDAAgD,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACtG,CAAC;YACD,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,GAAG,YAAY,sBAAsB,IAAI,GAAG,YAAY,0BAA0B,EAAE,CAAC;gBACvF,IAAI,SAAS,CAAC,mBAAmB,EAAE,CAAC;oBAClC,IAAI,CAAC,MAAM,EAAE,IAAI,CACf,0EAA0E,SAAS,CAAC,mBAAmB,EAAE,CAC1G,CAAC;oBACF,OAAO,SAAS,CAAC,mBAAmB,CAAC;gBACvC,CAAC;gBACD,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,0CAA0C,CAAC,CAAC;YACjE,CAAC;YACD,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAEM,YAAY,CAAC,QAAgB,EAAE,UAA4B;QAChE,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,OAAO,QAAQ,GAAG,CAAC,QAAQ,GAAG,MAAM,CAAC,CAAC,SAAS,EAAE,wBAAwB,IAAI,CAAC,CAAC,GAAG,GAAI,CAAC,CAAC,GAAG,MAAO,CAAC;IACrG,CAAC;IAED;;;;;;OAMG;IACO,KAAK,CAAC,qBAAqB,CAAC,KAAa,EAAE,QAAQ,GAAG,KAAK,EAAE,gBAA2B,EAAE,QAAQ,GAAG,CAAC;QAC9G,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;QACzF,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAE1C,0DAA0D;QAC1D,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,WAAW,CAC3C;YACE,GAAG,IAAI,CAAC,MAAM;YACd,uEAAuE;YACvE,8BAA8B,EAAE,GAAG,EAAE,+CAA+C;SACrF,EACD,QAAQ,EACR,QAAQ,GAAG,CAAC,EACZ,gBAAgB,CACjB,CAAC;QAEF,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,+CAA+C,KAAK,EAAE,EAAE;YACzE,YAAY,EAAE,UAAU,CAAC,cAAc,CAAC,YAAY,CAAC;YACrD,oBAAoB,EAAE,UAAU,CAAC,cAAc,CAAC,oBAAoB,CAAC;SACtE,CAAC,CAAC;QACH,MAAM,OAAO,GAAG;YACd,EAAE,EAAE,OAAO,CAAC,OAAO;YACnB,KAAK,EAAE,EAAE;SACV,CAAC;QAEF,gDAAgD;QAChD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;YAC3D,GAAG,OAAO;YACV,KAAK;YACL,GAAG,EAAE,MAAO,EAAE,4BAA4B;YAC1C,YAAY,EAAE,cAAc,CAAC,YAAY;YACzC,oBAAoB,EAAE,cAAc,CAAC,oBAAoB;SAC1D,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAC3C,OAAO,EACP,YAAY,EACZ,EAAE,QAAQ,EAAE,MAAO,EAAE,EACrB,SAAS,EACT,SAAS,EACT,IAAI,CACL,CAAC;QAEF,OAAO,OAAO,CAAC,eAAe,CAAC;IACjC,CAAC;CACF;AAED,MAAM,UAAU,qCAAqC,CAAC,GAAmC;IACvF,OAAO,YAAY,CAAC,CAAC,GAAG,CAAC,YAAY,EAAE,GAAG,CAAC,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAChH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAgB;IAClD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC;AAClG,CAAC"}