Feemarket

BaseFee = max(CalculatedBaseFee, MinGasPrice)

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)
    }
}

// 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)
}

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
}

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

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

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
}