@aztec/ethereum 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/l1_tx_utils/config.ts

@@ -0,0 +1,161 @@
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  floatConfigHelper,
+  getConfigFromMappings,
+  getDefaultConfig,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+
+export interface L1TxUtilsConfig {
+  /**
+   * How much to increase calculated gas limit.
+   */
+  gasLimitBufferPercentage?: number;
+  /**
+   * Maximum gas price in gwei
+   */
+  maxGwei?: number;
+  /**
+   * Maximum blob fee per gas in gwei
+   */
+  maxBlobGwei?: number;
+  /**
+   * Priority fee bump percentage
+   */
+  priorityFeeBumpPercentage?: number;
+  /**
+   * How much to increase priority fee by each attempt (percentage)
+   */
+  priorityFeeRetryBumpPercentage?: number;
+  /**
+   * Minimum priority fee per gas in Gwei. Acts as a floor for the computed priority fee.
+   */
+  minimumPriorityFeePerGas?: number;
+  /**
+   * Maximum number of speed-up attempts
+   */
+  maxSpeedUpAttempts?: number;
+  /**
+   * How often to check tx status
+   */
+  checkIntervalMs?: number;
+  /**
+   * How long before considering tx stalled
+   */
+  stallTimeMs?: number;
+  /**
+   * How long to wait for a tx to be mined before giving up
+   */
+  txTimeoutMs?: number;
+  /**
+   * Whether to attempt to cancel a tx if it's not mined after txTimeoutMs
+   */
+  cancelTxOnTimeout?: boolean;
+  /**
+   * How long to wait for a cancellation tx to be mined after its last attempt before giving up
+   */
+  txCancellationFinalTimeoutMs?: number;
+  /**
+   * How long a tx nonce can be unseen in the mempool before considering it dropped
+   */
+  txUnseenConsideredDroppedMs?: number;
+}
+
+export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
+  gasLimitBufferPercentage: {
+    description: 'How much to increase calculated gas limit by (percentage)',
+    env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
+    ...numberConfigHelper(20),
+  },
+  maxGwei: {
+    description: 'Maximum gas price in gwei to be used for transactions.',
+    env: 'L1_GAS_PRICE_MAX',
+    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',
+    fallback: ['L1_BLOB_FEE_PER_GAS_GWEI_MAX'],
+    ...floatConfigHelper(3000),
+  },
+  priorityFeeBumpPercentage: {
+    description: 'How much to increase priority fee by each attempt (percentage)',
+    env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
+    ...numberConfigHelper(20),
+  },
+  priorityFeeRetryBumpPercentage: {
+    description: 'How much to increase priority fee by each retry attempt (percentage)',
+    env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
+    ...numberConfigHelper(50),
+  },
+  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',
+    env: 'L1_TX_MONITOR_MAX_ATTEMPTS',
+    ...numberConfigHelper(3),
+  },
+  checkIntervalMs: {
+    description: 'How often to check tx status',
+    env: 'L1_TX_MONITOR_CHECK_INTERVAL_MS',
+    ...numberConfigHelper(1_000),
+  },
+  stallTimeMs: {
+    description: 'How long before considering tx stalled',
+    env: 'L1_TX_MONITOR_STALL_TIME_MS',
+    ...numberConfigHelper(12_000), // 12s, 1 ethereum slot
+  },
+  txTimeoutMs: {
+    description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
+    env: 'L1_TX_MONITOR_TX_TIMEOUT_MS',
+    ...numberConfigHelper(120_000), // 2 mins
+  },
+  cancelTxOnTimeout: {
+    description: "Whether to attempt to cancel a tx if it's not mined after txTimeoutMs",
+    env: 'L1_TX_MONITOR_CANCEL_TX_ON_TIMEOUT',
+    ...booleanConfigHelper(true),
+  },
+  txCancellationFinalTimeoutMs: {
+    description: 'How long to wait for a cancellation tx after its last attempt before giving up',
+    env: 'L1_TX_MONITOR_TX_CANCELLATION_TIMEOUT_MS',
+    ...numberConfigHelper(24 * 12 * 1000), // 24 L1 blocks
+  },
+  txUnseenConsideredDroppedMs: {
+    description: 'How long a tx nonce can be unseen in the mempool before considering it dropped',
+    env: 'L1_TX_MONITOR_TX_UNSEEN_CONSIDERED_DROPPED_MS',
+    ...numberConfigHelper(6 * 12 * 1000), // 6 L1 blocks
+  },
+};
+
+// We abuse the fact that all mappings above have a non null default value and force-type this to Required
+export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(
+  l1TxUtilsConfigMappings,
+) as Required<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

@@ -0,0 +1,29 @@
+// 1_000_000_000 Gwei = 1 ETH
+// 1_000_000_000 Wei = 1 Gwei
+// 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;
+
+// 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
+export const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10;
+
+// setting a minimum bump percentage to 100% due to geth's implementation
+// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/blobpool/config.go#L34
+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

@@ -0,0 +1,64 @@
+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 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(
+    client,
+    EthAddress.fromString(client.account.address),
+    createViemSigner(client),
+    deps?.logger,
+    deps?.dateProvider,
+    config,
+    config?.debugMaxGasLimit ?? false,
+    deps?.store,
+    deps?.metrics,
+  );
+}
+
+export function createL1TxUtilsFromEthSigner(
+  client: ViemClient,
+  signer: EthSigner,
+  deps?: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+  },
+  config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
+): L1TxUtils {
+  const callback: SigningCallback = async (transaction: TransactionSerializable, _signingAddress) => {
+    return (await signer.signTransaction(transaction)).toViemTransactionSignature();
+  };
+
+  return new L1TxUtils(
+    client,
+    signer.address,
+    callback,
+    deps?.logger,
+    deps?.dateProvider,
+    config,
+    config?.debugMaxGasLimit ?? false,
+    deps?.store,
+    deps?.metrics,
+  );
+}

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,
+  executeStrategy,
+  type PriorityFeeStrategy,
+  type PriorityFeeStrategyContext,
+  type PriorityFeeStrategyResult,
+} from './types.js';
+
+export { P75AllTxsPriorityFeeStrategy } from './p75_competitive.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,159 @@
+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';
+
+/**
+ * Type for the promises required by the competitive strategy
+ */
+type P75AllTxsStrategyPromises = {
+  networkEstimate: Promise<bigint>;
+  pendingBlock: Promise<Awaited<ReturnType<ViemClient['getBlock']>> | null>;
+  feeHistory: Promise<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>;
+};
+
+/**
+ * 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<P75AllTxsStrategyPromises> = {
+  name: 'Competitive (P75 + History) - CURRENT',
+  id: 'p75_pending_txs_and_history_all_txs',
+
+  getRequiredPromises(client: ViemClient): P75AllTxsStrategyPromises {
+    return {
+      networkEstimate: client.estimateMaxPriorityFeePerGas().catch(() => 0n),
+      pendingBlock: client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
+      feeHistory: client
+        .getFeeHistory({
+          blockCount: HISTORICAL_BLOCK_COUNT,
+          rewardPercentiles: [75],
+          blockTag: 'latest',
+        })
+        .catch(() => null),
+    };
+  },
+
+  calculate(
+    results: {
+      [K in keyof P75AllTxsStrategyPromises]: PromiseSettledResult<Awaited<P75AllTxsStrategyPromises[K]>>;
+    },
+    context: PriorityFeeStrategyContext,
+  ): PriorityFeeStrategyResult {
+    const { logger } = context;
+
+    // Extract network estimate from settled result
+    const networkEstimate =
+      results.networkEstimate.status === 'fulfilled' && typeof results.networkEstimate.value === 'bigint'
+        ? results.networkEstimate.value
+        : 0n;
+
+    let competitiveFee = networkEstimate;
+    const debugInfo: Record<string, string | number> = {
+      networkEstimateGwei: formatGwei(networkEstimate),
+    };
+
+    // Extract pending block from settled result
+    const pendingBlock = results.pendingBlock.status === 'fulfilled' ? results.pendingBlock.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;
+          }
+          const fee = tx.maxPriorityFeePerGas || 0n;
+
+          return fee;
+        })
+        .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 from settled result
+    const feeHistory = results.feeHistory.status === 'fulfilled' ? results.feeHistory.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?.warn('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,
+      debugInfo,
+    };
+  },
+};

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

@@ -0,0 +1,241 @@
+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';
+
+/**
+ * Type for the promises required by the competitive strategy
+ */
+type P75AllTxsStrategyPromises = {
+  networkEstimate: Promise<bigint>;
+  pendingBlock: Promise<Awaited<ReturnType<ViemClient['getBlock']>> | null>;
+  feeHistory: Promise<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>;
+};
+
+/**
+ * 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<P75AllTxsStrategyPromises> = {
+  name: 'Competitive (P75 + History) - Blob Txs Only',
+  id: 'p75_pending_txs_and_history_blob_txs_only',
+
+  getRequiredPromises(client: ViemClient, opts: PriorityFeeStrategyContext): P75AllTxsStrategyPromises {
+    return {
+      networkEstimate: client.estimateMaxPriorityFeePerGas().catch(() => 0n),
+      pendingBlock: client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
+      feeHistory: opts.isBlobTx
+        ? getBlobPriorityFeeHistory(client, HISTORICAL_BLOCK_COUNT, [75])
+        : client
+            .getFeeHistory({
+              blockCount: HISTORICAL_BLOCK_COUNT,
+              rewardPercentiles: [75],
+              blockTag: 'latest',
+            })
+            .catch(() => null),
+    };
+  },
+
+  calculate(
+    results: {
+      [K in keyof P75AllTxsStrategyPromises]: PromiseSettledResult<Awaited<P75AllTxsStrategyPromises[K]>>;
+    },
+    context: PriorityFeeStrategyContext,
+  ): PriorityFeeStrategyResult {
+    const { logger } = context;
+
+    // Extract network estimate from settled result
+    const networkEstimate =
+      results.networkEstimate.status === 'fulfilled' && typeof results.networkEstimate.value === 'bigint'
+        ? results.networkEstimate.value
+        : 0n;
+
+    let competitiveFee = networkEstimate;
+    const debugInfo: Record<string, string | number> = {
+      networkEstimateGwei: formatGwei(networkEstimate),
+    };
+
+    // Extract pending block from settled result
+    const pendingBlock = results.pendingBlock.status === 'fulfilled' ? results.pendingBlock.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 (context.isBlobTx) {
+            if (!isBlobTransaction(tx)) {
+              return 0n;
+            }
+          }
+          const fee = tx.maxPriorityFeePerGas || 0n;
+
+          return fee;
+        })
+        .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 from settled result
+    const feeHistory = results.feeHistory.status === 'fulfilled' ? results.feeHistory.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),
+        });
+      }
+    }
+
+    // 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,
+      debugInfo,
+    };
+  },
+};