@aztec/ethereum 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/dest/l1_tx_utils/l1_fee_analyzer.js

@@ -0,0 +1,506 @@
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { DateProvider } from '@aztec/foundation/timer';
+import { formatGwei } from 'viem';
+import { calculatePercentile, isBlobTransaction } from '../utils.js';
+import { BLOB_CAPACITY_SCHEDULE, GAS_PER_BLOB, WEI_CONST } from './constants.js';
+import { DEFAULT_PRIORITY_FEE_STRATEGIES } from './fee-strategies/index.js';
+/**
+ * Gets the maximum blob capacity for a given block timestamp
+ */ function getMaxBlobCapacity(blockTimestamp) {
+    const timestamp = Number(blockTimestamp);
+    // Find the applicable schedule entry (sorted by timestamp descending)
+    for (const schedule of BLOB_CAPACITY_SCHEDULE){
+        if (timestamp >= schedule.timestamp) {
+            return schedule.max;
+        }
+    }
+    // Fallback (should never hit)
+    return BLOB_CAPACITY_SCHEDULE[BLOB_CAPACITY_SCHEDULE.length - 1].max;
+}
+/**
+ * Processes a list of transactions to extract blob transaction info and priority fees.
+ * Handles both pending and mined transactions.
+ * Note: Only works with blocks fetched with includeTransactions: true
+ */ function processTransactions(transactions) {
+    const blobTxs = [];
+    const allPriorityFees = [];
+    const blobPriorityFees = [];
+    let totalBlobCount = 0;
+    if (!transactions) {
+        return {
+            blobTxs,
+            allPriorityFees,
+            blobPriorityFees,
+            totalBlobCount
+        };
+    }
+    for (const tx of transactions){
+        const priorityFee = tx.maxPriorityFeePerGas || 0n;
+        if (priorityFee > 0n) {
+            allPriorityFees.push(priorityFee);
+        }
+        // Check if this is a blob transaction
+        if (isBlobTransaction(tx)) {
+            const blobCount = tx.blobVersionedHashes.length;
+            totalBlobCount += blobCount;
+            if (priorityFee > 0n) {
+                blobPriorityFees.push(priorityFee);
+            }
+            blobTxs.push({
+                hash: tx.hash,
+                maxPriorityFeePerGas: priorityFee,
+                maxFeePerGas: tx.maxFeePerGas || 0n,
+                maxFeePerBlobGas: tx.maxFeePerBlobGas,
+                blobCount,
+                gas: tx.gas
+            });
+        }
+    }
+    return {
+        blobTxs,
+        allPriorityFees,
+        blobPriorityFees,
+        totalBlobCount
+    };
+}
+/**
+ * Analyzes L1 transaction fees in fisherman mode.
+ * Captures pending block state, records gas calculations, and compares to what gets included.
+ * Supports multiple priority fee calculation strategies for comparison.
+ */ export class L1FeeAnalyzer {
+    client;
+    dateProvider;
+    logger;
+    maxCompletedAnalyses;
+    gasConfig;
+    pendingAnalyses;
+    pendingCallbacks;
+    completedAnalyses;
+    analysisCounter;
+    strategies;
+    constructor(client, dateProvider = new DateProvider(), logger = createLogger('ethereum:l1-fee-analyzer'), maxCompletedAnalyses = 100, strategies = DEFAULT_PRIORITY_FEE_STRATEGIES, gasConfig = {}){
+        this.client = client;
+        this.dateProvider = dateProvider;
+        this.logger = logger;
+        this.maxCompletedAnalyses = maxCompletedAnalyses;
+        this.gasConfig = gasConfig;
+        this.pendingAnalyses = new Map();
+        this.pendingCallbacks = new Map();
+        this.completedAnalyses = [];
+        this.analysisCounter = 0;
+        this.strategies = strategies;
+    }
+    /**
+   * Executes all configured strategies and returns their results.
+   * Each strategy handles its own RPC calls internally.
+   * @param isBlobTx - Whether this is a blob transaction
+   * @returns Array of strategy results
+   */ async executeAllStrategies(isBlobTx) {
+        const results = [];
+        const context = {
+            gasConfig: this.gasConfig,
+            isBlobTx,
+            logger: this.logger
+        };
+        for (const strategy of this.strategies){
+            try {
+                const result = await strategy.execute(this.client, context);
+                results.push({
+                    strategyId: strategy.id,
+                    strategyName: strategy.name,
+                    calculatedPriorityFee: result.priorityFee,
+                    debugInfo: result.debugInfo
+                });
+                this.logger.debug(`Strategy "${strategy.name}" calculated priority fee`, {
+                    strategyId: strategy.id,
+                    priorityFee: formatGwei(result.priorityFee),
+                    ...result.debugInfo
+                });
+            } catch (err) {
+                this.logger.error(`Error calculating priority fee for strategy "${strategy.name}"`, err, {
+                    strategyId: strategy.id
+                });
+            }
+        }
+        return results;
+    }
+    /**
+   * Captures a snapshot of the current pending block state
+   */ async capturePendingSnapshot() {
+        const timestamp = this.dateProvider.now();
+        // Fetch data in parallel
+        const [latestBlock, pendingBlock, blobBaseFee] = await Promise.all([
+            this.client.getBlock({
+                blockTag: 'latest'
+            }),
+            this.client.getBlock({
+                blockTag: 'pending',
+                includeTransactions: true
+            }).catch(()=>null),
+            this.client.getBlobBaseFee().catch(()=>0n)
+        ]);
+        const baseFeePerGas = latestBlock.baseFeePerGas || 0n;
+        const latestBlockNumber = latestBlock.number;
+        // Extract blob transaction info from pending block
+        const { blobTxs: pendingBlobTxs, allPriorityFees: allPendingPriorityFees, blobPriorityFees: pendingBlobPriorityFees, totalBlobCount: pendingBlobCount } = processTransactions(pendingBlock?.transactions);
+        // Calculate 75th percentile priority fees
+        const pendingP75PriorityFee = calculatePercentile(allPendingPriorityFees, 75);
+        const pendingBlobP75PriorityFee = calculatePercentile(pendingBlobPriorityFees, 75);
+        const pendingTxCount = pendingBlock?.transactions?.length || 0;
+        return {
+            timestamp,
+            latestBlockNumber,
+            baseFeePerGas,
+            blobBaseFee,
+            pendingTxCount,
+            pendingBlobTxCount: pendingBlobTxs.length,
+            pendingBlobCount,
+            pendingBlobTxs,
+            pendingP75PriorityFee,
+            pendingBlobP75PriorityFee
+        };
+    }
+    /**
+   * Starts a fee analysis for a transaction bundle
+   * @param l2SlotNumber - The L2 slot this analysis is for
+   * @param gasLimit - The estimated gas limit
+   * @param requests - The transaction requests being analyzed
+   * @param blobInputs - Blob inputs if this is a blob transaction
+   * @param onComplete - Optional callback to invoke when analysis completes
+   * @returns The analysis ID for tracking
+   */ async startAnalysis(l2SlotNumber, gasLimit, requests, blobInputs, onComplete) {
+        const id = `fee-analysis-${++this.analysisCounter}-${Date.now()}`;
+        const blobCount = blobInputs?.blobs?.length || 0;
+        const isBlobTx = blobCount > 0;
+        // Execute all strategies and capture pending snapshot in parallel
+        const [pendingSnapshot, strategyResults] = await Promise.all([
+            this.capturePendingSnapshot(),
+            this.executeAllStrategies(isBlobTx)
+        ]);
+        const analysis = {
+            id,
+            l2SlotNumber,
+            pendingSnapshot,
+            computedPrices: {
+                gasLimit,
+                blobCount,
+                strategyResults
+            },
+            txInfo: {
+                requestCount: requests.length,
+                hasBlobData: isBlobTx,
+                totalEstimatedGas: gasLimit
+            }
+        };
+        this.pendingAnalyses.set(id, analysis);
+        if (onComplete) {
+            this.pendingCallbacks.set(id, onComplete);
+        }
+        // Log strategy calculations
+        const strategyLogInfo = strategyResults.reduce((acc, s)=>{
+            acc[`strategy_${s.strategyId}`] = formatGwei(s.calculatedPriorityFee);
+            return acc;
+        }, {});
+        this.logger.debug('Started fee analysis with strategy calculations', {
+            id,
+            l2SlotNumber: l2SlotNumber.toString(),
+            pendingBlobTxCount: pendingSnapshot.pendingBlobTxCount,
+            pendingBlobCount: pendingSnapshot.pendingBlobCount,
+            pendingBlobP75: formatGwei(pendingSnapshot.pendingBlobP75PriorityFee),
+            strategiesAnalyzed: strategyResults.length,
+            ...strategyLogInfo
+        });
+        // Start watching for the next block
+        void this.watchForNextBlock(id, pendingSnapshot.latestBlockNumber);
+        return id;
+    }
+    /**
+   * Watches for the next block to be mined and completes the analysis
+   */ async watchForNextBlock(analysisId, startBlockNumber) {
+        const analysis = this.pendingAnalyses.get(analysisId);
+        if (!analysis) {
+            return;
+        }
+        try {
+            // wait for next block
+            await retryUntil(async ()=>{
+                const currentBlockNumber = await this.client.getBlockNumber();
+                if (currentBlockNumber > startBlockNumber) {
+                    return true;
+                }
+                return false;
+            }, 'Wait for next block', 13_000, 0.5);
+            const minedBlock = await this.client.getBlock({
+                includeTransactions: true
+            });
+            this.completeAnalysis(analysisId, minedBlock);
+        } catch (err) {
+            this.logger.error('Error waiting for next block in fee analysis', err, {
+                analysisId
+            });
+        } finally{
+            this.pendingAnalyses.delete(analysisId);
+        }
+    }
+    /**
+   * Completes the analysis once the next block is mined
+   */ completeAnalysis(analysisId, minedBlock) {
+        const analysis = this.pendingAnalyses.get(analysisId);
+        if (!analysis) {
+            return;
+        }
+        // Extract blob transaction info from mined block
+        const { blobTxs: includedBlobTxs, allPriorityFees: includedPriorityFees, blobPriorityFees: includedBlobPriorityFees, totalBlobCount: includedBlobCount } = processTransactions(minedBlock.transactions);
+        // Get minimum included fees
+        const minIncludedPriorityFee = includedPriorityFees.length > 0 ? this.minBigInt(includedPriorityFees) : 0n;
+        const minIncludedBlobPriorityFee = includedBlobPriorityFees.length > 0 ? this.minBigInt(includedBlobPriorityFees) : 0n;
+        // Populate mined block info
+        analysis.minedBlock = {
+            blockNumber: minedBlock.number,
+            blockHash: minedBlock.hash,
+            blockTimestamp: minedBlock.timestamp,
+            baseFeePerGas: minedBlock.baseFeePerGas || 0n,
+            blobGasUsed: minedBlock.blobGasUsed || 0n,
+            txCount: minedBlock.transactions?.length || 0,
+            includedBlobTxCount: includedBlobTxs.length,
+            includedBlobCount,
+            includedBlobTxs,
+            minIncludedPriorityFee,
+            minIncludedBlobPriorityFee
+        };
+        // Calculate time before block mined
+        const blockTimestampMs = Number(minedBlock.timestamp) * 1000;
+        const timeBeforeBlockMs = blockTimestampMs - analysis.pendingSnapshot.timestamp;
+        // Calculate how many blobs were actually in the mined block
+        const blobsInBlock = minedBlock.blobGasUsed > 0n ? Number(minedBlock.blobGasUsed / GAS_PER_BLOB) : 0;
+        const maxBlobCapacity = getMaxBlobCapacity(minedBlock.timestamp);
+        const blockBlobsFull = blobsInBlock >= maxBlobCapacity;
+        // Count how many pending blob txs actually got included
+        const pendingBlobHashes = new Set(analysis.pendingSnapshot.pendingBlobTxs.map((tx)=>tx.hash));
+        const includedBlobHashes = new Set(includedBlobTxs.map((tx)=>tx.hash));
+        const pendingBlobTxsIncludedCount = [
+            ...pendingBlobHashes
+        ].filter((h)=>includedBlobHashes.has(h)).length;
+        const pendingBlobTxsExcludedCount = analysis.pendingSnapshot.pendingBlobTxCount - pendingBlobTxsIncludedCount;
+        analysis.analysis = {
+            timeBeforeBlockMs,
+            pendingBlobTxsIncludedCount,
+            pendingBlobTxsExcludedCount,
+            blobsInBlock,
+            maxBlobCapacity,
+            blockBlobsFull
+        };
+        // Evaluate each strategy against the mined block
+        const isBlobTx = analysis.computedPrices.blobCount > 0;
+        const minPriorityFeeToCompare = isBlobTx ? minIncludedBlobPriorityFee : minIncludedPriorityFee;
+        const gasLimit = analysis.computedPrices.gasLimit;
+        if (analysis.computedPrices.strategyResults) {
+            for (const strategyResult of analysis.computedPrices.strategyResults){
+                const strategyPriorityFee = strategyResult.calculatedPriorityFee;
+                const strategyPriorityFeeDelta = strategyPriorityFee - minPriorityFeeToCompare;
+                // Determine if this strategy would have resulted in inclusion
+                let strategyWouldBeIncluded = true;
+                let strategyExclusionReason;
+                if (isBlobTx) {
+                    // For blob txs, only consider priority fee if blob space was full
+                    if (includedBlobPriorityFees.length > 0 && strategyPriorityFee < minIncludedBlobPriorityFee && blockBlobsFull) {
+                        strategyWouldBeIncluded = false;
+                        strategyExclusionReason = 'priority_fee_too_low';
+                    }
+                } else {
+                    // For non-blob txs, use the old logic
+                    if (includedPriorityFees.length > 0 && strategyPriorityFee < minIncludedPriorityFee) {
+                        strategyWouldBeIncluded = false;
+                        strategyExclusionReason = 'priority_fee_too_low';
+                    }
+                }
+                // Calculate estimated cost in ETH for this strategy
+                // Cost = gasLimit * (baseFee + priorityFee)
+                const baseFee = analysis.minedBlock.baseFeePerGas;
+                // Execution cost: gasLimit * (baseFee + priorityFee)
+                const executionCostWei = gasLimit * (baseFee + strategyPriorityFee);
+                const estimatedCostEth = Number(executionCostWei) / 1e18;
+                // Calculate minimum cost needed for inclusion
+                const minExecutionCostWei = gasLimit * (baseFee + minPriorityFeeToCompare);
+                const minCostEth = Number(minExecutionCostWei) / 1e18;
+                // Overpayment is the difference
+                const estimatedOverpaymentEth = estimatedCostEth - minCostEth;
+                // Update the strategy result with analysis data
+                strategyResult.wouldBeIncluded = strategyWouldBeIncluded;
+                strategyResult.exclusionReason = strategyExclusionReason;
+                strategyResult.priorityFeeDelta = strategyPriorityFeeDelta;
+                strategyResult.estimatedCostEth = estimatedCostEth;
+                strategyResult.estimatedOverpaymentEth = estimatedOverpaymentEth;
+                // Log per-strategy results
+                this.logger.info(`Strategy "${strategyResult.strategyName}" analysis`, {
+                    id: analysisId,
+                    strategyId: strategyResult.strategyId,
+                    strategyName: strategyResult.strategyName,
+                    calculatedPriorityFee: formatGwei(strategyPriorityFee),
+                    minIncludedPriorityFee: formatGwei(minPriorityFeeToCompare),
+                    priorityFeeDelta: formatGwei(strategyPriorityFeeDelta),
+                    wouldBeIncluded: strategyWouldBeIncluded,
+                    exclusionReason: strategyExclusionReason,
+                    estimatedCostEth: estimatedCostEth.toFixed(6),
+                    estimatedOverpaymentEth: estimatedOverpaymentEth.toFixed(6)
+                });
+            }
+            // Create cost ranking
+            const costRanking = analysis.computedPrices.strategyResults.map((s)=>({
+                    strategyId: s.strategyId,
+                    strategyName: s.strategyName,
+                    estimatedCostEth: s.estimatedCostEth,
+                    wouldBeIncluded: s.wouldBeIncluded
+                })).sort((a, b)=>a.estimatedCostEth - b.estimatedCostEth);
+            analysis.analysis.costRanking = costRanking;
+            // Log cost ranking summary
+            this.logger.info('Strategy cost ranking', {
+                id: analysisId,
+                cheapestStrategy: costRanking[0]?.strategyName,
+                cheapestCost: costRanking[0]?.estimatedCostEth.toFixed(6),
+                cheapestWouldBeIncluded: costRanking[0]?.wouldBeIncluded,
+                mostExpensiveStrategy: costRanking[costRanking.length - 1]?.strategyName,
+                mostExpensiveCost: costRanking[costRanking.length - 1]?.estimatedCostEth.toFixed(6),
+                mostExpensiveWouldBeIncluded: costRanking[costRanking.length - 1]?.wouldBeIncluded,
+                costSpread: costRanking.length > 1 ? (costRanking[costRanking.length - 1].estimatedCostEth - costRanking[0].estimatedCostEth).toFixed(6) : '0'
+            });
+        }
+        // Log the overall results
+        this.logger.info('Fee analysis completed', {
+            id: analysisId,
+            l2SlotNumber: analysis.l2SlotNumber.toString(),
+            timeBeforeBlockMs,
+            pendingBlobTxCount: analysis.pendingSnapshot.pendingBlobTxCount,
+            includedBlobTxCount: analysis.minedBlock.includedBlobTxCount,
+            pendingBlobTxsIncludedCount,
+            pendingBlobTxsExcludedCount,
+            blobsInBlock,
+            maxBlobCapacity,
+            blockBlobsFull,
+            minIncludedPriorityFee: formatGwei(minIncludedPriorityFee),
+            minIncludedBlobPriorityFee: formatGwei(minIncludedBlobPriorityFee),
+            strategiesAnalyzed: analysis.computedPrices.strategyResults?.length ?? 0
+        });
+        // Move to completed analyses
+        this.pendingAnalyses.delete(analysisId);
+        this.completedAnalyses.push(analysis);
+        // Trim old completed analyses if needed
+        while(this.completedAnalyses.length > this.maxCompletedAnalyses){
+            this.completedAnalyses.shift();
+        }
+        // Invoke the callback for this specific analysis
+        const callback = this.pendingCallbacks.get(analysisId);
+        if (callback) {
+            try {
+                callback(analysis);
+            } catch (err) {
+                this.logger.error('Error in analysis complete callback', err);
+            }
+            this.pendingCallbacks.delete(analysisId);
+        }
+    }
+    /**
+   * Gets a specific analysis result by ID
+   */ getAnalysis(id) {
+        return this.pendingAnalyses.get(id) || this.completedAnalyses.find((a)=>a.id === id);
+    }
+    /**
+   * Gets all completed analyses
+   */ getCompletedAnalyses() {
+        return [
+            ...this.completedAnalyses
+        ];
+    }
+    /**
+   * Gets statistics about all completed analyses
+   */ getAnalysisStats() {
+        const completed = this.completedAnalyses.filter((a)=>a.analysis);
+        if (completed.length === 0) {
+            return {
+                totalAnalyses: 0,
+                avgTimeBeforeBlockMs: 0,
+                avgBlobsInBlock: 0,
+                blocksBlobsFull: 0
+            };
+        }
+        const avgTimeBeforeBlockMs = completed.reduce((sum, a)=>sum + a.analysis.timeBeforeBlockMs, 0) / completed.length;
+        const avgBlobsInBlock = completed.reduce((sum, a)=>sum + a.analysis.blobsInBlock, 0) / completed.length;
+        const blocksBlobsFull = completed.filter((a)=>a.analysis.blockBlobsFull).length;
+        return {
+            totalAnalyses: completed.length,
+            avgTimeBeforeBlockMs,
+            avgBlobsInBlock,
+            blocksBlobsFull
+        };
+    }
+    /**
+   * Gets comparative statistics for all strategies across completed analyses
+   */ getStrategyComparison() {
+        const completed = this.completedAnalyses.filter((a)=>a.analysis);
+        if (completed.length === 0) {
+            return [];
+        }
+        // Collect data by strategy ID
+        const strategyData = new Map();
+        for (const analysis of completed){
+            if (!analysis.computedPrices.strategyResults) {
+                continue;
+            }
+            for (const strategyResult of analysis.computedPrices.strategyResults){
+                if (!strategyData.has(strategyResult.strategyId)) {
+                    strategyData.set(strategyResult.strategyId, {
+                        strategyName: strategyResult.strategyName,
+                        analyses: 0,
+                        inclusions: 0,
+                        totalCostEth: 0,
+                        totalOverpaymentEth: 0,
+                        totalPriorityFeeDelta: 0
+                    });
+                }
+                const data = strategyData.get(strategyResult.strategyId);
+                data.analyses++;
+                if (strategyResult.wouldBeIncluded) {
+                    data.inclusions++;
+                }
+                if (strategyResult.estimatedCostEth !== undefined) {
+                    data.totalCostEth += strategyResult.estimatedCostEth;
+                }
+                if (strategyResult.estimatedOverpaymentEth !== undefined) {
+                    data.totalOverpaymentEth += strategyResult.estimatedOverpaymentEth;
+                }
+                if (strategyResult.priorityFeeDelta !== undefined) {
+                    data.totalPriorityFeeDelta += Number(strategyResult.priorityFeeDelta);
+                }
+            }
+        }
+        // Convert to output format
+        const results = Array.from(strategyData.entries()).map(([strategyId, data])=>({
+                strategyId,
+                strategyName: data.strategyName,
+                totalAnalyses: data.analyses,
+                inclusionCount: data.inclusions,
+                inclusionRate: data.analyses > 0 ? data.inclusions / data.analyses : 0,
+                avgEstimatedCostEth: data.analyses > 0 ? data.totalCostEth / data.analyses : 0,
+                totalEstimatedCostEth: data.totalCostEth,
+                avgOverpaymentEth: data.analyses > 0 ? data.totalOverpaymentEth / data.analyses : 0,
+                totalOverpaymentEth: data.totalOverpaymentEth,
+                avgPriorityFeeDeltaGwei: data.analyses > 0 ? data.totalPriorityFeeDelta / data.analyses / Number(WEI_CONST) : 0
+            }));
+        // Sort by inclusion rate descending, then by avg cost ascending
+        return results.sort((a, b)=>{
+            if (Math.abs(a.inclusionRate - b.inclusionRate) > 0.01) {
+                return b.inclusionRate - a.inclusionRate;
+            }
+            return a.avgEstimatedCostEth - b.avgEstimatedCostEth;
+        });
+    }
+    /**
+   * Gets the minimum value from an array of bigints
+   */ minBigInt(values) {
+        if (values.length === 0) {
+            return 0n;
+        }
+        return values.reduce((min, val)=>val < min ? val : min, values[0]);
+    }
+}

package/dest/l1_tx_utils/l1_tx_utils.d.ts

@@ -0,0 +1,94 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { type Abi, type BlockOverrides, type Hex, type NonceManager, type PrepareTransactionRequestRequest, type StateOverride, type TransactionReceipt } from 'viem';
+import type { ViemClient } from '../types.js';
+import { type L1TxUtilsConfig } from './config.js';
+import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
+import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
+import { type L1BlobInputs, type L1TxConfig, type L1TxRequest, type L1TxState, type SigningCallback, TxUtilsState } from './types.js';
+export declare class L1TxUtils extends ReadOnlyL1TxUtils {
+    client: ViemClient;
+    address: EthAddress;
+    protected signer: SigningCallback;
+    protected store?: IL1TxStore | undefined;
+    protected metrics?: IL1TxMetrics | undefined;
+    protected nonceManager: NonceManager;
+    protected txs: L1TxState[];
+    constructor(client: ViemClient, address: EthAddress, signer: SigningCallback, logger?: Logger, dateProvider?: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean, store?: IL1TxStore | undefined, metrics?: IL1TxMetrics | undefined);
+    get state(): TxUtilsState;
+    get lastMinedAtBlockNumber(): bigint | undefined;
+    protected updateState(l1TxState: L1TxState, newState: TxUtilsState.MINED, l1Timestamp: number): Promise<void>;
+    protected updateState(l1TxState: L1TxState, newState: TxUtilsState, l1Timestamp?: undefined): Promise<void>;
+    updateConfig(newConfig: Partial<L1TxUtilsConfig>): void;
+    getSenderAddress(): EthAddress;
+    getSenderBalance(): Promise<bigint>;
+    /**
+     * Rehydrates transaction states from the store and resumes monitoring for pending transactions.
+     * This should be called on startup to restore state and resume monitoring of any in-flight transactions.
+     */
+    loadStateAndResumeMonitoring(): Promise<void>;
+    private signTransaction;
+    protected prepareSignedTransaction(txData: PrepareTransactionRequestRequest): Promise<`0x${string}`>;
+    /**
+     * 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
+     */
+    sendTransaction(request: L1TxRequest, gasConfigOverrides?: L1TxConfig, blobInputs?: L1BlobInputs, stateChange?: TxUtilsState): Promise<{
+        txHash: Hex;
+        state: L1TxState;
+    }>;
+    private tryGetTxReceipt;
+    /**
+     * Returns whether a given tx should be considered as timed out and no longer monitored.
+     * Relies on the txTimeout setting for user txs, and on the txCancellationTimeout for cancel txs.
+     * @remarks 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.
+     */
+    private isTxTimedOut;
+    /**
+     * Monitors a transaction until completion, handling speed-ups if needed
+     */
+    protected monitorTransaction(state: L1TxState): Promise<TransactionReceipt>;
+    /**
+     * Creates tx data to be signed by viem signTransaction method, using the state as input.
+     * If isCancelTx is true, creates a 0-value tx to self with 21k gas and no data instead,
+     * and an empty blob input if the original tx also had blobs.
+     */
+    private makeTxData;
+    /** Returns when all monitor loops have stopped. */
+    waitMonitoringStopped(timeoutSeconds?: number): Promise<void>;
+    /**
+     * 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
+     */
+    sendAndMonitorTransaction(request: L1TxRequest, gasConfig?: L1TxConfig, blobInputs?: L1BlobInputs): Promise<{
+        receipt: TransactionReceipt;
+        state: L1TxState;
+    }>;
+    simulate(request: L1TxRequest & {
+        gas?: bigint;
+        from?: Hex;
+    }, _blockOverrides?: BlockOverrides<bigint, number>, stateOverrides?: StateOverride, abi?: Abi, _gasConfig?: L1TxUtilsConfig & {
+        fallbackGasEstimate?: bigint;
+        ignoreBlockGasLimit?: boolean;
+    }): Promise<{
+        gasUsed: bigint;
+        result: `0x${string}`;
+    }>;
+    /**
+     * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
+     * Only sends the cancellation if the original tx is still pending, not if it was dropped
+     * @returns The hash of the cancellation transaction
+     */
+    protected attemptTxCancellation(state: L1TxState): Promise<void>;
+    private getL1Timestamp;
+    /** Makes empty blob inputs for the cancellation tx. To be overridden in L1TxUtilsWithBlobs. */
+    protected makeEmptyBlobInputs(_maxFeePerBlobGas: bigint): Required<L1BlobInputs>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/l1_tx_utils/l1_tx_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_tx_utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/l1_tx_utils.ts"],"names":[],"mappings":"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"}