@aztec/ethereum 2.0.3 → 2.1.0-rc.2

package/dest/l1_tx_utils.js

@@ -1,834 +0,0 @@
-import { compactArray, times } from '@aztec/foundation/collection';
-import { bigintConfigHelper, booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-import { makeBackoff, retry } from '@aztec/foundation/retry';
-import { sleep } from '@aztec/foundation/sleep';
-import { DateProvider } from '@aztec/foundation/timer';
-import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
-import pickBy from 'lodash.pickby';
-import { MethodNotFoundRpcError, MethodNotSupportedRpcError, createNonceManager, decodeErrorResult, formatGwei, getContractError, hexToBytes, parseTransaction, serializeTransaction } from 'viem';
-import { jsonRpc } from 'viem/nonce';
-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 = 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 = 12_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;
-// setting a minimum bump percentage to 100% due to geth's implementation
-// 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 = 12_000;
-export const l1TxUtilsConfigMappings = {
-    gasLimitBufferPercentage: {
-        description: 'How much to increase calculated gas limit by (percentage)',
-        env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
-        ...numberConfigHelper(20)
-    },
-    maxGwei: {
-        description: 'Maximum gas price in gwei',
-        env: 'L1_GAS_PRICE_MAX',
-        ...bigintConfigHelper(500n)
-    },
-    maxBlobGwei: {
-        description: 'Maximum blob fee per gas in gwei',
-        env: 'L1_BLOB_FEE_PER_GAS_MAX',
-        ...bigintConfigHelper(1_500n)
-    },
-    priorityFeeBumpPercentage: {
-        description: 'How much to increase priority fee by each attempt (percentage)',
-        env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
-        ...numberConfigHelper(20)
-    },
-    priorityFeeRetryBumpPercentage: {
-        description: 'How much to increase priority fee by each retry attempt (percentage)',
-        env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
-        ...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)
-    },
-    maxAttempts: {
-        description: 'Maximum number of speed-up attempts',
-        env: 'L1_TX_MONITOR_MAX_ATTEMPTS',
-        ...numberConfigHelper(3)
-    },
-    checkIntervalMs: {
-        description: 'How often to check tx status',
-        env: 'L1_TX_MONITOR_CHECK_INTERVAL_MS',
-        ...numberConfigHelper(1_000)
-    },
-    stallTimeMs: {
-        description: 'How long before considering tx stalled',
-        env: 'L1_TX_MONITOR_STALL_TIME_MS',
-        ...numberConfigHelper(24_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(120_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)
-    },
-    cancelTxOnTimeout: {
-        description: "Whether to attempt to cancel a tx if it's not mined after txTimeoutMs",
-        env: 'L1_TX_MONITOR_CANCEL_TX_ON_TIMEOUT',
-        ...booleanConfigHelper(true)
-    }
-};
-export const defaultL1TxUtilsConfig = getDefaultConfig(l1TxUtilsConfigMappings);
-export function getL1TxUtilsConfigEnvVars() {
-    return getConfigFromMappings(l1TxUtilsConfigMappings);
-}
-export var TxUtilsState = /*#__PURE__*/ function(TxUtilsState) {
-    TxUtilsState[TxUtilsState["IDLE"] = 0] = "IDLE";
-    TxUtilsState[TxUtilsState["SENT"] = 1] = "SENT";
-    TxUtilsState[TxUtilsState["SPEED_UP"] = 2] = "SPEED_UP";
-    TxUtilsState[TxUtilsState["CANCELLED"] = 3] = "CANCELLED";
-    TxUtilsState[TxUtilsState["NOT_MINED"] = 4] = "NOT_MINED";
-    TxUtilsState[TxUtilsState["MINED"] = 5] = "MINED";
-    return TxUtilsState;
-}({});
-export class ReadOnlyL1TxUtils {
-    client;
-    logger;
-    dateProvider;
-    debugMaxGasLimit;
-    config;
-    interrupted;
-    constructor(client, logger = createLogger('ReadOnlyL1TxUtils'), dateProvider, config, debugMaxGasLimit = false){
-        this.client = client;
-        this.logger = logger;
-        this.dateProvider = dateProvider;
-        this.debugMaxGasLimit = debugMaxGasLimit;
-        this.interrupted = false;
-        this.config = {
-            ...defaultL1TxUtilsConfig,
-            ...config || {}
-        };
-    }
-    interrupt() {
-        this.interrupted = true;
-    }
-    restart() {
-        this.interrupted = false;
-    }
-    getBlock() {
-        return this.client.getBlock();
-    }
-    getBlockNumber() {
-        return this.client.getBlockNumber();
-    }
-    /**
-   * 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.client.getBlock({
-            blockTag: 'latest'
-        });
-        const baseFee = block.baseFeePerGas ?? 0n;
-        // Get blob base fee if available
-        let blobBaseFee = 0n;
-        if (isBlobTx) {
-            try {
-                blobBaseFee = await retry(()=>this.client.getBlobBaseFee(), 'Getting L1 blob base fee', makeBackoff(times(2, ()=>1)), this.logger, true);
-                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
-            });
-            // try to maintain precision up to 1000000 wei
-            priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1_000_000) * (WEI_CONST / 1_000_000n);
-        } else {
-            // Get initial priority fee from the network
-            priorityFee = await this.client.estimateMaxPriorityFeePerGas();
-        }
-        let maxFeePerGas = baseFee;
-        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++){
-            // each block can go up 12.5% from previous baseFee
-            maxFeePerGas = maxFeePerGas * (1_000n + 125n) / 1_000n;
-            // same for blob gas fee
-            maxFeePerBlobGas = maxFeePerBlobGas * (1_000n + 125n) / 1_000n;
-        }
-        if (attempt > 0) {
-            const configBump = gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage;
-            // if this is a blob tx, we have to use the blob bump percentage
-            const minBumpPercentage = isBlobTx ? MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE : MIN_REPLACEMENT_BUMP_PERCENTAGE;
-            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 * (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 {
-            // 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 * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
-            }
-            maxFeePerGas += priorityFee;
-        }
-        // Ensure we don't exceed maxGwei
-        const maxGweiInWei = gasConfig.maxGwei * WEI_CONST;
-        maxFeePerGas = maxFeePerGas > maxGweiInWei ? maxGweiInWei : maxFeePerGas;
-        // Ensure we don't exceed maxBlobGwei
-        if (maxFeePerBlobGas) {
-            const maxBlobGweiInWei = gasConfig.maxBlobGwei * WEI_CONST;
-            maxFeePerBlobGas = maxFeePerBlobGas > maxBlobGweiInWei ? maxBlobGweiInWei : maxFeePerBlobGas;
-        }
-        // 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;
-            // calculate min blob fee based on previous attempt
-            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;
-        }
-        this.logger?.debug(`Computed L1 gas price`, {
-            attempt,
-            baseFee: formatGwei(baseFee),
-            maxFeePerGas: formatGwei(maxFeePerGas),
-            maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
-            ...maxFeePerBlobGas && {
-                maxFeePerBlobGas: formatGwei(maxFeePerBlobGas)
-            }
-        });
-        return {
-            maxFeePerGas,
-            maxPriorityFeePerGas,
-            ...maxFeePerBlobGas && {
-                maxFeePerBlobGas: maxFeePerBlobGas
-            }
-        };
-    }
-    /**
-   * 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
-            const gasPrice = await this.getGasPrice(gasConfig, true, 0);
-            initialEstimate = await this.client.estimateGas({
-                account,
-                ...request,
-                ..._blobInputs,
-                maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
-                gas: LARGE_GAS_LIMIT
-            });
-            this.logger?.debug(`L1 gas used in estimateGas by blob tx: ${initialEstimate}`);
-        } else {
-            initialEstimate = await this.client.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
-        const withBuffer = this.bumpGasLimit(initialEstimate, gasConfig);
-        return withBuffer;
-    }
-    async getTransactionStats(txHash) {
-        const tx = await this.client.getTransaction({
-            hash: txHash
-        });
-        if (!tx) {
-            return undefined;
-        }
-        const calldata = hexToBytes(tx.input);
-        return {
-            sender: tx.from.toString(),
-            transactionHash: tx.hash,
-            calldataSize: calldata.length,
-            calldataGas: getCalldataGasUsage(calldata)
-        };
-    }
-    async tryGetErrorFromRevertedTx(data, args, blobInputs, stateOverride = []) {
-        try {
-            await this.client.simulateContract({
-                ...args,
-                account: this.client.account,
-                stateOverride
-            });
-            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.client.account,
-                to: args.address,
-                data,
-                blobs: blobInputs.blobs,
-                kzg: blobInputs.kzg,
-                maxFeePerBlobGas: blobInputs.maxFeePerBlobGas
-            } : {
-                account: this.client.account,
-                to: args.address,
-                data
-            };
-            this.logger?.trace('Preparing tx', {
-                request
-            });
-            await this.client.prepareTransactionRequest(request);
-            this.logger?.trace('Prepared tx');
-            return undefined;
-        } 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
-            });
-            if (contractErr.name === 'ContractFunctionExecutionError') {
-                const execErr = contractErr;
-                return tryGetCustomErrorNameContractFunction(execErr);
-            }
-            this.logger?.error(`Error getting error from simulation`, simulationErr);
-        }
-    }
-    async simulate(request, blockOverrides = {}, stateOverrides = [], abi = RollupAbi, _gasConfig) {
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        const call = {
-            to: request.to,
-            data: request.data,
-            ...request.from && {
-                from: request.from
-            }
-        };
-        return await this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
-    }
-    async _simulate(call, blockOverrides = {}, stateOverrides = [], gasConfig, abi) {
-        try {
-            const result = await this.client.simulateBlocks({
-                validation: false,
-                blocks: [
-                    {
-                        blockOverrides,
-                        stateOverrides,
-                        calls: [
-                            call
-                        ]
-                    }
-                ]
-            });
-            if (result[0].calls[0].status === 'failure') {
-                this.logger?.error('L1 transaction simulation failed', result[0].calls[0].error);
-                const decodedError = decodeErrorResult({
-                    abi,
-                    data: result[0].calls[0].data
-                });
-                throw new Error(`L1 transaction simulation failed with error ${decodedError.errorName}(${decodedError.args?.join(',')})`);
-            }
-            this.logger?.debug(`L1 transaction simulation succeeded`, {
-                ...result[0].calls[0]
-            });
-            return {
-                gasUsed: result[0].gasUsed,
-                result: result[0].calls[0].data
-            };
-        } 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}`);
-                    return {
-                        gasUsed: gasConfig.fallbackGasEstimate,
-                        result: '0x'
-                    };
-                }
-                this.logger?.error('Node does not support eth_simulateV1 API');
-            }
-            throw err;
-        }
-    }
-    bumpGasLimit(gasLimit, _gasConfig) {
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        const bumpedGasLimit = gasLimit + gasLimit * BigInt((gasConfig?.gasLimitBufferPercentage || 0) * 1_00) / 100_00n;
-        const cleanGasConfig = pickBy(gasConfig, (_, key)=>key in l1TxUtilsConfigMappings);
-        this.logger?.debug('Bumping gas limit', {
-            gasLimit,
-            gasConfig: cleanGasConfig,
-            bumpedGasLimit
-        });
-        return bumpedGasLimit;
-    }
-}
-export class L1TxUtils extends ReadOnlyL1TxUtils {
-    client;
-    address;
-    signer;
-    logger;
-    txUtilsState;
-    lastMinedBlockNumber;
-    nonceManager;
-    constructor(client, address, signer, logger = createLogger('L1TxUtils'), dateProvider = new DateProvider(), config, debugMaxGasLimit = false){
-        super(client, logger, dateProvider, config, debugMaxGasLimit), this.client = client, this.address = address, this.signer = signer, this.logger = logger, this.txUtilsState = 0, this.lastMinedBlockNumber = undefined;
-        this.nonceManager = createNonceManager({
-            source: jsonRpc()
-        });
-    }
-    get state() {
-        return this.txUtilsState;
-    }
-    get lastMinedAtBlockNumber() {
-        return this.lastMinedBlockNumber;
-    }
-    set lastMinedAtBlockNumber(blockNumber) {
-        this.lastMinedBlockNumber = blockNumber;
-    }
-    set state(state) {
-        this.txUtilsState = state;
-        this.logger?.debug(`L1TxUtils state changed to ${TxUtilsState[state]} for sender: ${this.getSenderAddress().toString()}`);
-    }
-    getSenderAddress() {
-        return this.address;
-    }
-    getSenderBalance() {
-        return this.client.getBalance({
-            address: this.getSenderAddress().toString()
-        });
-    }
-    async signTransaction(txRequest) {
-        const signature = await this.signer(txRequest, this.getSenderAddress());
-        return serializeTransaction(txRequest, signature);
-    }
-    async prepareSignedTransaction(txData) {
-        const txRequest = await this.client.prepareTransactionRequest(txData);
-        return await this.signTransaction(txRequest);
-    }
-    /**
-   * 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, stateChange = 1) {
-        try {
-            const gasConfig = {
-                ...this.config,
-                ..._gasConfig
-            };
-            const account = this.getSenderAddress().toString();
-            let gasLimit;
-            if (this.debugMaxGasLimit) {
-                gasLimit = LARGE_GAS_LIMIT;
-            } else if (gasConfig.gasLimit) {
-                gasLimit = gasConfig.gasLimit;
-            } else {
-                gasLimit = await this.estimateGas(account, request, gasConfig);
-            }
-            this.logger?.debug(`Gas limit for request is ${gasLimit}`, {
-                gasLimit,
-                ...request
-            });
-            const gasPrice = await this.getGasPrice(gasConfig, !!blobInputs);
-            if (gasConfig.txTimeoutAt && this.dateProvider.now() > gasConfig.txTimeoutAt.getTime()) {
-                throw new Error('Transaction timed out before sending');
-            }
-            const nonce = await this.nonceManager.consume({
-                client: this.client,
-                address: account,
-                chainId: this.client.chain.id
-            });
-            let txHash;
-            if (blobInputs) {
-                const txData = {
-                    ...request,
-                    ...blobInputs,
-                    gas: gasLimit,
-                    maxFeePerGas: gasPrice.maxFeePerGas,
-                    maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-                    maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
-                    nonce
-                };
-                const signedRequest = await this.prepareSignedTransaction(txData);
-                txHash = await this.client.sendRawTransaction({
-                    serializedTransaction: signedRequest
-                });
-            } else {
-                const txData = {
-                    ...request,
-                    gas: gasLimit,
-                    maxFeePerGas: gasPrice.maxFeePerGas,
-                    maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-                    nonce
-                };
-                const signedRequest = await this.prepareSignedTransaction(txData);
-                txHash = await this.client.sendRawTransaction({
-                    serializedTransaction: signedRequest
-                });
-            }
-            this.state = stateChange;
-            const cleanGasConfig = pickBy(gasConfig, (_, key)=>key in l1TxUtilsConfigMappings);
-            this.logger?.info(`Sent L1 transaction ${txHash}`, {
-                gasLimit,
-                maxFeePerGas: formatGwei(gasPrice.maxFeePerGas),
-                maxPriorityFeePerGas: formatGwei(gasPrice.maxPriorityFeePerGas),
-                gasConfig: cleanGasConfig,
-                ...gasPrice.maxFeePerBlobGas && {
-                    maxFeePerBlobGas: formatGwei(gasPrice.maxFeePerBlobGas)
-                }
-            });
-            return {
-                txHash,
-                gasLimit,
-                gasPrice
-            };
-        } catch (err) {
-            const viemError = formatViemError(err, request.abi);
-            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 allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
-   * @param params - Parameters used in the initial transaction
-   * @param gasConfig - Optional gas configuration
-   */ async monitorTransaction(request, initialTxHash, allVersions, params, _gasConfig, _blobInputs, isCancelTx = false) {
-        const isBlobTx = !!_blobInputs;
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        const account = this.getSenderAddress().toString();
-        const blobInputs = _blobInputs || {};
-        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.client.getTransaction({
-                hash: initialTxHash
-            }), `Getting L1 transaction ${initialTxHash}`, makeGetTransactionBackoff(), this.logger, true);
-        if (!tx) {
-            throw new Error(`Failed to get L1 transaction ${initialTxHash} to monitor`);
-        }
-        if (tx?.nonce === undefined || tx?.nonce === null) {
-            throw new Error(`Failed to get L1 transaction ${initialTxHash} nonce`);
-        }
-        const nonce = tx.nonce;
-        allVersions.add(initialTxHash);
-        let currentTxHash = initialTxHash;
-        let attempts = 0;
-        let lastAttemptSent = this.dateProvider.now();
-        let lastGasPrice = {
-            maxFeePerGas: tx.maxFeePerGas,
-            maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-            maxFeePerBlobGas: tx.maxFeePerBlobGas
-        };
-        const initialTxTime = lastAttemptSent;
-        let txTimedOut = false;
-        let latestBlockTimestamp;
-        // We check against the latestBlockTimestamp as opposed to the current time to avoid a race condition where
-        // the tx is mined in a block with the same timestamp as txTimeoutAt, but our execution node has not yet processed it,
-        // or the loop here has not yet checked the tx before that timeout.
-        const isTimedOut = ()=>gasConfig.txTimeoutAt && latestBlockTimestamp !== undefined && Number(latestBlockTimestamp) * 1000 >= gasConfig.txTimeoutAt.getTime() || gasConfig.txTimeoutMs !== undefined && this.dateProvider.now() - initialTxTime > gasConfig.txTimeoutMs || this.interrupted || false;
-        while(!txTimedOut){
-            try {
-                ({ timestamp: latestBlockTimestamp } = await this.client.getBlock({
-                    blockTag: 'latest',
-                    includeTransactions: false
-                }));
-                const currentNonce = await this.client.getTransactionCount({
-                    address: account
-                });
-                // If the current nonce on our account is greater than our transaction's nonce then a tx with the same nonce has been mined.
-                if (currentNonce > nonce) {
-                    for (const hash of allVersions){
-                        try {
-                            const receipt = await this.client.getTransactionReceipt({
-                                hash
-                            });
-                            if (receipt) {
-                                if (receipt.status === 'reverted') {
-                                    this.logger?.error(`L1 transaction ${hash} reverted`, receipt);
-                                } else {
-                                    this.logger?.debug(`L1 transaction ${hash} mined`);
-                                }
-                                this.state = 5;
-                                this.lastMinedAtBlockNumber = receipt.blockNumber;
-                                return receipt;
-                            }
-                        } catch (err) {
-                            if (err instanceof Error && err.message.includes('reverted')) {
-                                throw formatViemError(err);
-                            }
-                        }
-                    }
-                    // If we get here then we have checked all of our tx versions and not found anything.
-                    // We should consider the nonce as MINED
-                    this.state = 5;
-                    throw new Error(`Nonce ${nonce} is MINED but not by one of our expected transactions`);
-                }
-                this.logger?.trace(`Tx timeout check for ${currentTxHash}: ${isTimedOut()}`, {
-                    latestBlockTimestamp: Number(latestBlockTimestamp) * 1000,
-                    lastAttemptSent,
-                    initialTxTime,
-                    now: this.dateProvider.now(),
-                    txTimeoutAt: gasConfig.txTimeoutAt?.getTime(),
-                    txTimeoutMs: gasConfig.txTimeoutMs,
-                    txStallTime: gasConfig.stallTimeMs
-                });
-                // Retry a few times, in case the tx is not yet propagated.
-                const tx = await retry(()=>this.client.getTransaction({
-                        hash: currentTxHash
-                    }), `Getting L1 transaction ${currentTxHash}`, makeGetTransactionBackoff(), this.logger, true);
-                const timePassed = this.dateProvider.now() - lastAttemptSent;
-                if (tx && timePassed < gasConfig.stallTimeMs) {
-                    this.logger?.debug(`L1 transaction ${currentTxHash} pending. Time passed: ${timePassed}ms.`);
-                    // Check timeout before continuing
-                    txTimedOut = isTimedOut();
-                    if (txTimedOut) {
-                        break;
-                    }
-                    await sleep(gasConfig.checkIntervalMs);
-                    continue;
-                }
-                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);
-                    lastGasPrice = newGasPrice;
-                    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)
-                        }
-                    });
-                    const txData = {
-                        ...request,
-                        ...blobInputs,
-                        nonce,
-                        gas: params.gasLimit,
-                        maxFeePerGas: newGasPrice.maxFeePerGas,
-                        maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas
-                    };
-                    if (isBlobTx && newGasPrice.maxFeePerBlobGas) {
-                        txData.maxFeePerBlobGas = newGasPrice.maxFeePerBlobGas;
-                    }
-                    const signedRequest = await this.prepareSignedTransaction(txData);
-                    const newHash = await this.client.sendRawTransaction({
-                        serializedTransaction: signedRequest
-                    });
-                    if (!isCancelTx) {
-                        this.state = 2;
-                    }
-                    const cleanGasConfig = pickBy(gasConfig, (_, key)=>key in l1TxUtilsConfigMappings);
-                    this.logger?.verbose(`Sent L1 speed-up tx ${newHash}, replacing ${currentTxHash}`, {
-                        gasLimit: params.gasLimit,
-                        maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
-                        maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
-                        gasConfig: cleanGasConfig,
-                        ...newGasPrice.maxFeePerBlobGas && {
-                            maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas)
-                        }
-                    });
-                    currentTxHash = newHash;
-                    allVersions.add(currentTxHash);
-                    lastAttemptSent = this.dateProvider.now();
-                }
-                await sleep(gasConfig.checkIntervalMs);
-            } catch (err) {
-                const viemError = formatViemError(err);
-                this.logger?.warn(`Error monitoring L1 transaction ${currentTxHash}:`, viemError.message);
-                if (viemError.message?.includes('reverted')) {
-                    throw viemError;
-                }
-                await sleep(gasConfig.checkIntervalMs);
-            }
-            // Check if tx has timed out.
-            txTimedOut = isTimedOut();
-        }
-        // The transaction has timed out. If it's a cancellation then we are giving up on it.
-        // Otherwise we may attempt to cancel it if configured to do so.
-        if (isCancelTx) {
-            this.state = 4;
-        } else if (gasConfig.cancelTxOnTimeout) {
-            // Fire cancellation without awaiting to avoid blocking the main thread
-            this.attemptTxCancellation(currentTxHash, nonce, allVersions, isBlobTx, lastGasPrice, attempts).catch((err)=>{
-                const viemError = formatViemError(err);
-                this.logger?.error(`Failed to send cancellation for timed out tx ${currentTxHash}:`, viemError.message, {
-                    metaMessages: viemError.metaMessages
-                });
-            });
-        }
-        this.logger?.error(`L1 transaction ${currentTxHash} timed out`, {
-            txHash: currentTxHash,
-            txTimeoutAt: gasConfig.txTimeoutAt,
-            txTimeoutMs: gasConfig.txTimeoutMs,
-            txInitialTime: initialTxTime,
-            now: this.dateProvider.now(),
-            attempts,
-            isInterrupted: this.interrupted,
-            ...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) {
-        const { txHash, gasLimit, gasPrice } = await this.sendTransaction(request, gasConfig, blobInputs);
-        const receipt = await this.monitorTransaction(request, txHash, new Set(), {
-            gasLimit
-        }, gasConfig, blobInputs);
-        return {
-            receipt,
-            gasPrice
-        };
-    }
-    async simulate(request, _blockOverrides = {}, stateOverrides = [], abi = RollupAbi, _gasConfig) {
-        const blockOverrides = {
-            ..._blockOverrides
-        };
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        const gasPrice = await this.getGasPrice(gasConfig, false);
-        const call = {
-            to: request.to,
-            data: request.data,
-            from: request.from ?? this.getSenderAddress().toString(),
-            maxFeePerGas: gasPrice.maxFeePerGas,
-            maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-            gas: request.gas ?? LARGE_GAS_LIMIT
-        };
-        if (!request.gas && !gasConfig.ignoreBlockGasLimit) {
-            // LARGE_GAS_LIMIT is set as call.gas, increase block gasLimit
-            blockOverrides.gasLimit = LARGE_GAS_LIMIT * 2n;
-        }
-        return this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
-    }
-    /**
-   * 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 allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
-   * @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(currentTxHash, nonce, allVersions, isBlobTx = false, previousGasPrice, attempts = 0) {
-        if (isBlobTx) {
-            throw new Error('Cannot cancel blob transactions, please use L1TxUtilsWithBlobsClass');
-        }
-        // Get gas price with higher priority fee for cancellation
-        const cancelGasPrice = await this.getGasPrice({
-            ...this.config,
-            // Use high bump for cancellation to ensure it replaces the original tx
-            priorityFeeRetryBumpPercentage: 150
-        }, isBlobTx, attempts + 1, previousGasPrice);
-        this.logger?.info(`Attempting to cancel L1 transaction ${currentTxHash} with nonce ${nonce}`, {
-            maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
-            maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas)
-        });
-        const request = {
-            to: this.getSenderAddress().toString(),
-            value: 0n
-        };
-        // Send 0-value tx to self with higher gas price
-        const txData = {
-            ...request,
-            nonce,
-            gas: 21_000n,
-            maxFeePerGas: cancelGasPrice.maxFeePerGas,
-            maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas
-        };
-        const signedRequest = await this.prepareSignedTransaction(txData);
-        const cancelTxHash = await this.client.sendRawTransaction({
-            serializedTransaction: signedRequest
-        });
-        this.state = 3;
-        this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`, {
-            nonce
-        });
-        const receipt = await this.monitorTransaction(request, cancelTxHash, allVersions, {
-            gasLimit: 21_000n
-        }, undefined, undefined, true);
-        return receipt.transactionHash;
-    }
-}
-export function createViemSigner(client) {
-    const signer = async (tx, _address)=>{
-        const signedTx = await client.signTransaction(tx);
-        const parsed = parseTransaction(signedTx);
-        if (!parsed.r || !parsed.s || parsed.yParity !== 0 && parsed.yParity !== 1) {
-            throw new Error('Failed to extract signature from viem signed transaction');
-        }
-        return {
-            r: parsed.r,
-            s: parsed.s,
-            yParity: parsed.yParity
-        };
-    };
-    return signer;
-}
-export function createL1TxUtilsFromViemWallet(client, logger = createLogger('L1TxUtils'), dateProvider = new DateProvider(), config, debugMaxGasLimit = false) {
-    return new L1TxUtils(client, EthAddress.fromString(client.account.address), createViemSigner(client), logger, dateProvider, config, debugMaxGasLimit);
-}
-export function createL1TxUtilsFromEthSigner(client, signer, logger = createLogger('L1TxUtils'), dateProvider = new DateProvider(), config, debugMaxGasLimit = false) {
-    const callback = async (transaction, _signingAddress)=>{
-        return (await signer.signTransaction(transaction)).toViemTransactionSignature();
-    };
-    return new L1TxUtils(client, signer.address, callback, logger, dateProvider, config, debugMaxGasLimit);
-}
-export function tryGetCustomErrorNameContractFunction(err) {
-    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;
-}