@aztec/ethereum 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/dest/l1_tx_utils/l1_fee_analyzer.js

@@ -0,0 +1,568 @@
+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;
+        });
+    }
+    minBigInt(values) {
+        if (values.length === 0) {
+            return 0n;
+        }
+        return values.reduce((min, val)=>val < min ? val : min, values[0]);
+    }
+}
+/** Safety bound on how far back the window scan walks if the chain head is far ahead of the window. */ const MAX_WINDOW_SCAN_BLOCKS = 64;
+/**
+ * Reads the already-mined L1 blocks whose timestamps fall in [windowStartS, windowEndS) — the L1
+ * inclusion window of an L2 slot — and extracts per-block fee data. Walks block headers to map the
+ * window to block numbers, then reads the priority-fee stats from a single eth_feeHistory call
+ * (percentile 0 is the cheapest included tx, i.e. the inclusion bar), so no transaction bodies are
+ * ever downloaded. Historical reads only, so it never waits on a future block. Returns the blocks in
+ * chronological order, [] on error, or the subset mined so far if the window is still in progress.
+ * Never throws.
+ */ export async function captureWindowBlockFees(client, windowStartS, windowEndS) {
+    try {
+        let current = await client.getBlock({
+            blockTag: 'latest'
+        });
+        const inWindow = [];
+        let scanned = 0;
+        // Walk back from the head, collecting blocks inside the window and skipping any past its end,
+        // until we cross below the window start (or hit the safety cap / genesis).
+        while(current.timestamp >= windowStartS && scanned < MAX_WINDOW_SCAN_BLOCKS){
+            if (current.timestamp < windowEndS) {
+                inWindow.push(current);
+            }
+            if (current.number === 0n) {
+                break;
+            }
+            current = await client.getBlock({
+                blockNumber: current.number - 1n
+            });
+            scanned++;
+        }
+        if (inWindow.length === 0) {
+            return [];
+        }
+        inWindow.reverse();
+        const newest = inWindow[inWindow.length - 1];
+        const feeHistory = await client.getFeeHistory({
+            blockCount: Number(newest.number - inWindow[0].number) + 1,
+            blockNumber: newest.number,
+            rewardPercentiles: [
+                0,
+                75
+            ]
+        });
+        return inWindow.map((block)=>{
+            const idx = Number(block.number - feeHistory.oldestBlock);
+            const [minIncludedPriorityFee, p75PriorityFee] = feeHistory.reward?.[idx] ?? [
+                0n,
+                0n
+            ];
+            const blobsInBlock = block.blobGasUsed ? Number(block.blobGasUsed / GAS_PER_BLOB) : 0;
+            return {
+                blockNumber: block.number,
+                timestamp: block.timestamp,
+                baseFeePerGas: block.baseFeePerGas ?? 0n,
+                p75PriorityFee,
+                minIncludedPriorityFee,
+                blockBlobsFull: blobsInBlock >= getMaxBlobCapacity(block.timestamp),
+                includedBlobCount: blobsInBlock
+            };
+        });
+    } catch  {
+        return [];
+    }
+}

package/dest/l1_tx_utils/l1_tx_utils.d.ts

@@ -1,11 +1,13 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type Logger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings } 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 Abi, type BlockOverrides, type Hex, 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 { Delayer } from './tx_delayer.js';
 import { type L1BlobInputs, type L1TxConfig, type L1TxRequest, type L1TxState, type SigningCallback, TxUtilsState } from './types.js';
 export declare class L1TxUtils extends ReadOnlyL1TxUtils {
     client: ViemClient;
@@ -13,14 +15,26 @@ export declare class L1TxUtils extends ReadOnlyL1TxUtils {
     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);
+    /** Last nonce successfully sent to the chain. Used as a lower bound when a fallback RPC node returns a stale count. */
+    private lastSentNonce;
+    /** Mutex to prevent concurrent sendTransaction calls from racing on the same nonce. */
+    private readonly sendMutex;
+    /** Tx delayer for testing. Only set when enableDelayer config is true. */
+    delayer?: Delayer;
+    /** KZG instance for blob operations. */
+    protected kzg?: BlobKzgInstance;
+    constructor(client: ViemClient, address: EthAddress, signer: SigningCallback, logger?: Logger, dateProvider?: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean, store?: IL1TxStore | undefined, metrics?: IL1TxMetrics | undefined, kzg?: BlobKzgInstance, delayer?: Delayer);
     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;
+    /**
+     * Clears the cached `lastSentNonce` so the next `sendTransaction` call fetches the real
+     * nonce from the chain. Call this after an L1 reorg to prevent stale nonce references.
+     */
+    resetNonce(): void;
     getSenderAddress(): EthAddress;
     getSenderBalance(): Promise<bigint>;
     /**
@@ -30,6 +44,7 @@ export declare class L1TxUtils extends ReadOnlyL1TxUtils {
     loadStateAndResumeMonitoring(): Promise<void>;
     private signTransaction;
     protected prepareSignedTransaction(txData: PrepareTransactionRequestRequest): Promise<`0x${string}`>;
+    private checkInterruptedOrTimedOut;
     /**
      * Sends a transaction with gas estimation and pricing
      * @param request - The transaction request (to, data, value)
@@ -88,7 +103,11 @@ export declare class L1TxUtils extends ReadOnlyL1TxUtils {
      */
     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>;
+    /** Makes empty blob inputs for the cancellation tx. */
+    protected makeEmptyBlobInputs(maxFeePerBlobGas: bigint): Required<L1BlobInputs>;
+    /** Creates a new delayer instance. */
+    protected createDelayer(opts: {
+        ethereumSlotDuration: bigint | number;
+    }, bindings: LoggerBindings): Delayer;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

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