Blockchain Economics And Mev Theory

Blockchain Economics & MEV Theory

Expert Reference for On-Chain Economic Analysis

1. Block Space as a Market

Supply and Demand Fundamentals

Block space is a non-storable, periodically produced resource. Supply is fixed per slot (Ethereum: 30M gas target, 60M gas ceiling post-EIP-4844 soft limits). Demand is variable and driven by user activity, bot competition, and protocol interactions.

Supply constraints:

• Block gas limit: hard ceiling set by validators via governance signaling
• Target gas: half the ceiling; EIP-1559 equilibrium point
• Block time: 12s on Ethereum mainnet post-Merge; deterministic slot cadence

Demand drivers:

• DeFi activity (swaps, liquidations, yield harvesting)
• NFT mints and secondary sales
• Arbitrage and MEV bot competition
• Bridge operations and cross-chain messaging
• Token launches and airdrop claims

EIP-1559 Mechanism

Introduced in London hard fork (August 2021). Replaced first-price auction with a protocol-managed base fee plus voluntary priority fee (tip).

Base fee adjustment rule:

base_fee[n+1] = base_fee[n] * (1 + (gas_used[n] - gas_target) / (gas_target * 8))

Where:

• gas_target = block_gas_limit / 2 = 15,000,000
• gas_target * 8 = 120,000,000 (the denominator that bounds adjustment speed)
• Maximum base fee increase per block: 12.5%
• Maximum base fee decrease per block: 12.5%

Key properties:

• Base fee is burned, not paid to validators — separates congestion pricing from validator revenue
• Priority fee (tip) goes to the block proposer
• MAXFEE = base_fee + priority_fee; user sets max willingness to pay
• Transactions included only if maxFeePerGas >= base_fee

Base fee as price discovery: The base fee functions as a stochastic control system. Under persistent full blocks, the base fee doubles every 55 blocks (11 minutes). This creates predictable price signals but slow response to demand spikes. Users smooth this via max fee slippage tolerance.

EIP-1559 welfare analysis:

• Reduces variance in transaction inclusion times vs. first-price auction
• Does NOT eliminate priority-fee MEV races; tip auctions still occur on top
• Burns ETH proportional to economic activity: ETH becomes a deflationary asset during high demand
• Empirical: ~1.5M-4M ETH burned annually depending on network activity

Base fee elasticity:

E = (delta_quantity / quantity) / (delta_price / price)

Empirically, block space demand is inelastic at low base fees (bots and protocols pay regardless) and more elastic for casual users. This bimodal demand structure means EIP-1559 primarily price-discriminates between time-sensitive and time-insensitive users.

Mempool Economics

The public mempool is a pending transaction pool where participants can observe and react to unconfirmed transactions. This creates the primary vector for frontrunning and sandwich attacks.

Mempool as information market:

• Transactions broadcast P2P; propagation delay ~200-500ms globally
• MEV searchers run full nodes co-located with major relayers and validators
• Private mempools (Flashbots, MEV Blocker) allow users to bypass public mempool

2. MEV Supply Chain

Value Flow Architecture

MEV (Maximal Extractable Value, formerly Miner Extractable Value) is the total profit extractable by reordering, inserting, or censoring transactions within a block.

Supply chain participants:

User Transactions
      |
      v
  Searchers          <- identify MEV opportunities, construct bundles
      |
      v
  Builders           <- assemble full blocks from bundles + txs, bid to proposers
      |
      v
   Relays             <- trust intermediary, validates blocks, passes to proposers
      |
      v
  Proposers           <- Ethereum validators who select winning block

Value flow:

1. Searcher identifies opportunity with expected profit P
2. Searcher bids gas priority fee or direct payment to builder capturing fraction (1-s) of P
3. Builder receives multiple searcher bundles, constructs maximally profitable block
4. Builder bids to relay: builder_bid = sum(all_bundle_profits) - builder_margin
5. Proposer receives highest relay bid; the builder_bid goes to proposer as ETH payment
6. Proposer's total revenue: block_reward + builder_bid

Competitive dynamics:

• Searcher competition drives bids toward opportunity value (P approaches captured fraction)
• Builder competition drives block bids toward full MEV extraction
• At equilibrium: searchers keep ~1-10% of opportunity value; rest flows to proposers via builders

Quantitative MEV Data

Historical MEV extraction on Ethereum:

• 2021 peak: ~$700M annual MEV extraction (flashbots dashboard)
• 2022: reduced DeFi activity, but sandwich attacks sustained ~$300M
• Post-Merge: MEV income to validators: ~0.3-1.5 ETH per MEV-Boost block (median ~0.05 ETH)
• Builder market concentration: top 3 builders (beaverbuild, rsync, titan) regularly capture >70% of blocks

Searcher profitability model:

Expected_profit = P(opportunity) * opportunity_value - gas_cost - bundle_payment
gas_cost = gas_used * gas_price
bundle_payment = bid_fraction * opportunity_value

Searcher equilibrium bid: searchers bid up to opportunity_value - gas_cost - minimum_margin.

3. MEV Taxonomy

3.1 Arbitrage

DEX-DEX Arbitrage: Exploits price discrepancy between two AMMs for the same asset pair.

profit = (price_A - price_B) * trade_size - fees_A - fees_B - gas

For Uniswap V2 constant product AMM x * y = k:

price_impact = (x + delta_x) * (y - delta_y) = k
delta_y = y * delta_x / (x + delta_x)
effective_price = delta_y / delta_x = y / (x + delta_x)

Optimal arbitrage size balances price impact against fee drag. Closed-form for two pools with reserves (x1, y1) and (x2, y2) and fee f:

optimal_trade = sqrt(x1 * y1 * x2 * y2) / (x1 + x2) - y1

(simplified; full derivation accounts for fees asymmetrically)

CEX-DEX Arbitrage: Dominant MEV category post-Merge. Centralized exchange price updates faster than DEX rebalancing.

• Latency advantage critical: co-located traders at CEX execute fills in <1ms
• On-chain DEX update: next Ethereum block (~12s); creates ~12s window of stale pricing
• Value: estimated $1-3B annually across all DEXes; majority captured by professional market makers
• CEX-DEX arb is "good MEV" — it keeps DEX prices accurate and reduces LP losses from toxic flow

CEX-DEX arb model:

arb_value = (CEX_mid_price - DEX_effective_price) * trade_size * (1 - fee_drag)

LP impermanent loss (IL) is the flip side: LPs lose this exact value to arbitrageurs.

3.2 Liquidations

Lending protocols (Aave, Compound, MakerDAO) allow liquidation of undercollateralized positions.

Liquidation economics:

health_factor = (collateral_value * liquidation_threshold) / debt_value
liquidation_triggered_when: health_factor < 1.0

Liquidation bonus:

liquidation_profit = debt_repaid * liquidation_bonus - gas_cost

• Aave V3: bonus = 5-15% depending on asset
• Compound V2: bonus = 8%

Competition dynamics: Multiple searchers monitor oracle price feeds and race to liquidate. Gas auction in mempool; winner is often highest gas bidder or bundle with best simulation accuracy.

Flash loan liquidations: Liquidator borrows collateral asset flash loan, repays debt, receives collateral, swaps to repay loan — all in one atomic transaction. Eliminates capital requirement; profit = bonus - swap slippage - flash loan fee (0.09% on Aave).

3.3 Sandwich Attacks

Attacker identifies a pending large swap, frontrunns it (buying before), lets victim trade (moving price), then backruns (selling after). Classic price manipulation.

Sandwich profitability model:

profit = sell_price_after_victim - buy_price_before_victim - 2 * fees - gas

For Uniswap V2 pool with victim trade size V and pool depth L:

price_impact_of_victim ≈ V / L  (for small V/L)
sandwich_profit ≈ (V/L) * frontrun_size - 2*fee*frontrun_size - gas

Profit is proportional to victim slippage tolerance and inversely proportional to pool depth.

Empirical data:

• EigenPhi reports sandwich attacks cost users ~$150-200M annually (2022-2023 estimates)
• Single-block sandwiches are detectable; cross-block sandwiches harder to identify
• Anti-sandwich countermeasures: low slippage tolerance, private RPC, MEV Blocker

3.4 Just-In-Time (JIT) Liquidity

Liquidity provider adds concentrated liquidity to Uniswap V3 immediately before a large swap, captures fees, then removes liquidity in the same block.

JIT economics:

JIT_profit = fee_captured_from_swap - gas_cost_of_add_remove

JIT is only profitable when:

fee_rate * swap_size > gas_cost_add + gas_cost_remove

• At current gas prices: requires swap > ~$50K on Ethereum mainnet for profitability
• JIT hurts passive LPs by diluting their fee share in the block

V3 JIT formulas: For concentrated liquidity between ticks [pa, pb]:

liquidity_units = L
fee_earned_from_swap = fee_rate * swap_amount * (L_JIT / L_total)

JIT provider captures L_JIT / (L_total + L_JIT) of fees for that swap.

3.5 Backrunning

Transaction placed immediately after a target transaction to capture state changes.

Example: DEX price update backrun After a large swap moves a pool price, backrunner arbitrages the pool against another venue.

Backrunning is generally benign (no victim harm) unlike frontrunning. Pure backrunning is the basis for most DEX arbitrage.

3.6 Time-Bandit Attacks (Chain Reorg MEV)

If accumulated MEV in past blocks exceeds cost of reorging those blocks, a validator could theoretically reorg to capture it.

Reorg profitability condition:

MEV_in_reorged_blocks > cost_of_validator_penalty + opportunity_cost_of_reorg

For Ethereum PoS:

• Reorging requires >33% stake to execute safely (for short reorgs)
• Slashing risk: block equivocation → 1/32 ETH slash minimum + forced exit
• Practical threshold: reorg only rational if MEV >> slashing penalty

Security budget argument: Block rewards + MEV income must exceed attack profit for the chain to be secure. If MEV becomes extremely concentrated in single blocks ("golden blocks"), time-bandit risk increases.

4. Economic Security

Security Budget Framework

Security budget: Total annual revenue to validators (block rewards + transaction fees + MEV) that makes attacking the chain unprofitable.

security_budget = annual_issuance + annual_fee_burn_redirected_to_validators + annual_MEV

Note: EIP-1559 burns base fees, reducing security budget vs. pre-1559. Priority fees + MEV go to validators.

Cost of attack (51% attack on PoW):

attack_cost_per_hour = hashrate_required * energy_cost_per_hash * hours
hashrate_required = 0.51 * total_network_hashrate

Cost of attack (PoS long-range attack):

attack_cost = 0.33 * total_staked_ETH * ETH_price

For Ethereum: ~33% of ~32M ETH ≈ 10.56M ETH ≈ $35B+ at $3,300/ETH (2024 prices)

Profit from attack: For double-spend attack:

attack_profit = value_of_double_spent_transactions - attack_cost - slashing_losses

Security ratio:

security_ratio = attack_cost / attack_profit

Rational attack condition: attack_profit > attack_cost i.e., security_ratio < 1

Staking Yield as Security

Higher staking yield → more ETH staked → higher attack cost.

Ethereum issuance model (post-Merge):

annual_issuance = base_reward_per_epoch * epochs_per_year * sqrt(total_staked_ETH / 32) * validators_count

Simplified: issuance scales with sqrt(total_staked_ETH), creating diminishing returns for additional stakers.

Staking equilibrium: Staking yield falls as more ETH is staked, reaching equilibrium where:

staking_yield = opportunity_cost_of_capital (risk-adjusted)

With ~32M ETH staked (2024), issuance yield ≈ 3.0-3.5% APR. MEV adds ~0.5-1.5% on top for solo validators using MEV-Boost.

5. Proposer-Builder Separation (PBS)

MEV-Boost Architecture

MEV-Boost is an out-of-protocol PBS implementation by Flashbots. Validators run MEV-Boost as a sidecar to their consensus client.

Architecture:

[Searchers] --> [Builders] --> [Relays] --> [MEV-Boost] --> [Validator/Proposer]
                               (multiple)      (sidecar)

Flow per slot:

1. Builder constructs block and submits bid to relay with block header (not full block body)
2. Relay validates block (simulates, checks payment, verifies no invalid txs)
3. Relay serves highest valid bid to requesting validators
4. Validator signs the block header (commits to proposing this block)
5. Relay releases full block body after receiving signed header
6. Validator broadcasts block

MEV-Boost adoption: ~90% of Ethereum validators use MEV-Boost (2023-2024 data). This makes out-of-protocol PBS de facto standard.

Builder Competition

Builder block auction: Builders compete in a second-price-adjacent auction for the block slot. In practice it's first-price (highest bid wins).

Builder profit model:

builder_profit = total_bundle_value + uncle_bandit_value + order_flow_fees - bid_to_proposer - operational_cost

Builders who receive exclusive order flow (from wallets like MetaMask, Coinbase) can extract more value because they see private transactions. This creates a two-sided market dynamic.

Builder market power:

• Order flow (OF) is the scarce input; builders compete for exclusive OF agreements
• Wallet apps receive "kickbacks" from builders for exclusive routing (controversial)
• Top builders: beaverbuild, rsync-builder, titan, flashbots builder
• Herfindahl-Hirschman Index (HHI) of builder market has been high (~3000-4000), indicating concentration

Relay Trust Assumptions

Relays are trusted intermediaries — they see the full block body before the validator commits. This creates:

1. Censorship risk: Relay can filter transactions (OFAC compliance filtering is documented)
2. Block withholding risk: Relay could theoretically withhold winning block after validator signs header (equivocation risk)
3. Data availability: Relays serve block data to the network; single-relay dependency is a failure point

OFAC filtering controversy: Post-Tornado Cash sanctions (Aug 2022), many relays began filtering OFAC-sanctioned addresses. At peak, ~70-75% of Ethereum blocks were OFAC-compliant (censoring some transactions). This created a two-tier mempool and raised censorship-resistance concerns.

In-protocol PBS (ePBS): Ethereum researchers working on enshrined PBS to remove relay trust. Attester-Proposer Separation (APS) and execution tickets are proposed designs. Key property: builder must post full block before receiving payment commitment, enforced by protocol.

6. MEV Redistribution Mechanisms

MEV Share (Flashbots)

MEV Share allows users to share their transaction order flow with searchers and receive a portion of MEV extracted from their transactions.

Mechanism:

1. User submits transaction to MEV Share matchmaker
2. Matchmaker broadcasts "hints" (partial transaction data) to registered searchers
3. Searchers submit bundles that include user transaction plus their MEV extraction
4. Matchmaker selects bundle that pays highest user kickback
5. User receives ETH refund on-chain

Value split:

user_refund = kickback_percentage * MEV_extracted
searcher_keeps = (1 - kickback_percentage) * MEV_extracted - gas

Kickback is configurable by user (0-100%). Higher kickback → fewer searchers compete → less total MEV extracted (tradeoff).

Priority Fee as MEV Tax (MEV Tax)

Proposed mechanism where protocols embed a "MEV tax" directly into the priority fee.

Design: Protocol sets priority_fee = captured_value * tax_rate. Transactions that create MEV opportunities pay that value to the block proposer, which eventually flows to protocol via fee switches or burn.

Application: Cowswap batch auction settles at uniform clearing price; surplus is returned to users rather than extracted by MEV bots. This is a form of application-layer MEV internalization.

Order Flow Auctions (OFA)

OFAs are mechanisms where user transactions are auctioned to searchers/solvers who compete to give users the best execution.

Types:

• UniswapX: Dutch auction for swap orders; fillers compete on price improvement
• CoW Protocol: Batch auction with coincidence of wants (CoW) detection; solver competition
• 1inch Fusion: Intent-based swaps with resolver competition
• MEV Blocker: Routes transactions to searcher network; backrunning revenue shared with users

OFA economics:

user_surplus = price_improvement - base_execution_cost
protocol_revenue = spread_captured * volume
solver_profit = MEV_extracted - user_refund - gas

Competition among solvers drives user_surplus toward maximum achievable.

Backrunning Auctions

Instead of preventing MEV, backrunning auctions allow it and share proceeds.

SUAVE Order Flow Auction:

• Users submit orders to SUAVE (decentralized block builder/order flow marketplace)
• Searchers bid for backrunning rights
• Winning searcher executes backrun; revenue split: user / protocol / searcher
• SUAVE is Flashbots' decentralized MEV supply chain vision

7. Validator Economics

Staking Yield Decomposition

Total validator return:

total_APR = consensus_layer_APR + execution_layer_APR
consensus_layer_APR = issuance_APR + attestation_rewards_APR - slashing_penalties
execution_layer_APR = priority_fees_APR + MEV_APR

Issuance APR (simplified):

base_reward = 64 * effective_balance / sqrt(total_effective_balance_gwei)
annual_issuance_APR = base_reward * epochs_per_year / effective_balance

With 32M ETH staked: consensus APR ≈ 3.0-3.5% With MEV-Boost: execution APR adds ≈ 0.5-2.0% depending on block luck and market activity

Validator economics data (2023-2024):

• Solo validator 32 ETH: ~$2,500-6,000/year at $3,000 ETH, 3.5% consensus + 1% MEV
• MEV income is highly variable: lottery-like distribution; some blocks worth >10 ETH, most <0.05
• Smoothed MEV (DVT + MEV smoothing): reduces variance, makes solo validation more viable

Validator Set Dynamics

Entry queue mechanics:

• Ethereum limits validator activations: max_per_epoch = max(4, total_validators / 65536)
• Queue backlog in 2023: up to 6-12 month wait for new validators
• Exit queue similarly rate-limited to prevent rapid unstaking

Validator incentive model: Validators maximize expected returns subject to slashing risk:

expected_return = P(no_slash) * total_reward + P(slash) * (total_reward - slash_penalty)

Rational validators: maximize uptime, use MEV-Boost, choose high-performing client software.

Validator concentration risk:

• Lido controls ~30-32% of staked ETH (2023-2024 data)
• If single entity controls >33%, they can prevent finality
• If >50%, they can control transaction ordering
• Governance attack on Lido's node operator set is a systemic risk

LST (Liquid Staking Token) Economics

LST mechanics:

exchange_rate[t] = total_ETH_staked[t] / total_LST_supply[t]
exchange_rate increases over time as staking rewards accrue

stETH (Lido):

• Rebasing token: balance increases daily proportional to staking rewards
• stETH/ETH peg: maintained by arbitrage; depeg risk during liquidity crises
• June 2022: stETH traded at ~6% discount during Celsius/3AC crisis

rETH (Rocket Pool):

• Non-rebasing: exchange rate appreciates; 1 rETH > 1 ETH over time
• Decentralized: anyone can run node with 8 ETH + 2.4 ETH in RPL collateral

LST yield:

LST_APR = staking_APR * (1 - protocol_fee)
Lido fee: 10% of staking rewards
Rocket Pool fee: 14% of staking rewards (shared with node operators)

LST as DeFi collateral: stETH/rETH accepted as collateral in Aave, MakerDAO, Compound. Creates leverage loop:

deposit_stETH → borrow_ETH → stake → more_stETH → repeat

This loop increases LST demand and concentrates staking even further.

8. L2 Economics

Sequencer Revenue Model

L2 sequencers earn revenue from the spread between L2 transaction fees collected and L1 data costs paid.

Sequencer profit per transaction:

sequencer_profit = user_fee_paid - L1_data_cost - L2_execution_cost - overhead

L1 data cost (pre-EIP-4844):

calldata_cost = bytes * 16_gas (non-zero) + bytes * 4_gas (zero)
L1_data_cost = calldata_gas * L1_base_fee * ETH_price

L1 data cost (post-EIP-4844, blobs):

blob_cost = blob_count * blob_base_fee
blob_base_fee adjusts like EIP-1559 targeting 3 blobs per block (max 6)
blob_base_fee[n+1] = blob_base_fee[n] * exp((blob_count - target) / target)

EIP-4844 (Dencun, March 2024) reduced L2 data costs by ~10-100x depending on network conditions.

Sequencer revenue data (2023-2024):

• Arbitrum: ~$50-150M annual sequencer revenue (estimated)
• Optimism: ~$30-80M annual sequencer revenue
• Base (Coinbase): launched mid-2023, rapidly growing, ~$50M+ estimated 2024
• Most sequencer profit flows to protocol treasury or token holders (OP Stack: goes to Optimism Collective)

L1 Data Costs

Blob pricing mechanics:

• Target: 3 blobs/block; max: 6 blobs/block
• Blob size: 128KB per blob (4096 field elements * 32 bytes)
• Blob data available for ~18 days (not forever; proofs stored permanently via EIP-4844 commitment)
• Post-Dencun blob fees: often <$0.01 per blob; L2 costs < $0.001 per transaction

L2 profitability:

margin = (L2_fee_revenue - blob_cost) / L2_fee_revenue

High margins when L2 is busy and blobs are cheap. Margin compresses when blob demand spikes.

L2 MEV

L2s have their own MEV dynamics, typically controlled by centralized sequencer:

Types of L2 MEV:

1. Sequencer extractable value (SEV): Centralized sequencer can reorder transactions; most choose not to for reputational reasons
2. DEX arbitrage on L2: Abundant, lower gas costs make smaller opportunities viable
3. L1→L2 bridge MEV: Large deposits create arbitrage opportunities between L1 and L2 prices

FCFS (First-Come-First-Served) sequencing: Most L2 sequencers use FCFS ordering to prevent frontrunning. But FCFS at the sequencer creates latency races to the sequencer endpoint (similar to CEX latency racing).

Shared Sequencing

Problem: Multiple L2s with separate sequencers cannot atomically coordinate cross-chain transactions.

Shared sequencer solutions:

• Espresso Systems: Decentralized sequencing layer; multiple rollups opt in
• Astria: Shared sequencer with lazy sequencing model
• Based rollups: Use L1 validators as sequencer; inherits L1 MEV structure

Economic model of shared sequencing: Shared sequencer captures cross-domain MEV (atomic arbitrage across L2s). Revenue split between:

• Sequencer operators
• Participating rollup protocols
• Token holders of sequencing protocol

9. Token Value Accrual

Fee Switches

Fee switch: Protocol begins redirecting a portion of trading fees from LPs to token holders or protocol treasury.

Uniswap V3 fee switch:

protocol_fee = trading_fee * switch_fraction (0-100% of LP fee, governance vote)

• Uniswap has activated fee switch on test pools (2023)
• Full switch activation: contentious; LPs would receive less, UNI holders more
• UNI holders vote to enable; conflict of interest vs. LP interests

Value accrual impact:

token_value = DCF(future_fee_revenue_to_token) + governance_premium + speculative_premium

Buyback-and-Burn

Burn mechanics: Protocol uses revenue to buy and burn its own token, reducing supply.

ETH burn (EIP-1559):

ETH_burned = base_fee * gas_used
annual_ETH_burned ≈ 300,000 - 900,000 ETH depending on activity (2022-2024 range)

This makes ETH "ultrasound money" thesis: at high activity, ETH supply decreases.

Token deflationary model:

inflation_rate = issuance_rate - burn_rate
ultrasound threshold: issuance_rate = burn_rate

For ETH: ~4.7M ETH/year issuance (post-Merge, pre-EIP-1559 offset)... wait, post-Merge issuance is ~700K ETH/year. At historical burn rates of 500K-900K ETH/year: ETH is net deflationary.

BNB burn: Binance burns BNB quarterly based on trading volume; supply reduces toward 100M BNB.

Revenue Sharing

veToken model (Curve, Balancer):

• Token holders lock tokens for veCRV/veBAL
• Receive share of protocol fees proportional to locked amount and duration
• Lock creates supply overhang and alignment incentives

veCRV_balance = CRV_locked * (time_remaining / max_lock_time)
fee_share_per_epoch = (veCRV_balance / total_veCRV) * total_protocol_fees

Curve Wars: Protocols compete to accumulate veCRV to direct CRV emissions to their liquidity pools. This created an entire meta-economy of bribe protocols (Votium, Hidden Hand).

Bribe economics:

bribe_ROI = (CRV_emissions_directed * CRV_price) / bribe_amount
Protocol bribes if ROI > cost of alternative liquidity acquisition

Protocol-Owned Liquidity (POL)

Instead of renting liquidity via token emissions, protocols own their own liquidity permanently.

Olympus DAO bond mechanism:

• Users sell ETH/DAI/LP tokens to protocol at discount for OHM bonds (vested over 5 days)
• Protocol accumulates treasury; OHM backed by treasury at minimum
• Bonding works as: bond_price = market_price * (1 - discount)

POL advantages:

• No mercenary capital: liquidity stays even when emissions stop
• Protocol earns trading fees from its own liquidity
• Treasury appreciation creates reflexive value

POL risks:

• Concentration: protocol is single LP; exit = liquidity crisis
• Smart contract risk on protocol-owned positions

10. Cryptoeconomic Attack Analysis

Governance Attacks

Governance attack: Acquiring enough voting tokens to pass malicious proposals (drain treasury, change fee parameters, etc.)

Cost of governance attack:

attack_cost = (quorum_threshold * total_supply + 1) * token_price

For Compound (2023):

• COMP supply: ~10M tokens
• Quorum: 400K COMP needed (4%)
• Attack cost at $60/COMP: ~$24M
• Compound treasury: ~$150M

This creates a profitable attack if execution succeeds.

Time-delayed governance:

• Timelock contracts delay proposal execution (e.g., 48h-7 days)
• Allows community to detect and react to malicious proposals
• Can perform "governance emergency" via multisig guardian

Flash loan governance attack:

1. Flash loan governance tokens
2. Vote on malicious proposal in same block (if no snapshot delay)
3. Pass proposal
4. Repay flash loan

Modern protocols prevent this via snapshot-based voting (votes counted at proposal creation block, not execution block). Compound and Uniswap use this pattern.

Beanstalk exploit (April 2022):

• Attacker flash loaned ~$1B in stablecoins
• Used Beanstalk's Silo (governance) to vote on malicious BIP
• Passed immediately (no timelock) — drained $182M from protocol
• Flash loan repaid; net profit ~$80M

Oracle Manipulation Economics

Oracles report external price data on-chain. Manipulation creates profit opportunities.

TWAP (Time-Weighted Average Price) manipulation:

TWAP[n] = (sum of prices weighted by time) / total_time
TWAP = Integral(price(t) dt) / T   over window T

Manipulating TWAP requires moving price for sustained duration:

manipulation_cost = price_impact_cost * duration

For Uniswap V2 TWAP:

cost_to_manipulate_by_X% = pool_liquidity * (X/100)^2 / (time_window_in_seconds / block_time)

Mango Markets exploit (Oct 2022):

• Attacker used $10M to take large MNGO futures position
• Simultaneously pumped MNGO spot price via AMM (own funds)
• Manipulated oracle price → inflated collateral value
• Borrowed $116M against inflated collateral
• Walked away with ~$110M profit after repaying loan

Flash Loan Amplification

Flash loans allow uncollateralized borrowing within a single transaction.

Flash loan economics:

max_borrow = protocol_liquidity (Aave V3: ~$10B+)
flash_loan_fee = borrow_amount * 0.0009 (0.09% on Aave)

Amplification factor: Flash loans amplify capital by orders of magnitude. An attacker with $100K can execute attacks requiring $100M+ of capital, as long as the attack is atomic and profitable.

Flash loan attack profitability condition:

attack_profit > flash_loan_fee + gas_cost
attack_profit = exploit_value - market_impact_losses

bZx attacks (Feb 2020, first major flash loan exploit):

• Attack 1: Borrowed ETH flash loan, shorted ETH on bZx, pumped WBTC/ETH price on Uniswap (thin liquidity), triggered bZx liquidation for profit — $350K profit
• Attack 2: Similar SUSD price manipulation — $600K profit
• Both attacks required no capital; only on-chain execution skill

Cross-Protocol Composability Risk

Flash loans expose a "free option" on composability. Every new protocol integration creates new potential attack surfaces.

Risk amplification through composability:

total_exploitable_value = min(protocol_TVL, flash_loan_available_liquidity)
attack_complexity scales with protocol_integration_depth

11. Gas Token Economics

CHI Token History

Gas tokens (GST2, CHI) allowed users to pre-purchase gas at low prices and redeem it later at high prices via SELFDESTRUCT/SSTORE refund mechanism.

Mechanism (pre-EIP-3529):

• SSTORE 0→nonzero costs 20,000 gas
• SSTORE nonzero→0 (clear) refunds 15,000 gas (old EVM rule)
• Gas tokens: mint (SSTORE) when gas cheap; burn (clear via SELFDESTRUCT) when gas expensive

CHI token (1inch):

• More gas-efficient than GST2; used SELFDESTRUCT for additional refund
• Widely used by MEV bots and DeFi power users (2019-2021)
• CHI: mint at 1 gas_token per 43,000 gas; burn refunded ~42,000 gas minus overhead

Profitability of gas token arbitrage:

profit = (gas_price_at_burn - gas_price_at_mint) * refund_per_token - mint_cost * gas_price_at_mint - overhead

Effective if burn/mint gas price ratio > 1.5-2x (accounting for overhead).

EIP-3529 (London, Aug 2021)

EIP-3529 significantly changed gas refund mechanics:

Changes:

• SELFDESTRUCT no longer grants gas refund (eliminated)
• SSTORE refund reduced from 15,000 to 4,800 gas
• Max refund cap: changed from 50% of gas used to 20% of gas used

Impact on gas tokens:

• CHI and GST2 became unprofitable/unusable
• Gas token market collapsed; CHI supply stranded
• SELFDESTRUCT penalty: still exists as opcode but refund removed (SELFDESTRUCT itself scheduled for eventual removal via EOF)

EIP-4758 (future): Proposes SELFDESTRUCT deactivation to simplify state management and enable Verkle tree transitions.

Gas token economics post-3529:

• No viable on-chain gas token mechanism exists
• Gas futures/derivatives (off-chain) explored by protocols but illiquid market
• GasHawk, bloXroute: offer gas price optimization via timing rather than gas tokens

12. Future MEV

Encrypted Mempools

Problem: Public mempool enables frontrunning and sandwiching by revealing transaction intent before execution.

Threshold encryption approach:

1. User encrypts transaction with committee public key
2. Encrypted transaction submitted to mempool
3. Validators order encrypted transactions (cannot see content)
4. After block committed, committee decrypts and reveals
5. Execution proceeds; ordering is already committed, cannot be manipulated

Threshold decryption security:

t-of-n threshold: t validators must cooperate to decrypt
security: breaking requires t validators colluding before decryption

Practical implementations:

• Shutter Network: Deployed threshold encryption on Gnosis Chain; Ethereum integration in research
• Penumbra: Privacy-preserving DEX using ZK proofs; orders invisible until settlement
• Anoma: Intent-based architecture with privacy; encrypted intents revealed post-matching

Encrypted mempool limitations:

• Decryption adds latency (~200-500ms for threshold ceremony)
• Does not prevent all MEV: post-decryption order matters; last-look manipulation still possible
• Committee trust assumption; liveness requirement (decryption must happen for execution)
• Replay attacks: encrypted tx rebroadcast in future slots if intent not expired

SUAVE (Single Unifying Auction for Value Expression)

Flashbots' architecture for decentralizing the MEV supply chain.

SUAVE architecture:

[User Intents] --> [SUAVE Chain] --> [Executors/Searchers] --> [Multi-chain Blocks]

Key components:

1. Confidential compute: TEE (Trusted Execution Environment) for private preference expression
2. Preference Environment: Users submit encrypted orders/preferences
3. SUAVE chain: Executes MEV extraction logic in TEE; results verified on-chain
4. Universal block builder: Can build blocks for Ethereum, L2s, and other chains simultaneously

SUAVE economic model:

• Searchers bid for order flow in SUAVE
• MEV extracted goes to: user (refund) + SUAVE validators + block builders
• SUAVE token used for paying for compute and staking by executor nodes

Cross-chain MEV via SUAVE: SUAVE enables atomic cross-chain MEV: arbitrage between Ethereum and L2 in single SUAVE execution, settled atomically via bridge calls.

Inclusion Lists (EIP-7547 and related)

Problem: Builder censorship — powerful builders can exclude transactions (OFAC compliance, extracting value by delaying competitor transactions).

Inclusion list mechanism:

• Proposer specifies a list of transactions that MUST be included in the next block
• Builder constructs block; must include all listed transactions or block is invalid
• Proposer compiles inclusion list from mempool without builder's influence

Economics of inclusion lists:

censorship_resistance_value = sum(expected_delay_cost for censored_txs)
IL_improves: proposer enforces minimum inclusion without knowing block content

Attacker response: Builder could refuse to build blocks with uncomfortable inclusion lists → reduces builder revenue → market pressure toward compliant builders.

Force inclusion (alternative): After N slots of non-inclusion, any transaction in public mempool is automatically included. Weaker guarantee but lower implementation complexity.

MEV Smoothing

Problem: MEV income is highly volatile for validators. Some blocks are worth 0.01 ETH, rare "golden blocks" worth 100+ ETH. This variance creates inequality and incentivizes validator centralization (economies of scale in variance reduction).

MEV smoothing approaches:

1. Execution tickets (EIP-7547 variant): Validators sell their right to propose blocks; buyers receive MEV; proceeds distributed to all validators
2. MEV smoothing pool: Validators share MEV via off-chain commitment; each gets proportional share
3. Attester-Proposer Separation (APS): Attesters (majority) receive stable income; proposers receive MEV; roles separated

Rocket Pool MEV smoothing pool (live):

• Node operators opt-in
• MEV-Boost rewards pooled and distributed proportionally to all opt-in validators
• Reduces variance: from "lottery" to stable ~MEV average per epoch

Economic model of MEV smoothing:

smoothed_reward_per_validator = (total_MEV_in_period / N_smoothed_validators) * (uptime_fraction)
expected_value same; variance(smoothed) << variance(individual)

By Central Limit Theorem: variance reduces by 1/N for N validators pooling.

Threshold Encryption MEV Resistance

Commit-reveal schemes:

Phase 1 (commit): user submits H(tx || nonce) to mempool
Phase 2 (reveal): after block committed, user reveals tx; included in next block

Problem: two-transaction cost; liveness issue if user doesn't reveal.

TEE-based sequencing: Trusted hardware (Intel SGX, AMD SEV) executes transaction ordering inside secure enclave. Enclave cannot be read by node operator.

Limitations of TEE:

• Side-channel attacks on SGX are documented; not cryptographically secure
• Single point of hardware trust; supply chain risk
• Intel/AMD have kill switches; geopolitical risk

Cryptographic MEV minimization: Long-term research direction combining:

• Threshold encryption (pre-confirmation privacy)
• ZK proofs (provable fair ordering)
• Randomness beacons (verifiable randomness for tie-breaking)

MEV in Post-Quantum Context

With quantum computing advances (Grover's algorithm, Shor's algorithm):

• Threshold signature schemes (BLS12-381) vulnerable to Shor's algorithm at ~4000 logical qubits
• Timeline: cryptographically relevant quantum computers potentially 10-20 years out
• MEV extraction via quantum speedup: Grover's algorithm provides quadratic speedup for brute-force search; could enable faster arbitrage discovery
• Post-quantum MEV: resistant protocols must use lattice-based cryptography (CRYSTALS-Dilithium, CRYSTALS-Kyber)

Appendix: Key Formulas Reference

AMM Price Impact

Uniswap V2: output = (input * fee_factor * reserve_out) / (reserve_in * 1e6 + input * fee_factor)
fee_factor = 997 (for 0.3% fee)

Impermanent Loss

IL = 2 * sqrt(price_ratio) / (1 + price_ratio) - 1
For price_ratio = 2x: IL = 2 * sqrt(2) / 3 - 1 ≈ -5.7%
For price_ratio = 5x: IL ≈ -25.4%

Uniswap V3 Concentrated Liquidity

L = sqrt(k) where k = x * y
For range [p_lower, p_upper]:
x = L * (sqrt(p_upper) - sqrt(p)) / (sqrt(p) * sqrt(p_upper))
y = L * (sqrt(p) - sqrt(p_lower))

MEV-Boost Bidding Game (Game Theory)

Builder bidding: Nash equilibrium where each builder bids their block value minus small epsilon
In practice: Bertrand competition with block value heterogeneity
Proposer expected_MEV = max(builder_bids) = second_highest_value + epsilon (in ideal competition)

Staking Economics

real_staking_yield = nominal_yield - inflation_rate
nominal_yield = (consensus_rewards + MEV_income) / staked_ETH
For Ethereum post-Merge (2024 approx): nominal ≈ 4-5%, inflation ≈ -0.3% to +0.3%
real_yield ≈ 4.3-5.3%

Base Fee Prediction (EIP-1559)

If blocks consistently full (gas_used = gas_limit):
base_fee[n] = base_fee[0] * (1.125)^n
Doubling time: n = log(2)/log(1.125) ≈ 5.88 blocks ≈ 70 seconds

Flash Loan Profit Threshold

minimum_exploitable_profit = flash_loan_fee + gas_cost
= borrow_amount * 0.0009 + gas_used * gas_price
For $100M flash loan: minimum profit = $90,000 + gas costs (~$500-5000)

Governance Attack Threshold

tokens_needed = quorum_percentage * total_supply + 1
cost = tokens_needed * market_price
attack_profitable_if: protocol_value_at_risk > cost * (1 + opportunity_cost)

Key References and Data Sources

• Flashbots MEV Dashboard: mev.metablock.dev — real-time MEV extraction data
• EigenPhi: eigenphi.io — MEV transaction analysis and sandwich detection
• MEV-Boost.pics: mevboost.pics — relay statistics and builder market share
• Rated.network: validator performance and MEV income statistics
• Ethereum Research (ethresear.ch): PBS designs, ePBS proposals, inclusion lists
• EIP-1559 analytics: ultrasound.money — ETH issuance vs. burn tracking
• Dune Analytics: on-chain MEV, DEX volume, staking data dashboards

Document covers state of blockchain economics and MEV theory as of 2024-2025. Fast-moving field: specific data points should be verified against current sources. Mathematical models are simplified for pedagogical clarity; production implementations require additional precision.