BASEFEE (0x48)

(none)

base_fee_per_gas (wei as u256)

stack.push(block.basefee)

Base Fee:   20 gwei
In wei:     20,000,000,000
As u256:    0x4a817c800

import { basefee } from '@tevm/voltaire/evm/block';
import { createFrame } from '@tevm/voltaire/evm/Frame';

const frame = createFrame({
  stack: [],
  hardfork: 'LONDON',
  blockContext: {
    block_base_fee: 20_000_000_000n // 20 gwei
  }
});

const err = basefee(frame);
console.log(frame.stack); // [20000000000n]
console.log(frame.gasRemaining); // Original - 2

// Before London hardfork
const preLondonFrame = createFrame({
  hardfork: 'BERLIN',
  blockContext: { block_base_fee: 20_000_000_000n }
});

const err = basefee(preLondonFrame);
console.log(err); // { type: "InvalidOpcode" }

// Calculate minimum transaction cost
basefee(frame);
const baseFee = frame.stack[0];
const gasUsed = 21_000n; // Simple transfer

const minimumCost = baseFee * gasUsed;
console.log(`Minimum cost: ${minimumCost} wei`);
// 20 gwei * 21,000 = 0.00042 ETH

// Total fee = base fee + priority fee
const maxFeePerGas = 30_000_000_000n; // 30 gwei

basefee(frame);
const baseFee = frame.stack[0]; // 20 gwei

const maxPriorityFee = maxFeePerGas - baseFee;
console.log(`Max priority fee: ${maxPriorityFee} wei`);
// 10 gwei available for priority

contract DynamicPricer {
    function getRecommendedPriorityFee() external view returns (uint256) {
        uint256 baseFee = block.basefee;

        // Recommend priority fee based on base fee
        if (baseFee < 20 gwei) {
            return 1 gwei; // Low congestion
        } else if (baseFee < 50 gwei) {
            return 2 gwei; // Medium congestion
        } else {
            return 5 gwei; // High congestion
        }
    }
}

contract FeeGuard {
    uint256 public constant MAX_BASE_FEE = 100 gwei;

    modifier maxBaseFee() {
        require(block.basefee <= MAX_BASE_FEE, "Base fee too high");
        _;
    }

    function expensiveOperation() external maxBaseFee {
        // Only execute if base fee is reasonable
    }
}

contract CongestionMonitor {
    enum Congestion { Low, Medium, High, Extreme }

    function currentCongestion() public view returns (Congestion) {
        uint256 baseFee = block.basefee;

        if (baseFee < 20 gwei) return Congestion.Low;
        if (baseFee < 50 gwei) return Congestion.Medium;
        if (baseFee < 100 gwei) return Congestion.High;
        return Congestion.Extreme;
    }

    function shouldDefer() public view returns (bool) {
        // Defer non-urgent operations during high congestion
        return block.basefee > 100 gwei;
    }
}

contract GasRefunder {
    function refundExcess() external payable {
        uint256 baseFee = block.basefee;
        uint256 gasUsed = 21000; // Estimate

        uint256 cost = baseFee * gasUsed;

        if (msg.value > cost) {
            uint256 refund = msg.value - cost;
            payable(msg.sender).transfer(refund);
        }
    }
}

contract FeeAnalytics {
    struct FeeSnapshot {
        uint256 blockNumber;
        uint256 baseFee;
        uint256 timestamp;
    }

    FeeSnapshot[] public history;

    function recordBaseFee() external {
        history.push(FeeSnapshot({
            blockNumber: block.number,
            baseFee: block.basefee,
            timestamp: block.timestamp
        }));
    }

    function averageBaseFee(uint256 blocks) external view returns (uint256) {
        require(history.length >= blocks, "Insufficient data");

        uint256 sum = 0;
        uint256 start = history.length - blocks;

        for (uint i = start; i < history.length; i++) {
            sum += history[i].baseFee;
        }

        return sum / blocks;
    }
}

contract BaseFeeReliant {
    // SAFE: Base fee follows EIP-1559 algorithm
    function checkFee() external view returns (bool) {
        // Base fee adjusted by protocol, not validator discretion
        return block.basefee <= 100 gwei;
    }
}

contract VolatilityAware {
    uint256 public recordedBaseFee;

    function recordFee() external {
        recordedBaseFee = block.basefee;
    }

    // PROBLEMATIC: Assumes stable fees
    function executeLater() external {
        // Base fee could be very different now!
        require(block.basefee <= recordedBaseFee * 2, "Fees increased too much");
    }
}

contract PriorityAware {
    // Base fee: Minimum to be included
    // Priority fee: Determines ordering within block

    function estimateTotalFee() external view returns (uint256) {
        uint256 baseFee = block.basefee;
        uint256 priorityFee = 2 gwei; // User's choice

        return baseFee + priorityFee;
    }
}

contract BackwardCompatible {
    function getBaseFee() public view returns (uint256) {
        // BASEFEE opcode (0x48) only exists post-London
        uint256 baseFee;
        assembly {
            baseFee := basefee()
        }

        // Pre-London returns 0 or reverts
        // Post-London returns actual base fee
        return baseFee;
    }
}

contract FeeComponents {
    // Total fee per gas = base fee + priority fee
    // maxFeePerGas: Maximum user willing to pay
    // maxPriorityFeePerGas: Maximum tip to validator

    function effectivePriorityFee(
        uint256 maxFeePerGas,
        uint256 maxPriorityFeePerGas
    ) public view returns (uint256) {
        uint256 baseFee = block.basefee;

        // Priority fee is capped by: min(maxPriorityFee, maxFee - baseFee)
        uint256 maxAllowedPriority = maxFeePerGas - baseFee;
        return min(maxPriorityFeePerGas, maxAllowedPriority);
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

Target gas = 15M (50% of 30M limit)
Actual gas used = X

If X > 15M:  baseFee increases by (X - 15M) / 15M * baseFee / 8
If X < 15M:  baseFee decreases by (15M - X) / 15M * baseFee / 8
If X = 15M:  baseFee stays same

Maximum change per block: ±12.5%

// Before London: InvalidOpcode
const frame = createFrame({
  hardfork: 'BERLIN',
  blockContext: { block_base_fee: 20_000_000_000n }
});

const err = basefee(frame);
console.log(err); // { type: "InvalidOpcode" }

// Theoretical minimum (genesis or test networks)
const frame = createFrame({
  hardfork: 'LONDON',
  blockContext: { block_base_fee: 0n }
});

basefee(frame);
console.log(frame.stack); // [0n]

// Very high base fee during congestion
const frame = createFrame({
  hardfork: 'LONDON',
  blockContext: { block_base_fee: 500_000_000_000n } // 500 gwei
});

basefee(frame);
console.log(frame.stack); // [500000000000n]

// First block with EIP-1559 (initial base fee = 1 gwei)
const frame = createFrame({
  hardfork: 'LONDON',
  blockContext: { block_base_fee: 1_000_000_000n } // 1 gwei
});

basefee(frame);
console.log(frame.stack); // [1000000000n]

// Pre-London: Only gas price (auction mechanism)
// Miners choose transactions by gas price alone
// First-price auction: Pay your bid

// Post-London: Base fee + priority fee
// Base fee: Burned (removed from circulation)
// Priority fee: To validator (incentive for inclusion)
// Improved UX: Predictable fees, automatic adjustment