Deterministic Fees: No Auction
Exfer's transaction fee is fixed by the protocol and computed from the transaction itself. Once a transaction is serialized — before it's broadcast — its exact fee is known.
How it differs from Ethereum gas
Ethereum turns fees into a real-time auction: every pending transaction sits in the mempool, miners pick the highest bids. The same operation can cost wildly different amounts moment to moment — you never know what the next one will cost. Humans tolerate that variance; an autonomous program working to a budget cannot. Budget $1.00, spend $1.20, and the program is broke.
Exfer inverts this: the protocol enforces a minimum fee rate and FIFO within a rate band. Miners have no selection authority and no priority auction. The fee for a transaction is computed directly from its serialized bytes — input count, output count, script length — independent of network state.
Why this matters for programs
| Scenario | Ethereum (auction) | Exfer (deterministic) |
|---|---|---|
| AI pays $0.01 for an API call | Could be $0.05, $5, or $50 in practice | Always exactly that |
| Same transaction broadcast twice | Second attempt may fail because gas estimate shifted | Same bytes → same fee, always |
| Budget "$100/day" for an agent | Must reserve a large cushion for fee spikes | Allocate down to the cent |
| Queue-jumping | Higher bidders cut in front of you | No mechanism for jumping — limits MEV |
Costs of this design
- You cannot bid your way to faster confirmation. Exfer does not let you pay to jump the queue. Every transaction in its fee band waits FIFO — fair for programs, but a human in a hurry willing to overpay has no escape hatch
- Protocol-level fee parameters are fixed. Adjusting them requires a hard fork. The upside is years of predictability; the downside is that responding to extreme network conditions requires a protocol upgrade
- MEV is reduced, not eliminated. Exfer removes protocol-level MEV vectors (miner-extractable value — profit from reordering or sandwiching transactions), but application-level MEV (off-chain arbitrage on correlated transactions) is still possible and must be addressed in application design
Further reading
- Protocol specification — exact fee formula
- The UTXO data model — why static fee computation works naturally under UTXO
- JSON-RPC / send_raw_transaction — submitting a transaction with pre-computed fee