EIP-1559 — Fee Market Reform

Back to Protocol-Level EIPs

EIP-1559: Base Fee + Tip Fee Market

EIP-1559 (London, 2021) replaced Ethereum's first-price gas auction with a base-fee + tip model. The base fee is algorithmically adjusted per block to target 50% block fullness, and is burned rather than paid to miners. Users add an optional priority fee (tip) to incentivise inclusion.

Goals

1. Eliminate the wild gas-price spikes of the first-price auction.
2. Make wallet UX better: users can specify a max fee they're willing to pay.
3. Burn fees as a deflationary force on ETH supply.

Tradeoffs

• Adds protocol complexity: every block has a base fee state.
• Burning fees introduces miner-extractable-value (MEV) game theory because tips go to miners but base fee doesn't.
• Wallet UX still requires users to estimate maxFeePerGas and maxPriorityFeePerGas.

Neo Equivalent

Neo has had a deterministic fee model since launch. Every transaction pays:

• System fee: pays for the VM operations the transaction performs (read from a static gas table per opcode).
• Network fee: pays for the size of the transaction (deterministic per byte).

There's no auction. No tip. No base-fee algorithm. The cost of a transaction is calculable before submission with full precision. Neo doesn't burn fees — they fund the protocol's economic model (governance via NEO holders + GAS distribution).

// EIP-1559 transaction (type 0x02) format:
//
//   txType                = 0x02
//   chainId               = uint256
//   nonce                 = uint64
//   maxPriorityFeePerGas  = uint256        // tip to miner
//   maxFeePerGas          = uint256        // ceiling
//   gasLimit              = uint64
//   to                    = address
//   value                 = uint256
//   data                  = bytes
//   accessList            = ...
//   v, r, s
//
// At inclusion time:
//   actualFee = min(maxFeePerGas, baseFee + maxPriorityFeePerGas)
//   miner gets: actualFee - baseFee
//   protocol burns: baseFee * gasUsed
//
// The base fee adjusts each block:
//   baseFee[n+1] = baseFee[n] * (1 + 1/8 * (gasUsed - target) / target)

// Solidity contracts can introspect via:
contract FeeAware {
    function showFees() external view returns (uint256 baseFee, uint256 priority) {
        baseFee  = block.basefee;          // EIP-3198
        priority = tx.gasprice - block.basefee;
    }
}

// Neo's fee model in C# terms:
//
//   System fee  = sum over all VM ops in the script of `gasTable[op]`
//   Network fee = txSize * networkFeePerByte + signatureVerificationCost
//
// There's no "base fee" because there's no algorithmic adjustment. The
// PolicyContract on Neo maintains:
//   - FeePerByte (storage cost component)
//   - ExecFeeFactor (multiplier for VM ops)
//
// These can be adjusted by a CN majority vote, but they're stable in practice.
//
// Transaction submission:
//   const tx = new TransactionBuilder()
//     .invoke(target, "method", args)
//     .signers([{ account, scopes: WitnessScope.CalledByEntry }])
//     .build();
//
//   const systemFee  = await rpc.invokeScript(tx.script).gasconsumed;   // exact
//   const networkFee = tx.size * feePerByte + verificationCost;          // exact
//   tx.systemFee  = systemFee;
//   tx.networkFee = networkFee;
//
// The user signs once with the exact fee. There's no ceiling/floor estimation.

using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;

namespace R3E.Examples;

[DisplayName("FeeIntrospection")]
public class FeeIntrospection : SmartContract
{
    public static long FeePerByte() => Policy.GetFeePerByte();
    public static uint ExecFeeFactor() => Policy.GetExecFeeFactor();
}

Why Neo Doesn't Need a "Fee Reform"

The Ethereum fee market is auction-based because block space is scarce and demand is volatile. Neo's TPS (~4000 ops/sec) and block time (~15 sec) leave the chain typically uncongested, so first-price auctions don't gridlock — and the deterministic fee model means users always know the cost up front.