@aztec/ethereum 0.0.1-commit.9b94fc1 → 0.0.1-commit.9ee6fcc6

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -1,8 +1,9 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { merge, pick } from '@aztec/foundation/collection';
 import { InterruptError, TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
@@ -13,23 +14,21 @@ import {
   type Abi,
   type BlockOverrides,
   type Hex,
-  type NonceManager,
   type PrepareTransactionRequestRequest,
   type StateOverride,
   type TransactionReceipt,
   type TransactionSerializable,
-  createNonceManager,
   formatGwei,
   serializeTransaction,
 } from 'viem';
-import { jsonRpc } from 'viem/nonce';
 
 import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
-import { LARGE_GAS_LIMIT } from './constants.js';
+import { MAX_L1_TX_LIMIT } from './constants.js';
 import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
 import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
+import { Delayer, createDelayer, wrapClientWithDelayer } from './tx_delayer.js';
 import {
   DroppedTransactionError,
   type L1BlobInputs,
@@ -45,8 +44,13 @@ import {
 const MAX_L1_TX_STATES = 32;
 
 export class L1TxUtils extends ReadOnlyL1TxUtils {
-  protected nonceManager: NonceManager;
   protected txs: L1TxState[] = [];
+  /** Last nonce successfully sent to the chain. Used as a lower bound when a fallback RPC node returns a stale count. */
+  private lastSentNonce: number | undefined;
+  /** Tx delayer for testing. Only set when enableDelayer config is true. */
+  public delayer?: Delayer;
+  /** KZG instance for blob operations. */
+  protected kzg?: BlobKzgInstance;
 
   constructor(
     public override client: ViemClient,
@@ -58,9 +62,25 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     debugMaxGasLimit: boolean = false,
     protected store?: IL1TxStore,
     protected metrics?: IL1TxMetrics,
+    kzg?: BlobKzgInstance,
+    delayer?: Delayer,
   ) {
     super(client, logger, dateProvider, config, debugMaxGasLimit);
-    this.nonceManager = createNonceManager({ source: jsonRpc() });
+    this.kzg = kzg;
+
+    // Set up delayer: use provided one or create new
+    if (config?.enableDelayer && config?.ethereumSlotDuration) {
+      this.delayer =
+        delayer ?? this.createDelayer({ ethereumSlotDuration: config.ethereumSlotDuration }, logger.getBindings());
+      this.client = wrapClientWithDelayer(this.client, this.delayer);
+      if (config.txDelayerMaxInclusionTimeIntoSlot !== undefined) {
+        this.delayer.setMaxInclusionTimeIntoSlot(config.txDelayerMaxInclusionTimeIntoSlot);
+      }
+    } else if (delayer) {
+      // Delayer provided but enableDelayer not set — just store it without wrapping
+      logger.warn('Delayer provided but enableDelayer config is not set; delayer will not be used');
+      this.delayer = delayer;
+    }
   }
 
   public get state() {
@@ -87,6 +107,11 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       this.metrics?.recordMinedTx(l1TxState, new Date(l1Timestamp));
     } else if (newState === TxUtilsState.NOT_MINED) {
       this.metrics?.recordDroppedTx(l1TxState);
+      // The tx was dropped: the chain nonce reverted to l1TxState.nonce, so our lower bound is
+      // no longer valid. Clear it so the next send fetches the real nonce from the chain.
+      if (this.lastSentNonce === l1TxState.nonce) {
+        this.lastSentNonce = undefined;
+      }
     }
 
     // Update state in the store
@@ -130,12 +155,32 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       return;
     }
 
-    // Convert loaded states (which have id) to the txs format
-    this.txs = loadedStates;
-    this.logger.info(`Rehydrated ${loadedStates.length} tx states for account ${account}`);
+    // Clean up excess states if we have more than MAX_L1_TX_STATES
+    if (loadedStates.length > MAX_L1_TX_STATES) {
+      this.logger.warn(
+        `Found ${loadedStates.length} tx states for account ${account}, pruning to most recent ${MAX_L1_TX_STATES}`,
+      );
+
+      // Keep only the most recent MAX_L1_TX_STATES
+      const statesToKeep = loadedStates.slice(-MAX_L1_TX_STATES);
+      const statesToDelete = loadedStates.slice(0, -MAX_L1_TX_STATES);
+
+      // Batch delete old states in a transaction for efficiency
+      const idsToDelete = statesToDelete.map(s => s.id);
+      await this.store.deleteState(account, ...idsToDelete);
+
+      this.txs = statesToKeep;
+      this.logger.info(
+        `Cleaned up ${statesToDelete.length} old tx states, kept ${statesToKeep.length} for account ${account}`,
+      );
+    } else {
+      // Convert loaded states (which have id) to the txs format
+      this.txs = loadedStates;
+      this.logger.info(`Rehydrated ${loadedStates.length} tx states for account ${account}`);
+    }
 
     // Find all pending states and resume monitoring
-    const pendingStates = loadedStates.filter(state => !TerminalTxUtilsState.includes(state.status));
+    const pendingStates = this.txs.filter(state => !TerminalTxUtilsState.includes(state.status));
     if (pendingStates.length === 0) {
       return;
     }
@@ -187,7 +232,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
       let gasLimit: bigint;
       if (this.debugMaxGasLimit) {
-        gasLimit = LARGE_GAS_LIMIT;
+        gasLimit = MAX_L1_TX_LIMIT;
       } else if (gasConfig.gasLimit) {
         gasLimit = gasConfig.gasLimit;
       } else {
@@ -201,15 +246,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         throw new InterruptError(`Transaction sending is interrupted`);
       }
 
-      const nonce = await this.nonceManager.consume({
-        client: this.client,
-        address: account,
-        chainId: this.client.chain.id,
-      });
-
-      const baseState = { request, gasLimit, blobInputs, gasPrice, nonce };
-      const txData = this.makeTxData(baseState, { isCancelTx: false });
-
       const now = new Date(await this.getL1Timestamp());
       if (gasConfig.txTimeoutAt && now > gasConfig.txTimeoutAt) {
         throw new TimeoutError(
@@ -217,9 +253,20 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         );
       }
 
+      const chainNonce = await this.client.getTransactionCount({ address: account, blockTag: 'pending' });
+      // If a fallback RPC node returns a stale count (lower than what we last sent), use our
+      // local lower bound to avoid sending a duplicate of an already-pending transaction.
+      const nonce =
+        this.lastSentNonce !== undefined && chainNonce <= this.lastSentNonce ? this.lastSentNonce + 1 : chainNonce;
+
+      const baseState = { request, gasLimit, blobInputs, gasPrice, nonce };
+      const txData = this.makeTxData(baseState, { isCancelTx: false });
+
       // Send the new tx
       const signedRequest = await this.prepareSignedTransaction(txData);
       const txHash = await this.client.sendRawTransaction({ serializedTransaction: signedRequest });
+      // Update after tx is sent successfully
+      this.lastSentNonce = nonce;
 
       // Create the new state for monitoring
       const l1TxState: L1TxState = {
@@ -263,7 +310,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       return { txHash, state: l1TxState };
     } catch (err: any) {
       const viemError = formatViemError(err, request.abi);
-      this.logger.error(`Failed to send L1 transaction`, viemError, {
+      this.logger.error(`Failed to send L1 transaction: ${viemError.message}`, viemError, {
         request: pick(request, 'to', 'value'),
       });
       throw viemError;
@@ -403,7 +450,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             { nonce, account, pendingNonce, timePassed },
           );
           await this.updateState(state, TxUtilsState.NOT_MINED);
-          this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
           throw new DroppedTransactionError(nonce, account);
         }
 
@@ -495,12 +541,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
     // Oh no, the transaction has timed out!
     if (isCancelTx || !gasConfig.cancelTxOnTimeout) {
-      // If this was already a cancellation tx, or we are configured to not cancel txs, we just mark it as NOT_MINED
-      // and reset the nonce manager, so the next tx that comes along can reuse the nonce if/when this tx gets dropped.
-      // This is the nastiest scenario for us, since the new tx could acquire the next nonce, but then this tx is dropped,
-      // and the new tx would never get mined. Eventually, the new tx would also drop.
       await this.updateState(state, TxUtilsState.NOT_MINED);
-      this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
     } else {
       // Otherwise we fire the cancellation without awaiting to avoid blocking the caller,
       // and monitor it in the background so we can speed it up as needed.
@@ -611,12 +652,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       from: request.from ?? this.getSenderAddress().toString(),
       maxFeePerGas: gasPrice.maxFeePerGas,
       maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
-      gas: request.gas ?? LARGE_GAS_LIMIT,
+      gas: request.gas ?? MAX_L1_TX_LIMIT,
     };
 
     if (!request.gas && !gasConfig.ignoreBlockGasLimit) {
-      // LARGE_GAS_LIMIT is set as call.gas, increase block gasLimit
-      blockOverrides.gasLimit = LARGE_GAS_LIMIT * 2n;
+      // MAX_L1_TX_LIMIT is set as call.gas, ensure block gasLimit is sufficient
+      blockOverrides.gasLimit = MAX_L1_TX_LIMIT;
     }
 
     return this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
@@ -639,7 +680,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         { nonce, account },
       );
       await this.updateState(state, TxUtilsState.NOT_MINED);
-      this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
       return;
     }
 
@@ -651,7 +691,6 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         { nonce, account, currentNonce },
       );
       await this.updateState(state, TxUtilsState.NOT_MINED);
-      this.nonceManager.reset({ address: account, chainId: this.client.chain.id });
       return;
     }
 
@@ -711,8 +750,17 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     return Number(timestamp) * 1000;
   }
 
-  /** Makes empty blob inputs for the cancellation tx. To be overridden in L1TxUtilsWithBlobs. */
-  protected makeEmptyBlobInputs(_maxFeePerBlobGas: bigint): Required<L1BlobInputs> {
-    throw new Error('Cannot make empty blob inputs for cancellation');
+  /** Makes empty blob inputs for the cancellation tx. */
+  protected makeEmptyBlobInputs(maxFeePerBlobGas: bigint): Required<L1BlobInputs> {
+    if (!this.kzg) {
+      throw new Error('Cannot make empty blob inputs for cancellation without kzg');
+    }
+    const blobData = new Uint8Array(131072).fill(0);
+    return { blobs: [blobData], kzg: this.kzg, maxFeePerBlobGas };
+  }
+
+  /** Creates a new delayer instance. */
+  protected createDelayer(opts: { ethereumSlotDuration: bigint | number }, bindings: LoggerBindings): Delayer {
+    return createDelayer(this.dateProvider, opts, bindings);
   }
 }

package/src/l1_tx_utils/readonly_l1_tx_utils.ts

@@ -1,4 +1,5 @@
-import { getKeys, median, merge, pick, times } from '@aztec/foundation/collection';
+import { getKeys, merge, pick, times } from '@aztec/foundation/collection';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { DateProvider } from '@aztec/foundation/timer';
@@ -11,6 +12,7 @@ import {
   type BaseError,
   type BlockOverrides,
   type ContractFunctionExecutionError,
+  type GetCodeReturnType,
   type Hex,
   MethodNotFoundRpcError,
   MethodNotSupportedRpcError,
@@ -25,15 +27,17 @@ import type { ViemClient } from '../types.js';
 import { type L1TxUtilsConfig, defaultL1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
 import {
   BLOCK_TIME_MS,
-  LARGE_GAS_LIMIT,
+  MAX_L1_TX_LIMIT,
   MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE,
   MIN_REPLACEMENT_BUMP_PERCENTAGE,
   WEI_CONST,
 } from './constants.js';
+import { P75AllTxsPriorityFeeStrategy, type PriorityFeeStrategy } from './fee-strategies/index.js';
 import type { GasPrice, L1BlobInputs, L1TxRequest, TransactionStats } from './types.js';
 import { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
 
-const HISTORICAL_BLOCK_COUNT = 5;
+// Change this to the current strategy we want to use
+const CurrentStrategy: PriorityFeeStrategy = P75AllTxsPriorityFeeStrategy;
 
 export class ReadOnlyL1TxUtils {
   public config: Required<L1TxUtilsConfig>;
@@ -65,122 +69,8 @@ export class ReadOnlyL1TxUtils {
     return this.client.getBlockNumber();
   }
 
-  /**
-   * Analyzes pending transactions and recent fee history to determine a competitive priority fee.
-   * Falls back to network estimate if data is unavailable or fails.
-   * @param networkEstimateResult - Result from estimateMaxPriorityFeePerGas RPC call
-   * @param pendingBlockResult - Result from getBlock with pending tag RPC call
-   * @param feeHistoryResult - Result from getFeeHistory RPC call
-   * @returns A competitive priority fee based on pending txs and recent block history
-   */
-  protected getCompetitivePriorityFee(
-    networkEstimateResult: PromiseSettledResult<bigint | null>,
-    pendingBlockResult: PromiseSettledResult<Awaited<ReturnType<ViemClient['getBlock']>> | null>,
-    feeHistoryResult: PromiseSettledResult<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>,
-  ): bigint {
-    const networkEstimate =
-      networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint'
-        ? networkEstimateResult.value
-        : 0n;
-    let competitiveFee = networkEstimate;
-
-    if (
-      pendingBlockResult.status === 'fulfilled' &&
-      pendingBlockResult.value !== null &&
-      pendingBlockResult.value.transactions &&
-      pendingBlockResult.value.transactions.length > 0
-    ) {
-      const pendingBlock = pendingBlockResult.value;
-      // Extract priority fees from pending transactions
-      const pendingFees = pendingBlock.transactions
-        .map(tx => {
-          // Transaction can be just a hash string, so we need to check if it's an object
-          if (typeof tx === 'string') {
-            return 0n;
-          }
-          const fee = tx.maxPriorityFeePerGas || 0n;
-          // Debug: Log suspicious fees
-          if (fee > 100n * WEI_CONST) {
-            this.logger?.warn('Suspicious high priority fee in pending tx', {
-              txHash: tx.hash,
-              maxPriorityFeePerGas: formatGwei(fee),
-              maxFeePerGas: formatGwei(tx.maxFeePerGas || 0n),
-              maxFeePerBlobGas: tx.maxFeePerBlobGas ? formatGwei(tx.maxFeePerBlobGas) : 'N/A',
-            });
-          }
-          return fee;
-        })
-        .filter((fee: bigint) => fee > 0n);
-
-      if (pendingFees.length > 0) {
-        // Use 75th percentile of pending fees to be competitive
-        const sortedPendingFees = [...pendingFees].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
-        const percentile75Index = Math.floor((sortedPendingFees.length - 1) * 0.75);
-        const pendingCompetitiveFee = sortedPendingFees[percentile75Index];
-
-        if (pendingCompetitiveFee > competitiveFee) {
-          competitiveFee = pendingCompetitiveFee;
-        }
-
-        this.logger?.debug('Analyzed pending transactions for competitive pricing', {
-          pendingTxCount: pendingFees.length,
-          pendingP75: formatGwei(pendingCompetitiveFee),
-        });
-      }
-    }
-    if (
-      feeHistoryResult.status === 'fulfilled' &&
-      feeHistoryResult.value !== null &&
-      feeHistoryResult.value.reward &&
-      feeHistoryResult.value.reward.length > 0
-    ) {
-      const feeHistory = feeHistoryResult.value;
-      // Extract 75th percentile fees from each block
-      const percentile75Fees = feeHistory.reward!.map(rewards => rewards[0] || 0n).filter(fee => fee > 0n);
-
-      if (percentile75Fees.length > 0) {
-        // Calculate median of the 75th percentile fees across blocks
-        const medianHistoricalFee = median(percentile75Fees) ?? 0n;
-
-        // Debug: Log suspicious fees from history
-        if (medianHistoricalFee > 100n * WEI_CONST) {
-          this.logger?.warn('Suspicious high fee in history', {
-            historicalMedian: formatGwei(medianHistoricalFee),
-            allP75Fees: percentile75Fees.map(f => formatGwei(f)),
-          });
-        }
-
-        if (medianHistoricalFee > competitiveFee) {
-          competitiveFee = medianHistoricalFee;
-        }
-
-        this.logger?.debug('Analyzed fee history for competitive pricing', {
-          historicalMedian: formatGwei(medianHistoricalFee),
-        });
-      }
-    }
-
-    // Sanity check: cap competitive fee at 100x network estimate to avoid using unrealistic fees
-    // (e.g., Anvil returns inflated historical fees that don't reflect actual network conditions)
-    const maxReasonableFee = networkEstimate * 100n;
-    if (competitiveFee > maxReasonableFee) {
-      this.logger?.warn('Competitive fee exceeds sanity cap, using capped value', {
-        competitiveFee: formatGwei(competitiveFee),
-        networkEstimate: formatGwei(networkEstimate),
-        cappedTo: formatGwei(maxReasonableFee),
-      });
-      competitiveFee = maxReasonableFee;
-    }
-
-    // Log final decision
-    if (competitiveFee > networkEstimate) {
-      this.logger?.debug('Using competitive fee from market analysis', {
-        networkEstimate: formatGwei(networkEstimate),
-        competitive: formatGwei(competitiveFee),
-      });
-    }
-
-    return competitiveFee;
+  public getCode(address: EthAddress): Promise<GetCodeReturnType> {
+    return this.client.getCode({ address: address.toString() });
   }
 
   /**
@@ -194,76 +84,56 @@ export class ReadOnlyL1TxUtils {
   ): Promise<GasPrice> {
     const gasConfig = merge(this.config, gasConfigOverrides);
 
-    // Make all RPC calls in parallel upfront with retry logic
-    const latestBlockPromise = this.tryTwice(
-      () => this.client.getBlock({ blockTag: 'latest' }),
-      'Getting latest block',
+    // Execute strategy - it handles all RPC calls internally and returns everything we need
+    const strategyResult = await retry(
+      () =>
+        CurrentStrategy.execute(this.client, {
+          gasConfig,
+          isBlobTx,
+          logger: this.logger,
+        }),
+      'Executing priority fee strategy',
+      makeBackoff(times(2, () => 0)),
+      this.logger,
+      true,
     );
-    const networkEstimatePromise = gasConfig.fixedPriorityFeePerGas
-      ? null
-      : this.tryTwice(() => this.client.estimateMaxPriorityFeePerGas(), 'Estimating max priority fee per gas');
-    const pendingBlockPromise = gasConfig.fixedPriorityFeePerGas
-      ? null
-      : this.tryTwice(
-          () => this.client.getBlock({ blockTag: 'pending', includeTransactions: true }),
-          'Getting pending block',
-        );
-    const feeHistoryPromise = gasConfig.fixedPriorityFeePerGas
-      ? null
-      : this.tryTwice(
-          () => this.client.getFeeHistory({ blockCount: HISTORICAL_BLOCK_COUNT, rewardPercentiles: [75] }),
-          'Getting fee history',
-        );
-    const blobBaseFeePromise = isBlobTx
-      ? this.tryTwice(() => this.client.getBlobBaseFee(), 'Getting blob base fee')
-      : null;
-
-    const [latestBlockResult, networkEstimateResult, pendingBlockResult, feeHistoryResult, blobBaseFeeResult] =
-      await Promise.allSettled([
-        latestBlockPromise,
-        networkEstimatePromise ?? Promise.resolve(0n),
-        pendingBlockPromise ?? Promise.resolve(null),
-        feeHistoryPromise ?? Promise.resolve(null),
-        blobBaseFeePromise ?? Promise.resolve(0n),
-      ]);
-
-    // Extract results
-    const baseFee =
-      latestBlockResult.status === 'fulfilled' &&
-      typeof latestBlockResult.value === 'object' &&
-      latestBlockResult.value.baseFeePerGas
-        ? latestBlockResult.value.baseFeePerGas
-        : 0n;
-
-    // Get blob base fee if available
-    let blobBaseFee = 0n;
-    if (isBlobTx && blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
-      blobBaseFee = blobBaseFeeResult.value;
-    } else if (isBlobTx) {
+
+    const { latestBlock, blobBaseFee, priorityFee: strategyPriorityFee } = strategyResult;
+
+    // Extract base fee from latest block
+    const baseFee = latestBlock.baseFeePerGas ?? 0n;
+
+    // Handle blob base fee
+    if (isBlobTx && blobBaseFee === undefined) {
       this.logger?.warn('Failed to get L1 blob base fee', attempt);
     }
 
-    let priorityFee: bigint;
-    if (gasConfig.fixedPriorityFeePerGas) {
-      this.logger?.debug('Using fixed priority fee per L1 gas', {
-        fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas,
-      });
-      priorityFee = BigInt(Math.trunc(gasConfig.fixedPriorityFeePerGas * Number(WEI_CONST)));
-    } else {
-      // Get competitive priority fee (includes network estimate + analysis)
-      priorityFee = this.getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult);
+    let priorityFee = strategyPriorityFee;
+
+    // Apply minimum priority fee floor if configured
+    if (gasConfig.minimumPriorityFeePerGas) {
+      const minimumPriorityFee = BigInt(Math.trunc(gasConfig.minimumPriorityFeePerGas * Number(WEI_CONST)));
+      if (priorityFee < minimumPriorityFee) {
+        this.logger?.debug('Applying minimum priority fee floor', {
+          calculatedPriorityFee: formatGwei(priorityFee),
+          minimumPriorityFeePerGas: gasConfig.minimumPriorityFeePerGas,
+          appliedFee: formatGwei(minimumPriorityFee),
+        });
+        priorityFee = minimumPriorityFee;
+      }
     }
     let maxFeePerGas = baseFee;
 
-    let maxFeePerBlobGas = blobBaseFee;
+    let maxFeePerBlobGas = blobBaseFee ?? 0n;
 
     // 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;
+      // ceil, (a+b-1)/b, to avoid truncation at small values (e.g. 1 wei blob base fee)
+      maxFeePerGas = (maxFeePerGas * (1_000n + 125n) + 999n) / 1_000n;
       // same for blob gas fee
-      maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n)) / 1_000n;
+      maxFeePerBlobGas = (maxFeePerBlobGas * (1_000n + 125n) + 999n) / 1_000n;
     }
 
     if (attempt > 0) {
@@ -280,18 +150,15 @@ export class ReadOnlyL1TxUtils {
         (previousGasPrice!.maxPriorityFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00))) / 100_00n;
       const minMaxFee = (previousGasPrice!.maxFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00))) / 100_00n;
 
-      let competitivePriorityFee = priorityFee;
-      if (!gasConfig.fixedPriorityFeePerGas) {
-        // Apply bump percentage to competitive fee
-        competitivePriorityFee = (priorityFee * (100_00n + BigInt(configBump * 1_00))) / 100_00n;
+      // Apply bump percentage to competitive fee
+      const competitivePriorityFee = (priorityFee * (100_00n + BigInt(configBump * 1_00))) / 100_00n;
 
-        this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
-          networkEstimate: formatGwei(priorityFee),
-          competitiveFee: formatGwei(competitivePriorityFee),
-          minRequired: formatGwei(minPriorityFee),
-          bumpPercentage: configBump,
-        });
-      }
+      this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
+        networkEstimate: formatGwei(priorityFee),
+        competitiveFee: formatGwei(competitivePriorityFee),
+        minRequired: formatGwei(minPriorityFee),
+        bumpPercentage: configBump,
+      });
 
       // Use maximum between competitive fee and minimum required bump
       const finalPriorityFee = competitivePriorityFee > minPriorityFee ? competitivePriorityFee : minPriorityFee;
@@ -302,20 +169,16 @@ export class ReadOnlyL1TxUtils {
       maxFeePerGas += finalPriorityFee;
       maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
 
-      if (!gasConfig.fixedPriorityFeePerGas) {
-        this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
-          finalPriorityFee: formatGwei(finalPriorityFee),
-        });
-      }
+      this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
+        finalPriorityFee: formatGwei(finalPriorityFee),
+      });
     } else {
       // First attempt: apply configured bump percentage to competitive fee
       // 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;
-        this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
-          networkEstimate: formatGwei(priorityFee),
-        });
-      }
+      priorityFee = (priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00))) / 100_00n;
+      this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
+        networkEstimate: formatGwei(priorityFee),
+      });
       maxFeePerGas += priorityFee;
     }
 
@@ -356,7 +219,7 @@ export class ReadOnlyL1TxUtils {
         baseFee: formatGwei(baseFee),
         maxFeePerGas: formatGwei(maxFeePerGas),
         maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
-        blobBaseFee: formatGwei(blobBaseFee),
+        blobBaseFee: formatGwei(blobBaseFee ?? 0n),
         maxFeePerBlobGas: formatGwei(maxFeePerBlobGas),
       },
     );
@@ -380,19 +243,28 @@ export class ReadOnlyL1TxUtils {
     const gasConfig = { ...this.config, ..._gasConfig };
     let initialEstimate = 0n;
     if (_blobInputs) {
-      // @note requests with blobs also require maxFeePerBlobGas to be set
+      // @note requests with blobs also require maxFeePerBlobGas to be set.
+      // Use 2x buffer for maxFeePerBlobGas to avoid stale fees and to pass EIP-4844 validation (even if it is a gas estimation call).
+      // 1. maxFeePerBlobGas >= blobBaseFee
+      // 2. account balance >= gas * maxFeePerGas + maxFeePerBlobGas * blobCount + value
       const gasPrice = await this.getGasPrice(gasConfig, true, 0);
       initialEstimate = await this.client.estimateGas({
         account,
         ...request,
         ..._blobInputs,
-        maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
-        gas: LARGE_GAS_LIMIT,
+        maxFeePerBlobGas: gasPrice.maxFeePerBlobGas! * 2n,
+        gas: MAX_L1_TX_LIMIT,
+        blockTag: 'latest',
       });
 
       this.logger?.trace(`Estimated gas for blob tx: ${initialEstimate}`);
     } else {
-      initialEstimate = await this.client.estimateGas({ account, ...request, gas: LARGE_GAS_LIMIT });
+      initialEstimate = await this.client.estimateGas({
+        account,
+        ...request,
+        gas: MAX_L1_TX_LIMIT,
+        blockTag: 'latest',
+      });
       this.logger?.trace(`Estimated gas for non-blob tx: ${initialEstimate}`);
     }
 
@@ -548,11 +420,4 @@ export class ReadOnlyL1TxUtils {
     });
     return bumpedGasLimit;
   }
-
-  /**
-   * Helper function to retry RPC calls twice
-   */
-  private tryTwice<T>(fn: () => Promise<T>, description: string): Promise<T> {
-    return retry<T>(fn, description, makeBackoff(times(2, () => 0)), this.logger, true);
-  }
 }