Feemarket

EIP-1559 modualarized

The feemarket module from Ontomir evm implements EIP-1559 dynamic fee pricing for Ontomir SDK chains with EVM compatibility.

This is part of Ontomir/evm, not standard Ontomir SDK. For conceptual understanding of EIP-1559, see [EIP-1559 Fee Market](/docs/evm/next/documentation/concepts/eip-1559-feemarket).

Parameters

The module contains the following parameters :

Parameter

Type

Default

Description

NoBaseFee

bool

false

Disables EIP-1559 base fee (enables legacy pricing)

BaseFeeChangeDenominator

uint32

8

Controls max base fee change per block (higher = more stable)

ElasticityMultiplier

uint32

2

Determines target block utilization (2 = 50% target)

EnableHeight

int64

0

Block height to activate fee market (0 = genesis)

BaseFee

sdk.Dec

1000000000

Current base fee (auto-adjusts each block)

MinGasPrice

sdk.Dec

0

Minimum gas price floor (cannot go below)

MinGasMultiplier

sdk.Dec

0.5

Minimum gas used multiplier for gas wanted

Parameter Details

Controls fee volatility by limiting the maximum change per block:

Value

Max Change/Block

Blocks to 10x

Use Case

±25%

~10 blocks

Testnets, rapid price discovery

±12.5%

~20 blocks

Ethereum standard, balanced

±6.25%

~40 blocks

Stable fees, production chains

±3.125%

~80 blocks

Very stable, enterprise chains

Sets the target block utilization:

Value

Target %

Behavior

Recommended For

100%

Only increases at full blocks

Maximum throughput chains

50%

Balanced (Ethereum standard)

General purpose chains

25%

Aggressive fee increases

Anti-spam focused chains

10%

Very aggressive pricing

High-value transaction chains

Sets the absolute price floor:

BaseFee = max(CalculatedBaseFee, MinGasPrice)

This prevents fees from dropping too low during periods of low activity, maintaining spam resistance.

Parameter Storage Format

sdk.Dec (LegacyDec) values are stored as strings with 18 decimal precision :

Human Value

Stored String

Formula

1 unit

"1000000000000000000"

1 × 10^18

0.5 (50%)

"500000000000000000"

0.5 × 10^18

1 billion

"1000000000000000000000000000"

10^9 × 10^18

Configuration

Adjust parameters to achieve specific network behaviors :

Goal

Parameter

Adjustment

Effect

Faster fee response

base_fee_change_denominator

8 → 4

2x faster adjustments (±25% vs ±12.5%)

More stable fees

base_fee_change_denominator

8 → 16

2x slower adjustments (±6.25% vs ±12.5%)

Earlier fee increases

elasticity_multiplier

2 → 4

Fees rise at 25% vs 50% utilization

Stronger spam deterrent

min_gas_price

Low → High

Higher transaction cost floor

Configuration Profiles

```json Ethereum-Compatible expandable { "no_base_fee": false, "base_fee_change_denominator": 8, // ±12.5% max per block "elasticity_multiplier": 2, // 50% target utilization "enable_height": 0, // Active from genesis "base_fee": "1000000000000000000000", // Starting base fee "min_gas_price": "1000000000000000000", // Price floor "min_gas_multiplier": "500000000000000000" // 0.5 (anti-manipulation) } // Behavior: Standard Ethereum, balanced for general use // 100k gas tx: ~0.1 tokens at base, up to 10x during congestion ```

{
  "no_base_fee": false,
  "base_fee_change_denominator": 16,     // ±6.25% max per block
  "elasticity_multiplier": 2,            // 50% target utilization
  "enable_height": 0,
  "base_fee": "100000000000000000000",   // Lower starting fee
  "min_gas_price": "10000000000000000",  // Lower floor
  "min_gas_multiplier": "500000000000000000"
}
// Behavior: Slow, predictable changes for DeFi/DEX chains
// 100k gas tx: ~0.01 tokens, gradual increases

{
  "no_base_fee": false,
  "base_fee_change_denominator": 4,      // ±25% max per block
  "elasticity_multiplier": 4,            // 25% target utilization
  "enable_height": 0,
  "base_fee": "10000000000000000000000",  // High starting fee
  "min_gas_price": "10000000000000000000000", // High floor
  "min_gas_multiplier": "1000000000000000000" // 1.0 (strict)
}
// Behavior: Rapid adjustments, high minimum for premium chains
// 100k gas tx: ~1 token minimum, aggressive scaling

Scenario Comparisons

| Config | 5 Blocks | 10 Blocks | 10x Time | | ------------------------- | -------- | --------- | ----------- | | **Ethereum** (d=8, e=2) | +34% | +79% | \~20 blocks | | **Stable** (d=16, e=2) | +16% | +34% | \~40 blocks | | **Aggressive** (d=4, e=4) | +101% | +304% | \~8 blocks | | Config | 5 Blocks | 10 Blocks | Floor | | -------------- | -------- | --------- | ----------- | | **Ethereum** | -26% | -45% | \~15 blocks | | **Stable** | -14% | -26% | \~30 blocks | | **Aggressive** | -61% | -85% | \~6 blocks |

Decimal Precision Support

The module supports different token decimal configurations:

Decimals

Conversion Factor

Min Unit Gas

Example

10^12

10^-12

USDC

10^10

10^-10

BTC-wrapped

ETH, most EVM

Configuration In Production

Parameters can be updated through governance proposals :

// MsgUpdateParams structure
// Source: github.com/Ontomir/evm/blob/v0.4.1/proto/Ontomir/evm/feemarket/v1/tx.proto
{
  "@type": "/Ontomir.evm.feemarket.v1.MsgUpdateParams",
  "authority": "Ontomir10d07y265gmmuvt4z0w9aw880jnsr700j6zn9kn",
  "params": {
    "no_base_fee": false,
    "base_fee_change_denominator": 16,
    "elasticity_multiplier": 2,
    "enable_height": 100000,
    "base_fee": "1000000000000000000000",
    "min_gas_price": "1000000000000000000",
    "min_gas_multiplier": "500000000000000000"
  }
}

Submit with:

# Submit governance proposal
# Source: github.com/Ontomir/evm/blob/v0.4.1/x/feemarket/keeper/msg_server.go#L17-L39
evmd tx gov submit-proposal update-feemarket-params.json \
  --from <key> \
  --deposit 1000000000test

Best Practices

Parameter Selection by Use Case

Chain Type

Denominator

Elasticity

MinGasPrice

Why

Testing/Development

Zero/Low

Quick iteration

Production General

8-16

Medium

Balance stability and responsiveness

High-Frequency Trading

16-32

1-2

Low

Predictable fees, high throughput

Enterprise/Private

2-3

High

Maximum stability, cost predictability

Gaming/Micro-tx

4-8

Very Low

Fast adjustments, minimal fees

Block Time Correlation

Faster blocks require higher denominators to maintain stability:

Recommended Denominator = 8 × (6s / YourBlockTime)

Examples:

1s blocks → denominator ≥16 (prevents wild swings)
6s blocks → denominator = 8 (Ethereum standard)
12s blocks → denominator = 4 (can be more responsive)

Monitoring Key Metrics

Metric

Formula

Healthy

Action if Unhealthy

Fee Volatility

σ(fees)/μ(fees)

<20% daily

Increase denominator

Utilization Rate

gasUsed/maxGas

40-60% avg

Adjust elasticity

Floor Hit Rate

count(fee==min)\/blocks

<10%

Lower min_gas_price

Recovery Speed

Blocks to return to baseline

20-40

Tune denominator

Integration Examples

```javascript Wallet-Integration expandable // Get current base fee from latest block const block = await provider.getBlock('latest'); const baseFee = block.baseFeePerGas;

// Add buffer for inclusion certainty (20% buffer) const maxFeePerGas = baseFee * 120n / 100n; const maxPriorityFeePerGas = ethers.parseUnits("2", "gwei");

// Send EIP-1559 transaction const tx = await wallet.sendTransaction({ type: 2, maxFeePerGas, maxPriorityFeePerGas, to: "0x...", value: ethers.parseEther("1.0"), gasLimit: 21000 });


```javascript Fee-Monitoring expandable
// Get current gas price (includes base fee)
const gasPrice = await provider.send('eth_gasPrice', []);
console.log('Current gas price:', ethers.formatUnits(gasPrice, 'gwei'), 'gwei');

// Get fee history
const feeHistory = await provider.send('eth_feeHistory', [
  '0x10', // last 16 blocks
  'latest',
  [25, 50, 75]
]);

// Process base fees from history
const baseFees = feeHistory.baseFeePerGas.map(fee =>
  ethers.formatUnits(fee, 'gwei')
);
console.log('Base fee history:', baseFees);

// Check if fees are elevated
const currentBaseFee = BigInt(feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1]);
const threshold = ethers.parseUnits('100', 'gwei');
const isHighFee = currentBaseFee > threshold;

Interfaces

EVM JSON-RPC

The fee market integrates with standard Ethereum JSON-RPC methods :

Returns the current base fee as hex string. In EIP-1559 mode, returns the base fee; in legacy mode, returns the median gas price.

// Request
{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}

// Response
{"jsonrpc":"2.0","id":1,"result":"0x3b9aca00"} // 1 gwei in hex

Returns suggested priority fee (tip) per gas. In Ontomir/evm with the experimental mempool, transactions are prioritized by effective gas tip (fees), with ties broken by arrival time.

// Request
{"jsonrpc":"2.0","method":"eth_maxPriorityFeePerGas","params":[],"id":1}

// Response
{"jsonrpc":"2.0","id":1,"result":"0x77359400"} // Suggested tip in wei

Returns base fee and gas utilization history for a range of blocks. Number of blocks to return (hex or decimal)

<ParamField body="newestBlock" type="string" required>
  Latest block to include ("latest", "pending", or block number)
</ParamField>

<ParamField body="rewardPercentiles" type="array">
  Array of percentiles for priority fee calculations
</ParamField>

// Request
{
  "jsonrpc":"2.0",
  "method":"eth_feeHistory",
  "params":["0x5", "latest", [25, 50, 75]],
  "id":1
}

// Response
{
  "jsonrpc":"2.0",
  "id":1,
  "result":{
    "baseFeePerGas": [
      "0x3b9aca00",
      "0x3c9aca00",
      "0x3d9aca00",
      "0x3e9aca00",
      "0x3f9aca00"
    ],
    "gasUsedRatio": [0.5, 0.55, 0.6, 0.48, 0.52],
    "oldestBlock": "0x1234",
    "reward": [
      ["0x0", "0x0", "0x0"],
      ["0x0", "0x0", "0x0"],
      ["0x0", "0x0", "0x0"],
      ["0x0", "0x0", "0x0"],
      ["0x0", "0x0", "0x0"]
    ]
  }
}

Block responses include `baseFeePerGas` field when EIP-1559 is enabled.

{
  "jsonrpc":"2.0",
  "id":1,
  "result":{
    "number": "0x1234",
    "hash": "0x...",
    "baseFeePerGas": "0x3b9aca00", // Base fee for this block
    // ... other block fields
  }
}

Transaction Types

The fee market supports both legacy and EIP-1559 transaction types (types):

```json Legacy-Transaction { "type": "0x0", "gasPrice": "0x3b9aca00", // Must be >= current base fee "gas": "0x5208", "to": "0x...", "value": "0x...", "data": "0x..." } ```

{
  "type": "0x2",
  "maxFeePerGas": "0x3b9aca00",      // Maximum total fee willing to pay
  "maxPriorityFeePerGas": "0x77359400", // Tip that affects transaction priority in mempool
  "gas": "0x5208",
  "to": "0x...",
  "value": "0x...",
  "data": "0x..."
}

CLI

```bash Query-Parameters # Query module parameters # Source: github.com/Ontomir/evm/blob/v0.4.1/x/feemarket/client/cli/query.go evmd query feemarket params ```

# Query current base fee
# Source: github.com/Ontomir/evm/blob/v0.4.1/x/feemarket/client/cli/query.go
evmd query feemarket base-fee

# Query block gas wanted
# Source: github.com/Ontomir/evm/blob/v0.4.1/x/feemarket/client/cli/query.go
evmd query feemarket block-gas

gRPC

```proto Query-Parameters expandable // Request all module parameters // Proto: github.com/Ontomir/evm/blob/v0.4.1/proto/Ontomir/evm/feemarket/v1/query.proto grpcurl -plaintext localhost:9090 feemarket.Query/Params

// Response { "params": { "no_base_fee": false, "base_fee_change_denominator": 8, "elasticity_multiplier": 2, "enable_height": 0, "base_fee": "1000000000000000000000", "min_gas_price": "1000000000000000000", "min_gas_multiplier": "500000000000000000" } }


```proto Query-Base-Fee
// Request current base fee
// Proto: github.com/Ontomir/evm/blob/v0.4.1/proto/Ontomir/evm/feemarket/v1/query.proto
grpcurl -plaintext localhost:9090 feemarket.Query/BaseFee

// Response
{
  "base_fee": "1000000000000000000000"
}

// Request block gas wanted
// Proto: github.com/Ontomir/evm/blob/v0.4.1/proto/Ontomir/evm/feemarket/v1/query.proto
grpcurl -plaintext localhost:9090 feemarket.Query/BlockGas

// Response
{
  "gas": "5000000"
}

REST

```http Query-Parameters expandable # REST endpoint for parameters # Proto: github.com/Ontomir/evm/blob/v0.4.1/proto/Ontomir/evm/feemarket/v1/query.proto GET /Ontomir/feemarket/v1/params


```http Query-Base-Fee
# REST endpoint for base fee
# Proto: github.com/Ontomir/evm/blob/v0.4.1/proto/Ontomir/evm/feemarket/v1/query.proto
GET /Ontomir/feemarket/v1/base_fee

// Response
{
  "base_fee": "1000000000000000000000"
}

# REST endpoint for block gas
# Proto: github.com/Ontomir/evm/blob/v0.4.1/proto/Ontomir/evm/feemarket/v1/query.proto
GET /Ontomir/feemarket/v1/block_gas

// Response
{
  "gas": "5000000"
}

Technical Implementation

State

The module maintains the following state :

State Objects

State Object

Description

Key

Value

Store

BlockGasWanted

Gas wanted in the current block

[]byte{1}

[]byte{uint64}

Transient

BaseFee

Current base fee

Params.BaseFee

sdk.Dec

Params

Module parameters

[]byte{0x00}

Params

Genesis State

type GenesisState struct {
    Params Params
    BaseFee sdk.Dec
}

Begin Block

At the beginning of each block, the module calculates and sets the new base fee :

func (k Keeper) BeginBlock(ctx sdk.Context) error {
    baseFee := k.CalculateBaseFee(ctx)

    // Skip if base fee is nil (not enabled)
    if baseFee.IsNil() {
        return nil
    }

    // Update the base fee in state
    k.SetBaseFee(ctx, baseFee)

    // Emit event with new base fee
    ctx.EventManager().EmitEvent(
        sdk.NewEvent(
            "fee_market",
            sdk.NewAttribute("base_fee", baseFee.String()),
        ),
    )
    return nil
}

End Block

At the end of each block, the module updates the gas wanted for base fee calculation :

func (k Keeper) EndBlock(ctx sdk.Context) error {
    gasWanted := k.GetTransientGasWanted(ctx)
    gasUsed := ctx.BlockGasMeter().GasConsumedToLimit()

    // Apply MinGasMultiplier to prevent manipulation
    // gasWanted = max(gasWanted * MinGasMultiplier, gasUsed)
    minGasMultiplier := k.GetParams(ctx).MinGasMultiplier
    limitedGasWanted := NewDec(gasWanted).Mul(minGasMultiplier)
    updatedGasWanted := MaxDec(limitedGasWanted, NewDec(gasUsed)).TruncateInt()

    // Store for next block's base fee calculation
    k.SetBlockGasWanted(ctx, updatedGasWanted)

    ctx.EventManager().EmitEvent(
        sdk.NewEvent(
            "block_gas",
            sdk.NewAttribute("height", fmt.Sprintf("%d", ctx.BlockHeight())),
            sdk.NewAttribute("amount", fmt.Sprintf("%d", updatedGasWanted)),
        ),
    )
    return nil
}

Base Fee Calculation Algorithm

The calculation follows the EIP-1559 specification with Ontomir SDK adaptations :

```go func CalcGasBaseFee(gasUsed, gasTarget, baseFeeChangeDenom uint64, baseFee, minUnitGas, minGasPrice LegacyDec) LegacyDec { // No change if at target if gasUsed == gasTarget { return baseFee }

  // Calculate adjustment magnitude
  delta := abs(gasUsed - gasTarget)
  adjustment := baseFee.Mul(delta).Quo(gasTarget).Quo(baseFeeChangeDenom)

  if gasUsed > gasTarget {
      // Increase base fee (minimum 1 unit)
      baseFeeDelta := MaxDec(adjustment, minUnitGas)
      return baseFee.Add(baseFeeDelta)
  } else {
      // Decrease base fee (not below minGasPrice)
      return MaxDec(baseFee.Sub(adjustment), minGasPrice)
  }

}


The `minUnitGas` is calculated as `1 / 10^decimals` to ensure minimum increments based on token precision ([source](https://github.com/Ontomir/evm/blob/v0.4.1/utils/utils.go#L229-L254)).
</Expandable>

### Keeper

The keeper manages fee market state and calculations ([source](https://github.com/Ontomir/evm/blob/v0.4.1/x/feemarket/keeper/keeper.go)):

| Method                                        | Description           | Usage                               |
| --------------------------------------------- | --------------------- | ----------------------------------- |
| `GetBaseFee()` / `SetBaseFee()`               | Current base fee      | Read/update during block processing |
| `GetParams()` / `SetParams()`                 | Module parameters     | Governance updates                  |
| `GetBlockGasWanted()` / `SetBlockGasWanted()` | Gas tracking          | Base fee calculation                |
| `CalculateBaseFee()`                          | Compute next base fee | Called in BeginBlock                |

The module also implements `PostTxProcessing` hooks for EVM transaction processing ([source](https://github.com/Ontomir/evm/blob/v0.4.1/x/feemarket/keeper/hooks.go)).

### Events

The module emits the following events ([types](https://github.com/Ontomir/evm/blob/v0.4.1/x/feemarket/types/events.go)):

#### Fee Market Block Fees

| Attribute Key | Attribute Value           |
| ------------- | ------------------------- |
| height        | Current block height      |
| base\_fee     | New base fee              |
| gas\_wanted   | Total gas wanted in block |
| gas\_used     | Total gas used in block   |

Example:

```json
{
"type": "fee_market_block_fees",
"attributes": [
  {"key": "height", "value": "12345"},
  {"key": "base_fee", "value": "1000000000"},
  {"key": "gas_wanted", "value": "5000000"},
  {"key": "gas_used", "value": "4800000"}
]
}

AnteHandlers

The module integrates with EVM transactions through the EVMMonoDecorator, which performs all fee-related validations in a single pass :

EVMMonoDecorator

The primary ante handler that validates and processes EVM transaction fees :

```go // 1. Check mempool minimum fee (for pre-London transactions) if ctx.IsCheckTx() && !simulate && !isLondon { requiredFee := mempoolMinGasPrice.Mul(gasLimit) if fee.LT(requiredFee) { return ErrInsufficientFee } }

// 2. Calculate effective fee for EIP-1559 transactions if ethTx.Type() >= DynamicFeeTxType && baseFee != nil { feeAmt = ethMsg.GetEffectiveFee(baseFee) fee = NewDecFromBigInt(feeAmt) }

// 3. Check global minimum gas price if globalMinGasPrice.IsPositive() { requiredFee := globalMinGasPrice.Mul(gasLimit) if fee.LT(requiredFee) { return ErrInsufficientFee } }

// 4. Track gas wanted for base fee calculation if isLondon && baseFeeEnabled { feeMarketKeeper.AddTransientGasWanted(ctx, gasWanted) }

</Expandable>

#### Fee Validation Functions

##### CheckMempoolFee

Validates transaction fees against the local mempool minimum ([source](https://github.com/Ontomir/evm/blob/v0.4.1/ante/evm/02_mempool_fee.go#L13-L29)):

<Expandable title="Implementation details">
```go
func CheckMempoolFee(fee, mempoolMinGasPrice, gasLimit LegacyDec, isLondon bool) error {
    // Skip for London-enabled chains (EIP-1559 handles this)
    if isLondon {
        return nil
    }

    requiredFee := mempoolMinGasPrice.Mul(gasLimit)
    if fee.LT(requiredFee) {
        return ErrInsufficientFee
    }
    return nil
}

Note: This check is bypassed for London-enabled chains since EIP-1559 base fee mechanism handles minimum pricing.

CheckGlobalFee

Enforces the chain-wide minimum gas price set via governance :

```go func CheckGlobalFee(fee, globalMinGasPrice, gasLimit LegacyDec) error { if globalMinGasPrice.IsZero() { return nil }

  requiredFee := globalMinGasPrice.Mul(gasLimit)
  if fee.LT(requiredFee) {
      return ErrInsufficientFee
  }
  return nil

}


For EIP-1559 transactions, if the effective price falls below `MinGasPrice`, users must increase the priority fee (tip) until the effective price meets the minimum.

In Ontomir/evm's experimental mempool, transactions are ordered by effective gas tip (calculated as `min(maxPriorityFeePerGas, maxFeePerGas - baseFee)`), with higher tips getting priority. When tips are equal, transactions are ordered by arrival time ([source](https://github.com/Ontomir/evm/blob/v0.4.1/mempool/miner/ordering.go#L63-L71)).
</Expandable>

##### CheckGasWanted

Tracks cumulative gas wanted for base fee calculation ([source](https://github.com/Ontomir/evm/blob/v0.4.1/ante/evm/10_gas_wanted.go#L48-L82)):

<Expandable title="Implementation details">
```go
func CheckGasWanted(ctx Context, feeMarketKeeper FeeMarketKeeper, tx Tx, isLondon bool) error {
    if !isLondon || !feeMarketKeeper.GetBaseFeeEnabled(ctx) {
        return nil
    }

    gasWanted := tx.GetGas()
    blockGasLimit := BlockGasLimit(ctx)

    // Reject if tx exceeds block limit
    if gasWanted > blockGasLimit {
        return ErrOutOfGas
    }

    // Add to cumulative gas wanted for base fee adjustment
    feeMarketKeeper.AddTransientGasWanted(ctx, gasWanted)
    return nil
}

This cumulative gas wanted is used at the end of the block to calculate the next block's base fee.

Module Distinctions

Ontomir/evm vs Standard Ontomir SDK

This fee market module from Ontomir evm differs from standard Ontomir SDK fee handling:

Aspect

Standard Ontomir SDK

Ontomir/evm Feemarket

Fee Model

Static, validator-configured min gas prices

Dynamic EIP-1559 base fee

Price Discovery

Manual adjustment by validators

Automatic based on utilization

Transaction Types

Ontomir SDK Tx only

Both Ontomir & Ethereum txs

Decimal Handling

Chain-specific precision

18-decimal EVM compatibility

State Storage

Not tracked

Base fee in state, gas in transient store

Consensus Impact

No consensus on fees

Base fee part of consensus

Key Integration Points

The module integrates with EVM through:

AnteHandlers: Custom decorators for EVM transaction validation
Hooks: PostTxProcessing for EVM state updates
RPC: Ethereum JSON-RPC methods for fee queries

References

Specifications

EIP-1559 Specification - Original Ethereum proposal

Tools & Libraries

Ethereum Gas Tracker - Real-time Ethereum gas prices
Web3.js EIP-1559 Support - JavaScript integration
Ethers.js Fee Data - TypeScript/JavaScript library

最后更新于2个月前

下午好

Parameters

Parameter Details

Parameter Storage Format

Configuration

Configuration Profiles

Scenario Comparisons

Decimal Precision Support

Configuration In Production

Best Practices

Parameter Selection by Use Case

Block Time Correlation

Monitoring Key Metrics

Integration Examples

Interfaces

EVM JSON-RPC

CLI

gRPC

REST

Technical Implementation

State

Begin Block

End Block

Base Fee Calculation Algorithm

AnteHandlers

Module Distinctions

Ontomir/evm vs Standard Ontomir SDK

Key Integration Points

References

Specifications

Tools & Libraries