OpenParable
Skip to content
← Back to skills

Fee Estimation

Development
fee-estimation

Fee Estimation is an Agent Skill for development published in the Nethereum/Nethereum repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Estimate EIP-1559 gas fees with Nethereum. Use when the user asks about gas fees, fee estimation, maxFeePerGas, maxPriorityFeePerGas, base fee, or choosing a fee strategy for transactions.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/Nethereum/Nethereum/blob/HEAD/plugins/nethereum-skills/skills/fee-estimation/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/fee-estimation, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

EIP-1559 Fee Estimation with Nethereum

NuGet: Nethereum.RPC

Source: Fee1559SuggestionDocExampleTests

Required Usings

using System.Numerics;
using Nethereum.Hex.HexTypes;
using Nethereum.RPC.Eth.DTOs;
using Nethereum.RPC.Fee1559Suggestions;

Fee Components

EIP-1559 splits gas fees into baseFee (protocol-set, burned) and priorityFee (tip to validator). Users set maxPriorityFeePerGas (tip ceiling) and maxFeePerGas (total ceiling). Actual cost = min(baseFee + priorityFee, maxFeePerGas).

Fee1559 Model

Holds all fee components in a single object.

var fee = new Fee1559
{
    BaseFee = 20_000_000_000,
    MaxPriorityFeePerGas = 2_000_000_000,
    MaxFeePerGas = 42_000_000_000
};

Strategy 1: Simple (Default)

Fixed priority fee of 2 Gwei. MaxFee = 2 * baseFee + priorityFee. Fast, no RPC calls beyond latest block.

var defaultPriority = SimpleFeeSuggestionStrategy.DEFAULT_MAX_PRIORITY_FEE_PER_GAS;
// 2,000,000,000 (2 Gwei)

// Usage with Web3:
// var strategy = new SimpleFeeSuggestionStrategy(web3.Client);
// Fee1559 fee = await strategy.SuggestFeeAsync();

Strategy 2: Median Priority Fee History

Uses eth_feeHistory to compute median priority fee from recent blocks. Applies a baseFee multiplier that decreases as baseFee rises.

Base Fee Multiplier Tiers

var strategy = new MedianPriorityFeeHistorySuggestionStrategy();

strategy.GetBaseFeeMultiplier(30_000_000_000);   // 2.0x  (< 40 Gwei)
strategy.GetBaseFeeMultiplier(50_000_000_000);   // 1.6x  (40-100 Gwei)
strategy.GetBaseFeeMultiplier(150_000_000_000);  // 1.4x  (100-200 Gwei)
strategy.GetBaseFeeMultiplier(300_000_000_000);  // 1.2x  (>= 200 Gwei)

Estimate Priority Fee from Fee History

var feeHistory = new FeeHistoryResult
{
    OldestBlock = new HexBigInteger(100),
    BaseFeePerGas = new[]
    {
        new HexBigInteger(20_000_000_000),
        new HexBigInteger(21_000_000_000)
    },
    GasUsedRatio = new decimal[] { 0.5m },
    Reward = new[]
    {
        new[] { new HexBigInteger(1_000_000_000) },
        new[] { new HexBigInteger(1_500_000_000) },
        new[] { new HexBigInteger(2_000_000_000) },
        new[] { new HexBigInteger(2_500_000_000) },
        new[] { new HexBigInteger(3_000_000_000) }
    }
};

var estimate = strategy.EstimatePriorityFee(feeHistory);

Suggest Max Fee Using Multiplier

var maxPriorityFee = new BigInteger(2_000_000_000);
var baseFee = new HexBigInteger(30_000_000_000);

Fee1559 result = strategy.SuggestMaxFeeUsingMultiplier(maxPriorityFee, baseFee);
// result.MaxFeePerGas > baseFee (includes multiplier headroom)
// result.MaxPriorityFeePerGas == maxPriorityFee

Strategy 3: Time Preference

Returns an array of Fee1559 suggestions factoring in urgency. Uses 100 blocks of fee history. Best for UIs offering slow/medium/fast options.

var strategy = new TimePreferenceFeeSuggestionStrategy();

// Build fee history (normally from eth_feeHistory RPC)
var feeHistory = new FeeHistoryResult
{
    OldestBlock = new HexBigInteger(1000),
    BaseFeePerGas = baseFees,   // HexBigInteger[101]
    GasUsedRatio = gasUsedRatio // decimal[100]
};

var tip = new BigInteger(2_000_000_000);
Fee1559[] fees = strategy.SuggestFees(feeHistory, tip);

foreach (var fee in fees)
{
    // fee.MaxFeePerGas >= fee.MaxPriorityFeePerGas
}

Default Behavior in Web3

Web3's TransactionManagerBase defaults:

  • Strategy: TimePreferenceFeeSuggestionStrategy (NOT Simple)
  • Transaction type: EIP-1559 (UseLegacyAsDefault = false)
  • Auto-calculate: CalculateOrSetDefaultGasPriceFeesIfNotSet = true

Override the strategy:

web3.TransactionManager.Fee1559SuggestionStrategy =
    new SimpleFeeSuggestionStrategy(web3.Client);

Force legacy transactions:

web3.TransactionManager.UseLegacyAsDefault = true;
// Or provide GasPrice in TransactionInput — legacy is used automatically

Strategy Comparison

StrategyRPC CallsBest ForAccuracy
Simple1 (latest block)Quick transactions, stable networksLow
Median1 (eth_feeHistory)General-purpose, backend servicesMedium
TimePreference1 (eth_feeHistory, 100 blocks)UI with slow/medium/fast optionsHigh

Using with Web3 (Live)

// Simple
var simple = new SimpleFeeSuggestionStrategy(web3.Client);
Fee1559 fee = await simple.SuggestFeeAsync();

// Median
var median = new MedianPriorityFeeHistorySuggestionStrategy(web3.Client);
Fee1559 fee = await median.SuggestFeeAsync();

// TimePreference
var timePref = new TimePreferenceFeeSuggestionStrategy(web3.Client);
Fee1559[] fees = await timePref.SuggestFeesAsync();