@aztec/ethereum 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/src/l1_tx_utils/config.ts

@@ -1,10 +1,11 @@
 import {
   type ConfigMappingsType,
-  bigintConfigHelper,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
 
 export interface L1TxUtilsConfig {
@@ -15,11 +16,11 @@ export interface L1TxUtilsConfig {
   /**
    * Maximum gas price in gwei
    */
-  maxGwei?: bigint;
+  maxGwei?: number;
   /**
    * Maximum blob fee per gas in gwei
    */
-  maxBlobGwei?: bigint;
+  maxBlobGwei?: number;
   /**
    * Priority fee bump percentage
    */
@@ -29,9 +30,9 @@ export interface L1TxUtilsConfig {
    */
   priorityFeeRetryBumpPercentage?: number;
   /**
-   * Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage config
+   * Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee.
    */
-  fixedPriorityFeePerGas?: number;
+  minimumPriorityFeePerGas?: number;
   /**
    * Maximum number of speed-up attempts
    */
@@ -60,6 +61,12 @@ export interface L1TxUtilsConfig {
    * How long a tx nonce can be unseen in the mempool before considering it dropped
    */
   txUnseenConsideredDroppedMs?: number;
+  /** Enable tx delayer. When true, wraps the viem client to intercept and delay txs. Test-only. */
+  enableDelayer?: boolean;
+  /** Max seconds into an L1 slot for tx inclusion. Txs sent later are deferred to next slot. Only used when enableDelayer is true. */
+  txDelayerMaxInclusionTimeIntoSlot?: number;
+  /** How many seconds an L1 slot lasts. */
+  ethereumSlotDuration?: number;
 }
 
 export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
@@ -71,12 +78,14 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   maxGwei: {
     description: 'Maximum gas price in gwei to be used for transactions.',
     env: 'L1_GAS_PRICE_MAX',
-    ...bigintConfigHelper(2000n),
+    fallback: ['L1_FEE_PER_GAS_GWEI_MAX'],
+    ...floatConfigHelper(2000),
   },
   maxBlobGwei: {
     description: 'Maximum blob fee per gas in gwei',
     env: 'L1_BLOB_FEE_PER_GAS_MAX',
-    ...bigintConfigHelper(3000n),
+    fallback: ['L1_BLOB_FEE_PER_GAS_GWEI_MAX'],
+    ...floatConfigHelper(3000),
   },
   priorityFeeBumpPercentage: {
     description: 'How much to increase priority fee by each attempt (percentage)',
@@ -88,10 +97,22 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     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),
+  minimumPriorityFeePerGas: {
+    description:
+      'Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee. If network conditions require a higher fee, the higher fee will be used.',
+    env: 'L1_MINIMUM_PRIORITY_FEE_PER_GAS_GWEI',
+    fallback: ['L1_FIXED_PRIORITY_FEE_PER_GAS', 'L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'],
+    deprecatedFallback: [
+      {
+        env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
+        message: deprecatedFixedFeeMessage('L1_FIXED_PRIORITY_FEE_PER_GAS'),
+      },
+      {
+        env: 'L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI',
+        message: deprecatedFixedFeeMessage('L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'),
+      },
+    ],
+    ...floatConfigHelper(0),
   },
   maxSpeedUpAttempts: {
     description: 'Maximum number of speed-up attempts',
@@ -128,6 +149,19 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     env: 'L1_TX_MONITOR_TX_UNSEEN_CONSIDERED_DROPPED_MS',
     ...numberConfigHelper(6 * 12 * 1000), // 6 L1 blocks
   },
+  enableDelayer: {
+    description: 'Enable tx delayer for testing.',
+    ...booleanConfigHelper(false),
+  },
+  txDelayerMaxInclusionTimeIntoSlot: {
+    description: 'Max seconds into L1 slot for tx inclusion when delayer is enabled.',
+    ...optionalNumberConfigHelper(),
+  },
+  ethereumSlotDuration: {
+    env: 'ETHEREUM_SLOT_DURATION',
+    description: 'How many seconds an L1 slot lasts.',
+    ...numberConfigHelper(12),
+  },
 };
 
 // We abuse the fact that all mappings above have a non null default value and force-type this to Required
@@ -138,3 +172,10 @@ export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(
 export function getL1TxUtilsConfigEnvVars(): L1TxUtilsConfig {
   return getConfigFromMappings(l1TxUtilsConfigMappings);
 }
+
+function deprecatedFixedFeeMessage(envVar: string): string {
+  return (
+    `Environment variable ${envVar} is deprecated. It is now used as a MINIMUM priority fee rather than a fixed value. ` +
+    'Please use L1_MINIMUM_PRIORITY_FEE_PER_GAS_GWEI instead. If network conditions require a higher fee, the higher fee will be used.'
+  );
+}

package/src/l1_tx_utils/constants.ts

@@ -3,8 +3,8 @@
 // 1_000_000_000_000_000_000 Wei = 1 ETH
 export 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
-export const LARGE_GAS_LIMIT = 12_000_000n;
+// EIP-7825: protocol-level cap on tx gas limit (2^24). Clients reject above this.
+export const MAX_L1_TX_LIMIT = 16_777_216n;
 
 // 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
@@ -16,3 +16,14 @@ export const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
 
 // Avg ethereum block time is ~12s
 export const BLOCK_TIME_MS = 12_000;
+
+// Gas per blob (EIP-4844)
+export const GAS_PER_BLOB = 131072n;
+
+// Blob capacity schedule based on Ethereum upgrades
+export const BLOB_CAPACITY_SCHEDULE = [
+  { timestamp: 1734357600, target: 14, max: 21 }, // BPO2: Dec 17, 2025
+  { timestamp: 1733752800, target: 10, max: 15 }, // BPO1: Dec 9, 2025
+  { timestamp: 1733234400, target: 6, max: 9 }, // Fusaka: Dec 3, 2025
+  { timestamp: 0, target: 6, max: 9 }, // Pectra/earlier
+];

package/src/l1_tx_utils/factory.ts

@@ -1,64 +1,64 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 
-import type { TransactionSerializable } from 'viem';
-
 import type { EthSigner } from '../eth-signer/eth-signer.js';
 import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
 import type { L1TxUtilsConfig } from './config.js';
 import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
 import { L1TxUtils } from './l1_tx_utils.js';
 import { createViemSigner } from './signer.js';
+import { Delayer } from './tx_delayer.js';
 import type { SigningCallback } from './types.js';
 
-export function createL1TxUtilsFromViemWallet(
-  client: ExtendedViemWalletClient,
-  deps?: {
-    logger?: Logger;
-    dateProvider?: DateProvider;
-    store?: IL1TxStore;
-    metrics?: IL1TxMetrics;
-  },
-  config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
-): L1TxUtils {
-  return new L1TxUtils(
+/** Source of signing capability: either a wallet client or a separate client + signer. */
+export type L1SignerSource = ExtendedViemWalletClient | { client: ViemClient; signer: EthSigner };
+
+export function resolveSignerSource(source: L1SignerSource): {
+  client: ViemClient;
+  address: EthAddress;
+  signingCallback: SigningCallback;
+} {
+  if ('account' in source && source.account) {
+    return {
+      client: source as ExtendedViemWalletClient,
+      address: EthAddress.fromString((source as ExtendedViemWalletClient).account.address),
+      signingCallback: createViemSigner(source as ExtendedViemWalletClient),
+    };
+  }
+  const { client, signer } = source as { client: ViemClient; signer: EthSigner };
+  return {
     client,
-    EthAddress.fromString(client.account.address),
-    createViemSigner(client),
-    deps?.logger,
-    deps?.dateProvider,
-    config,
-    config?.debugMaxGasLimit ?? false,
-    deps?.store,
-    deps?.metrics,
-  );
+    address: signer.address,
+    signingCallback: async (tx, _addr) => (await signer.signTransaction(tx)).toViemTransactionSignature(),
+  };
 }
 
-export function createL1TxUtilsFromEthSigner(
-  client: ViemClient,
-  signer: EthSigner,
+export function createL1TxUtils(
+  source: L1SignerSource,
   deps?: {
     logger?: Logger;
     dateProvider?: DateProvider;
     store?: IL1TxStore;
     metrics?: IL1TxMetrics;
+    kzg?: BlobKzgInstance;
+    delayer?: Delayer;
   },
   config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
 ): L1TxUtils {
-  const callback: SigningCallback = async (transaction: TransactionSerializable, _signingAddress) => {
-    return (await signer.signTransaction(transaction)).toViemTransactionSignature();
-  };
-
+  const { client, address, signingCallback } = resolveSignerSource(source);
   return new L1TxUtils(
     client,
-    signer.address,
-    callback,
+    address,
+    signingCallback,
     deps?.logger,
     deps?.dateProvider,
     config,
     config?.debugMaxGasLimit ?? false,
     deps?.store,
     deps?.metrics,
+    deps?.kzg,
+    deps?.delayer,
   );
 }

package/src/l1_tx_utils/fee-strategies/index.ts

@@ -0,0 +1,22 @@
+import { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+import { P75BlobTxsOnlyPriorityFeeStrategy } from './p75_competitive_blob_txs_only.js';
+import type { PriorityFeeStrategy } from './types.js';
+
+export {
+  HISTORICAL_BLOCK_COUNT,
+  type PriorityFeeStrategy,
+  type PriorityFeeStrategyContext,
+  type PriorityFeeStrategyResult,
+} from './types.js';
+
+export { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+export { P75BlobTxsOnlyPriorityFeeStrategy } from './p75_competitive_blob_txs_only.js';
+
+/**
+ * Default list of priority fee strategies to analyze.
+ * Add more strategies here for comparison.
+ */
+export const DEFAULT_PRIORITY_FEE_STRATEGIES: PriorityFeeStrategy[] = [
+  P75AllTxsPriorityFeeStrategy,
+  P75BlobTxsOnlyPriorityFeeStrategy,
+];

package/src/l1_tx_utils/fee-strategies/p75_competitive.ts

@@ -0,0 +1,163 @@
+import { median } from '@aztec/foundation/collection';
+
+import { formatGwei } from 'viem';
+
+import type { ViemClient } from '../../types.js';
+import { calculatePercentile } from '../../utils.js';
+import { WEI_CONST } from '../constants.js';
+import {
+  HISTORICAL_BLOCK_COUNT,
+  type PriorityFeeStrategy,
+  type PriorityFeeStrategyContext,
+  type PriorityFeeStrategyResult,
+} from './types.js';
+
+/**
+ * Our current competitive priority fee strategy.
+ * Analyzes p75 of pending transactions and 5-block fee history to determine a competitive priority fee.
+ * Falls back to network estimate if data is unavailable.
+ */
+export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy = {
+  name: 'Competitive (P75 + History) - CURRENT',
+  id: 'p75_pending_txs_and_history_all_txs',
+
+  async execute(client: ViemClient, context: PriorityFeeStrategyContext): Promise<PriorityFeeStrategyResult> {
+    const { isBlobTx, logger } = context;
+
+    // Fire all RPC calls in parallel
+    const [latestBlockResult, blobBaseFeeResult, networkEstimateResult, pendingBlockResult, feeHistoryResult] =
+      await Promise.allSettled([
+        client.getBlock({ blockTag: 'latest' }),
+        isBlobTx ? client.getBlobBaseFee() : Promise.resolve(undefined),
+        client.estimateMaxPriorityFeePerGas().catch(() => 0n),
+        client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
+        client
+          .getFeeHistory({
+            blockCount: HISTORICAL_BLOCK_COUNT,
+            rewardPercentiles: [75],
+            blockTag: 'latest',
+          })
+          .catch(() => null),
+      ]);
+
+    // Extract latest block
+    if (latestBlockResult.status === 'rejected') {
+      throw new Error(`Failed to get latest block: ${latestBlockResult.reason}`);
+    }
+    const latestBlock = latestBlockResult.value;
+
+    // Extract blob base fee (only for blob txs)
+    let blobBaseFee: bigint | undefined;
+    if (isBlobTx) {
+      if (blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+        blobBaseFee = blobBaseFeeResult.value;
+      } else {
+        logger?.warn('Failed to get L1 blob base fee');
+      }
+    }
+
+    // Extract network estimate
+    const networkEstimate =
+      networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint'
+        ? networkEstimateResult.value
+        : 0n;
+
+    let competitiveFee = networkEstimate;
+    const debugInfo: Record<string, string | number> = {
+      networkEstimateGwei: formatGwei(networkEstimate),
+    };
+
+    // Extract pending block
+    const pendingBlock = pendingBlockResult.status === 'fulfilled' ? pendingBlockResult.value : null;
+
+    // Analyze pending block transactions
+    if (pendingBlock?.transactions && pendingBlock.transactions.length > 0) {
+      const pendingFees = pendingBlock.transactions
+        .map(tx => {
+          if (typeof tx === 'string') {
+            return 0n;
+          }
+          return tx.maxPriorityFeePerGas || 0n;
+        })
+        .filter((fee: bigint) => fee > 0n);
+
+      if (pendingFees.length > 0) {
+        // Use 75th percentile of pending fees to be competitive
+        const pendingCompetitiveFee = calculatePercentile(pendingFees, 75);
+
+        if (pendingCompetitiveFee > competitiveFee) {
+          competitiveFee = pendingCompetitiveFee;
+        }
+
+        debugInfo.pendingTxCount = pendingFees.length;
+        debugInfo.pendingP75Gwei = formatGwei(pendingCompetitiveFee);
+
+        logger?.debug('Analyzed pending transactions for competitive pricing', {
+          pendingTxCount: pendingFees.length,
+          pendingP75: formatGwei(pendingCompetitiveFee),
+        });
+      }
+    }
+
+    // Extract fee history
+    const feeHistory = feeHistoryResult.status === 'fulfilled' ? feeHistoryResult.value : null;
+
+    // Analyze fee history
+    if (feeHistory?.reward && feeHistory.reward.length > 0) {
+      // 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) {
+          logger?.warn('Suspicious high fee in history', {
+            historicalMedian: formatGwei(medianHistoricalFee),
+            allP75Fees: percentile75Fees.map(f => formatGwei(f)),
+          });
+        }
+
+        if (medianHistoricalFee > competitiveFee) {
+          competitiveFee = medianHistoricalFee;
+        }
+
+        debugInfo.historicalMedianGwei = formatGwei(medianHistoricalFee);
+
+        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
+    const maxReasonableFee = networkEstimate * 100n;
+    if (competitiveFee > maxReasonableFee && networkEstimate > 0n) {
+      logger?.debug('Competitive fee exceeds sanity cap, using capped value', {
+        competitiveFee: formatGwei(competitiveFee),
+        networkEstimate: formatGwei(networkEstimate),
+        cappedTo: formatGwei(maxReasonableFee),
+      });
+      competitiveFee = maxReasonableFee;
+      debugInfo.cappedToGwei = formatGwei(maxReasonableFee);
+    }
+
+    // Log final decision
+    if (competitiveFee > networkEstimate) {
+      logger?.debug('Using competitive fee from market analysis', {
+        networkEstimate: formatGwei(networkEstimate),
+        competitive: formatGwei(competitiveFee),
+      });
+    }
+
+    debugInfo.finalFeeGwei = formatGwei(competitiveFee);
+
+    return {
+      priorityFee: competitiveFee,
+      latestBlock,
+      blobBaseFee,
+      debugInfo,
+    };
+  },
+};

package/src/l1_tx_utils/fee-strategies/p75_competitive_blob_txs_only.ts

@@ -0,0 +1,245 @@
+import { median } from '@aztec/foundation/collection';
+
+import { type GetFeeHistoryReturnType, formatGwei } from 'viem';
+
+import type { ViemClient } from '../../types.js';
+import { calculatePercentile, isBlobTransaction } from '../../utils.js';
+import { WEI_CONST } from '../constants.js';
+import {
+  HISTORICAL_BLOCK_COUNT,
+  type PriorityFeeStrategy,
+  type PriorityFeeStrategyContext,
+  type PriorityFeeStrategyResult,
+} from './types.js';
+
+/**
+ * Fetches historical blocks and calculates reward percentiles for blob transactions only.
+ * Returns data in the same format as getFeeHistory for easy drop-in replacement.
+ *
+ * @param client - Viem client to use for RPC calls
+ * @param blockCount - Number of historical blocks to fetch
+ * @param rewardPercentiles - Array of percentiles to calculate (e.g., [75] for 75th percentile)
+ * @returns Object with reward field containing percentile fees for each block, similar to getFeeHistory
+ * @throws Error if fetching blocks fails
+ */
+export async function getBlobPriorityFeeHistory(
+  client: ViemClient,
+  blockCount: number,
+  rewardPercentiles: number[],
+): Promise<GetFeeHistoryReturnType> {
+  const latestBlockNumber = await client.getBlockNumber();
+
+  // Fetch multiple blocks in parallel
+  const blockPromises = Array.from({ length: blockCount }, (_, i) =>
+    client.getBlock({
+      blockNumber: latestBlockNumber - BigInt(i),
+      includeTransactions: true,
+    }),
+  );
+
+  const blocks = await Promise.all(blockPromises);
+
+  // Process each block to extract blob transaction fees and other data
+  const baseFeePerGas: bigint[] = [];
+  const gasUsedRatio: number[] = [];
+  const reward: bigint[][] = [];
+
+  for (const block of blocks) {
+    // Collect base fee per gas
+    baseFeePerGas.push(block.baseFeePerGas || 0n);
+
+    // Calculate gas used ratio
+    const gasUsed = block.gasUsed || 0n;
+    const gasLimit = block.gasLimit || 1n; // Avoid division by zero
+    gasUsedRatio.push(Number(gasUsed) / Number(gasLimit));
+
+    if (!block.transactions || block.transactions.length === 0) {
+      // No transactions in this block - return zeros for each percentile
+      reward.push(rewardPercentiles.map(() => 0n));
+      continue;
+    }
+
+    // Extract priority fees from blob transactions only
+    const blobFees = block.transactions
+      .map(tx => {
+        // Transaction can be just a hash string
+        if (typeof tx === 'string') {
+          return 0n;
+        }
+
+        if (!isBlobTransaction(tx)) {
+          return 0n;
+        }
+        return tx.maxPriorityFeePerGas || 0n;
+      })
+      .filter((fee: bigint) => fee > 0n);
+
+    if (blobFees.length === 0) {
+      // No blob transactions in this block - return zeros for each percentile
+      reward.push(rewardPercentiles.map(() => 0n));
+      continue;
+    }
+
+    // Calculate requested percentiles
+    const percentiles = rewardPercentiles.map(percentile => calculatePercentile(blobFees, percentile));
+
+    reward.push(percentiles);
+  }
+
+  // Calculate oldest block number (the last block in our array)
+  const oldestBlock = latestBlockNumber - BigInt(blockCount - 1);
+
+  // Reverse arrays to match getFeeHistory behavior (oldest first)
+  return {
+    baseFeePerGas: baseFeePerGas.reverse(),
+    gasUsedRatio: gasUsedRatio.reverse(),
+    oldestBlock,
+    reward: reward.reverse(),
+  };
+}
+
+/**
+ * Similar to our current competitive priority fee strategy, but only considers blob transactions
+ * when calculating competitive priority fee for blob transactions.
+ * This strategy also has NO cap on the competitive fee if it's much higher than the network estimate.
+ * Analyzes p75 of pending transactions and 5-block fee history to determine a competitive priority fee.
+ * Falls back to network estimate if data is unavailable.
+ */
+export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy = {
+  name: 'Competitive (P75 + History) - Blob Txs Only',
+  id: 'p75_pending_txs_and_history_blob_txs_only',
+
+  async execute(client: ViemClient, context: PriorityFeeStrategyContext): Promise<PriorityFeeStrategyResult> {
+    const { isBlobTx, logger } = context;
+
+    // Fire all RPC calls in parallel
+    const [latestBlockResult, blobBaseFeeResult, networkEstimateResult, pendingBlockResult, feeHistoryResult] =
+      await Promise.allSettled([
+        client.getBlock({ blockTag: 'latest' }),
+        isBlobTx ? client.getBlobBaseFee() : Promise.resolve(undefined),
+        client.estimateMaxPriorityFeePerGas().catch(() => 0n),
+        client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
+        isBlobTx
+          ? getBlobPriorityFeeHistory(client, HISTORICAL_BLOCK_COUNT, [75])
+          : client
+              .getFeeHistory({
+                blockCount: HISTORICAL_BLOCK_COUNT,
+                rewardPercentiles: [75],
+                blockTag: 'latest',
+              })
+              .catch(() => null),
+      ]);
+
+    // Extract latest block (required)
+    if (latestBlockResult.status === 'rejected') {
+      throw new Error(`Failed to get latest block: ${latestBlockResult.reason}`);
+    }
+    const latestBlock = latestBlockResult.value;
+
+    // Extract blob base fee (only for blob txs)
+    let blobBaseFee: bigint | undefined;
+    if (isBlobTx) {
+      if (blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+        blobBaseFee = blobBaseFeeResult.value;
+      } else {
+        logger?.warn('Failed to get L1 blob base fee');
+      }
+    }
+
+    // Extract network estimate
+    const networkEstimate =
+      networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint'
+        ? networkEstimateResult.value
+        : 0n;
+
+    let competitiveFee = networkEstimate;
+    const debugInfo: Record<string, string | number> = {
+      networkEstimateGwei: formatGwei(networkEstimate),
+    };
+
+    // Extract pending block
+    const pendingBlock = pendingBlockResult.status === 'fulfilled' ? pendingBlockResult.value : null;
+
+    // Analyze pending block transactions
+    if (pendingBlock?.transactions && pendingBlock.transactions.length > 0) {
+      const pendingFees = pendingBlock.transactions
+        .map(tx => {
+          if (typeof tx === 'string') {
+            return 0n;
+          }
+          if (isBlobTx) {
+            if (!isBlobTransaction(tx)) {
+              return 0n;
+            }
+          }
+          return tx.maxPriorityFeePerGas || 0n;
+        })
+        .filter((fee: bigint) => fee > 0n);
+
+      if (pendingFees.length > 0) {
+        const pendingCompetitiveFee = calculatePercentile(pendingFees, 75);
+
+        if (pendingCompetitiveFee > competitiveFee) {
+          competitiveFee = pendingCompetitiveFee;
+        }
+
+        debugInfo.pendingTxCount = pendingFees.length;
+        debugInfo.pendingP75Gwei = formatGwei(pendingCompetitiveFee);
+
+        logger?.debug('Analyzed pending transactions for competitive pricing', {
+          pendingTxCount: pendingFees.length,
+          pendingP75: formatGwei(pendingCompetitiveFee),
+        });
+      }
+    }
+
+    // Extract fee history
+    const feeHistory = feeHistoryResult.status === 'fulfilled' ? feeHistoryResult.value : null;
+
+    // Analyze fee history
+    if (feeHistory?.reward && feeHistory.reward.length > 0) {
+      // 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) {
+          logger?.debug('Suspicious high fee in history', {
+            historicalMedian: formatGwei(medianHistoricalFee),
+            allP75Fees: percentile75Fees.map(f => formatGwei(f)),
+          });
+        }
+
+        if (medianHistoricalFee > competitiveFee) {
+          competitiveFee = medianHistoricalFee;
+        }
+
+        debugInfo.historicalMedianGwei = formatGwei(medianHistoricalFee);
+
+        logger?.debug('Analyzed fee history for competitive pricing', {
+          historicalMedian: formatGwei(medianHistoricalFee),
+        });
+      }
+    }
+
+    // Log final decision
+    if (competitiveFee > networkEstimate) {
+      logger?.debug('Using competitive fee from market analysis', {
+        networkEstimate: formatGwei(networkEstimate),
+        competitive: formatGwei(competitiveFee),
+      });
+    }
+
+    debugInfo.finalFeeGwei = formatGwei(competitiveFee);
+
+    return {
+      priorityFee: competitiveFee,
+      latestBlock,
+      blobBaseFee,
+      debugInfo,
+    };
+  },
+};