eth_feeHistory - Polygon RPC Method

import { JsonRpcProvider, formatUnits } from 'ethers';

const provider = new JsonRpcProvider('https://api-polygon-mainnet-full.n.dwellir.com/YOUR_API_KEY');

async function estimateGasFees(blockRange = 20) {
  const feeHistory = await provider.send('eth_feeHistory', [
    '0x' + blockRange.toString(16),
    'latest',
    [10, 50, 90]
  ]);

  // Get the predicted next base fee (last element in baseFeePerGas)
  const nextBaseFee = BigInt(feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1]);

  // Calculate average priority fees at each percentile
  const avgRewards = [0, 1, 2].map(idx => {
    const fees = feeHistory.reward.map(r => BigInt(r[idx]));
    return fees.reduce((sum, f) => sum + f, 0n) / BigInt(fees.length);
  });

  return {
    low: {
      maxPriorityFeePerGas: avgRewards[0],
      maxFeePerGas: nextBaseFee + avgRewards[0],
      label: 'Low — may take several blocks'
    },
    medium: {
      maxPriorityFeePerGas: avgRewards[1],
      maxFeePerGas: nextBaseFee * 2n + avgRewards[1],
      label: 'Medium — next few blocks'
    },
    high: {
      maxPriorityFeePerGas: avgRewards[2],
      maxFeePerGas: nextBaseFee * 3n + avgRewards[2],
      label: 'High — next block target'
    }
  };
}

const fees = await estimateGasFees();
for (const [tier, data] of Object.entries(fees)) {
  console.log(`${data.label}`);
  console.log(`  Priority: ${formatUnits(data.maxPriorityFeePerGas, 'gwei')} Gwei`);
  console.log(`  Max Fee:  ${formatUnits(data.maxFeePerGas, 'gwei')} Gwei`);
}

async function getCongestionLevel(provider, blockRange = 50) {
  const feeHistory = await provider.send('eth_feeHistory', [
    '0x' + blockRange.toString(16),
    'latest',
    []
  ]);

  const ratios = feeHistory.gasUsedRatio;
  const avgRatio = ratios.reduce((sum, r) => sum + r, 0) / ratios.length;
  const recentRatio = ratios.slice(-5).reduce((sum, r) => sum + r, 0) / 5;

  // Detect base fee trend
  const baseFees = feeHistory.baseFeePerGas.map(f => Number(BigInt(f)));
  const firstHalf = baseFees.slice(0, Math.floor(baseFees.length / 2));
  const secondHalf = baseFees.slice(Math.floor(baseFees.length / 2));
  const avgFirst = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
  const avgSecond = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
  const trend = avgSecond > avgFirst * 1.1 ? 'rising' : avgSecond < avgFirst * 0.9 ? 'falling' : 'stable';

  let level;
  if (recentRatio > 0.8) level = 'high';
  else if (recentRatio > 0.5) level = 'moderate';
  else level = 'low';

  return {
    congestion: level,
    averageUtilization: (avgRatio * 100).toFixed(1) + '%',
    recentUtilization: (recentRatio * 100).toFixed(1) + '%',
    baseFeeTrend: trend
  };
}

const congestion = await getCongestionLevel(provider);
console.log('Network congestion:', congestion);

async function predictBaseFee(provider) {
  const feeHistory = await provider.send('eth_feeHistory', ['0x1', 'latest', []]);

  const currentBaseFee = BigInt(feeHistory.baseFeePerGas[0]);
  const gasUsedRatio = feeHistory.gasUsedRatio[0];

  // EIP-1559 base fee adjustment formula
  // If gas used > 50% target, base fee increases (up to 12.5%)
  // If gas used < 50% target, base fee decreases (up to 12.5%)
  const targetRatio = 0.5;
  const maxChange = 0.125; // 12.5%

  let changeRatio;
  if (gasUsedRatio > targetRatio) {
    changeRatio = Math.min((gasUsedRatio - targetRatio) / targetRatio, 1) * maxChange;
  } else {
    changeRatio = -Math.min((targetRatio - gasUsedRatio) / targetRatio, 1) * maxChange;
  }

  const predictedBaseFee = currentBaseFee + BigInt(Math.floor(Number(currentBaseFee) * changeRatio));

  console.log(`Current base fee: ${Number(currentBaseFee) / 1e9} Gwei`);
  console.log(`Gas used ratio: ${(gasUsedRatio * 100).toFixed(1)}%`);
  console.log(`Predicted next base fee: ${Number(predictedBaseFee) / 1e9} Gwei`);

  return predictedBaseFee;
}

async function safeFeeHistory(provider, blockCount = 10, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await provider.send('eth_feeHistory', [
        '0x' + blockCount.toString(16),
        'latest',
        [25, 50, 75]
      ]);
    } catch (error) {
      if (error.code === -32602 && blockCount > 1) {
        // Reduce block count and retry
        blockCount = Math.max(1, Math.floor(blockCount / 2));
        continue;
      }
      if (error.code === -32005) {
        await new Promise(r => setTimeout(r, Math.pow(2, i) * 1000));
        continue;
      }
      if (i === maxRetries - 1) throw error;
      await new Promise(r => setTimeout(r, Math.pow(2, i) * 1000));
    }
  }
}