---
title: "EIP-1559 — Fee Market Reform"
description: "EIP-1559 — Fee Market Reform mapped to Neo N3."
---
# EIP-1559 — Fee Market Reform
[Back to Protocol-Level EIPs](/standards-mirror/protocol-eips)
<StandardsMirror>
<StandardEntry
id="eip-1559"
title="EIP-1559 — Fee Market Reform"
eip="1559"
status="Final"
neoMapping="Native polynomial GAS pricing"
category="Fees"
parityLabel="Native"
parityClass="sm-pill-native"
>
<template #spec>
## 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).
</template>
<template #solidity>
```solidity
// 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;
}
}
```
</template>
<template #csharp>
```csharp
// 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.
</template>
</StandardEntry>
</StandardsMirror>