@aztec/ethereum 3.0.0-nightly.20251216 → 3.0.0-nightly.20251218

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,
+    };
+  },
+};

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

@@ -0,0 +1,88 @@
+import type { Logger } from '@aztec/foundation/log';
+
+import type { ViemClient } from '../../types.js';
+import type { L1TxUtilsConfig } from '../config.js';
+
+/**
+ * Historical block count for fee history queries
+ */
+export const HISTORICAL_BLOCK_COUNT = 5;
+
+/**
+ * Result from a priority fee strategy calculation
+ */
+export interface PriorityFeeStrategyResult {
+  /** The calculated priority fee in wei */
+  priorityFee: bigint;
+  /** Optional debug info about how the fee was calculated */
+  debugInfo?: Record<string, string | number>;
+}
+
+/**
+ * Context passed to the strategy calculation function (excluding promise results)
+ */
+export interface PriorityFeeStrategyContext {
+  /** Gas configuration */
+  gasConfig: L1TxUtilsConfig;
+  /** Whether this is for a blob transaction */
+  isBlobTx: boolean;
+  /** Logger for debugging */
+  logger?: Logger;
+}
+
+/**
+ * A strategy for calculating the priority fee for L1 transactions.
+ * Each strategy defines what promises it needs and how to calculate the fee from their results.
+ * This design allows strategies to be plugged into both L1FeeAnalyzer and ReadOnlyL1TxUtils.
+ */
+export interface PriorityFeeStrategy<TPromises extends Record<string, Promise<any>> = Record<string, Promise<any>>> {
+  /** Human-readable name for logging */
+  name: string;
+  /** Unique identifier for metrics */
+  id: string;
+  /**
+   * Returns the promises that need to be executed for this strategy.
+   * These will be run in parallel with Promise.allSettled.
+   * @param client - The viem client to use for RPC calls
+   * @returns An object of promises keyed by name
+   */
+  getRequiredPromises(client: ViemClient, opts: Partial<PriorityFeeStrategyContext>): TPromises;
+  /**
+   * Calculate the priority fee based on the settled promise results.
+   * @param results - The settled results of the promises from getRequiredPromises
+   * @param context - Contains gas config, whether it's a blob tx, and logger
+   * @returns The calculated priority fee result
+   */
+  calculate(
+    results: { [K in keyof TPromises]: PromiseSettledResult<Awaited<TPromises[K]>> },
+    context: PriorityFeeStrategyContext,
+  ): PriorityFeeStrategyResult;
+}
+
+/**
+ * Helper function to execute a strategy's promises and calculate the result.
+ * This can be used by both L1FeeAnalyzer and ReadOnlyL1TxUtils.
+ * @param strategy - The strategy to execute
+ * @param client - The viem client to use for RPC calls
+ * @param context - The context for calculation
+ * @returns The strategy result
+ */
+export async function executeStrategy<TPromises extends Record<string, Promise<any>>>(
+  strategy: PriorityFeeStrategy<TPromises>,
+  client: ViemClient,
+  context: PriorityFeeStrategyContext,
+): Promise<PriorityFeeStrategyResult> {
+  const promises = strategy.getRequiredPromises(client, { isBlobTx: context.isBlobTx });
+  const keys = Object.keys(promises) as Array<keyof TPromises>;
+  const promiseArray = keys.map(k => promises[k]);
+
+  const settledResults = await Promise.allSettled(promiseArray);
+
+  // Reconstruct the results object with the same keys, preserving the type mapping
+  const results = {} as { [K in keyof TPromises]: PromiseSettledResult<Awaited<TPromises[K]>> };
+  keys.forEach((key, index) => {
+    results[key] = settledResults[index] as PromiseSettledResult<Awaited<TPromises[typeof key]>>;
+  });
+
+  return strategy.calculate(results, context);
+}

package/src/l1_tx_utils/index.ts

@@ -1,7 +1,9 @@
 export * from './config.js';
 export * from './constants.js';
 export * from './factory.js';
+export * from './fee-strategies/index.js';
 export * from './interfaces.js';
+export * from './l1_fee_analyzer.js';
 export * from './l1_tx_utils.js';
 export * from './readonly_l1_tx_utils.js';
 export * from './signer.js';