What Is MegaETH? The Real-Time EVM Explained for Developers: 10 ms Mini-Blocks, Sequencer Architecture, Gas Model and RPC

MegaETH is an Ethereum Layer 2 built on the OP Stack that seals a mini-block about every 10 milliseconds and a standard EVM block about every second. A single sequencer executes every transaction, signs each mini-block and streams the results to replica nodes, so an RPC read reflects a transaction within milliseconds of it being sent. Transaction data is posted to EigenDA rather than Ethereum blobs, and state proposals are secured on Ethereum with Kailua ZK fault proofs. Public mainnet opened on 9 February 2026 with chain ID 4326.

This page covers what a developer needs before pointing code at MegaETH: the node roles, what 10 ms blocks change about reads, writes and subscriptions, the dual gas model, the mainnet timeline, and how to connect. Every chain reading below was taken from MegaETH mainnet on 9 November 2026.

MegaETH at a glance

What is MegaETH?

MegaETH is MegaLabs' attempt to make an EVM chain respond like a web server. Its design paper, Revisiting the World Computer, argues that block time, more than throughput, is what keeps on-chain apps from matching web2 feedback loops, and that an EVM chain can reach tens of milliseconds by taking consensus off the execution path and giving each node one job. MegaLabs raised a $20 million seed round led by Dragonfly in June 2024, with Vitalik Buterin, Joseph Lubin and Sreeram Kannan as angels.

For a developer, MegaETH is an EVM target with Prague-era opcodes, 512 KB contracts and a second gas dimension. Solidity, Foundry, Hardhat, viem and ethers work unchanged. What changes is how fast state moves and how you read it.

How does MegaETH work?

The architecture docs describe four node roles. The sequencer is one node that orders and executes every transaction, seals a mini-block about every 10 ms and an EVM block about every second, signs each mini-block header, and streams receipts, logs and state changes outward. A hot standby takes over "within tens of milliseconds" if it fails.

Replica nodes receive those state diffs and apply them without re-executing anything, which is how an RPC node keeps pace with 100 blocks per second on ordinary hardware. They are the default mode for the RPC fleet. Full nodes re-execute every block and do not have to trust the sequencer. Provers generate the ZK proofs used in disputes.

Settlement is standard OP Stack with two substitutions. Block data goes to EigenDA instead of Ethereum blobs, and state proposals are secured by Kailua, a fault-proof system built on RISC Zero that resolves a dispute with one ZK proof instead of a multi-round bisection, inside a 7-day challenge window. L2BEAT rates the project below Stage 0 because external node software is still under review and the L1 contracts are upgradable with no delay.

Mini-blocks vs EVM blocks: what 10 ms means for RPC

A mini-block holds the transactions executed in one 10 ms window, their receipts and state changes, with no state root or bloom filter, which keeps the header small enough to stream 100 times a second. An EVM block is the ordinary Ethereum block that wraps the last second of mini-blocks. Every transaction lands in exactly one of each.

We subscribed to the public WebSocket for five seconds on 9 November 2026 and received 501 mini-blocks: 100 per second, a 10.0 ms average interval, every header signed. Over the same window eth_blockNumber advanced by one each second, safe trailed latest by about 430 blocks and finalized by about 1,960, roughly 33 minutes.

That split shows up in three places in your code.

Reads. eth_getBalance, eth_call, eth_getTransactionReceipt and the other read methods return state as of the latest mini-block when you pass latest or pending; an explicit block number returns sealed EVM-block state, up to a second behind. A receipt produced from a mini-block carries an all-ff placeholder blockHash until the EVM block seals, so index by transactionHash and blockNumber and refetch when you need the canonical hash.

Writes. realtime_sendRawTransaction submits a transaction and returns the receipt in the same call, with a node default wait of 5 seconds. An expiry is inconclusive: the transaction may still land.

Subscriptions. eth_subscribe adds two MegaETH-only streams. miniBlocks delivers every mini-block with its transactions and receipts; stateChanges delivers the new balance, nonce and changed storage slots for the accounts you name. A logs subscription with fromBlock and toBlock set to pending switches to the mini-block log stream, and newHeads stays at EVM-block cadence with a miniBlockCount field.

{ "jsonrpc": "2.0", "id": 1, "method": "eth_subscribe", "params": ["miniBlocks"] }

Each notification carries the mini-block number and microsecond timestamp, the enclosing EVM block number, transactions, receipts, two trie roots and a signature over keccak256(rlp(header)). The signing key is registered on-chain in the SequencerRegistry at 0x6342000000000000000000000000000000000006, so a signed mini-block is evidence: if a sealed EVM block ever contradicted it, anyone holding the header could prove it. It is not finality. That still comes from the EVM block being posted and verified on L1.

For a chain producing 100 blocks a second, a polling loop is the wrong tool. One WebSocket connection replaces 100 eth_blockNumber calls per second. The same arithmetic applies on Base at 200 ms; see what Base's 200 ms blocks do to RPC costs.

Where the data goes: EigenDA

MegaETH's own numbers explain the choice. Ethereum at the post-Pectra target of 6 blobs per block offers about 64 KB/s of data availability across every rollup; MegaETH's 100,000 TPS target needs about 20 MB/s. EigenDA was live at 15 MB/s when MegaETH integrated it. The sequencer sends batches to EigenDA, operators sign, and the aggregated certificate is verified on Ethereum before the batch can be posted. L2BEAT flags the trade-off: if the data is not available on EigenDA, funds can be lost. If EigenDA is down, the sequencer falls back to Ethereum.

Gas and fees on MegaETH

MegaEVM charges two kinds of gas from one gas_limit. Compute gas is Ethereum's gas schedule unchanged. Storage gas is added for operations that create persistent data: 39,000 per transaction, 10,000 per byte of deployed code, 3,750 per LOG topic, 160 per non-zero calldata byte, and a charge for new storage slots and accounts that stays at zero until the relevant SALT trie bucket fills up. There is no refund for resetting a slot; transient storage (TSTORE) avoids storage gas entirely.

The fee itself is small. The base fee read on 9 November 2026 was 0.001 Gwei with a zero priority fee, so a 60,000-gas transfer costs 0.00000006 ETH, and the docs say base-fee adjustment is "effectively disabled". Each transaction is also capped at 200,000,000 compute gas, 12.5 MB of data, 500,000 key-value updates and 1,000 new state entries; reading block.timestamp, block.number or oracle storage caps the rest of the call at 20,000,000 compute gas; and gas forwarding is 98/100 rather than 63/64.

Call eth_estimateGas on a MegaETH endpoint and never compute gas locally: Ethereum toolchains know nothing about storage gas. The MegaETH gas tracker shows the live base fee.

Is MegaETH mainnet live?

Yes, since 9 February 2026. The dates that matter:

Hardforks ran on the mainnet chain from December 2025, so a block height says nothing about how long the public network has existed.

Who runs the sequencer?

One sequencer, operated by MegaLabs. The hot standby covers hardware failure, and the SequencerRegistry lets the signing key rotate at an EVM block boundary with the history kept on-chain. If the sequencer ignores you, force inclusion through the OptimismPortal at 0x7f82f57F0Dd546519324392e408b01fcC7D709e8 on Ethereum obliges MegaETH to include the transaction within 12 hours; the docs quote 5 to 20 minutes in practice.

The MEGA launch post of 30 April 2026 describes sequencer rotation in which operators stake MEGA, are selected on stake and performance and are slashed for faults. It is not live, and you cannot run your own RPC node yet either; the developer FAQ says all RPC endpoints are operated by the MegaETH team. Design for a single operator today.

How do I connect to MegaETH?

Point any EVM library at a MegaETH endpoint with chain ID 4326. The public gateway at https://mainnet.megaeth.com/rpc and wss://mainnet.megaeth.com/ws limits reads per IP to between 200 and 2,000 per 10 seconds depending on the method, and allows 5 WebSocket connections per IP with 5 subscriptions each. The MegaETH tooling page lists dRPC, Dwellir and Chainstack among its managed providers.

Dwellir serves MegaETH mainnet over HTTPS and WSS from archive nodes:

https://api-megaeth-mainnet.n.dwellir.com/YOUR_API_KEY
wss://api-megaeth-mainnet.n.dwellir.com/YOUR_API_KEY

curl -s https://api-megaeth-mainnet.n.dwellir.com/YOUR_API_KEY \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
# {"jsonrpc":"2.0","id":1,"result":"0x10e6"}

We checked the Dwellir endpoint on 9 November 2026. The head matched the public gateway block for block, realtime_sendRawTransaction, eth_sendRawTransactionSync and eth_callMany are exposed, eth_getBalance at block 1,000,000 returned historical state, trace_block returned traces, and a miniBlocks subscription over WSS delivered signed mini-blocks at the same 10 ms cadence as the public stream. Billing is one credit per response for every method, traces and WebSocket messages included, with 100,000 responses a day free and paid plans from $49 a month. The MegaETH network page has plans, an Unlimited Node from $119 a month and a dedicated cluster at $12,600 a month; the MegaETH docs list all 47 methods. To compare providers on price, read the MegaETH RPC provider comparison; for sustained-rate planning, the best RPC providers for high-throughput workloads.

What's live and what's roadmap

Getting started

MegaETH behaves like any OP Stack chain until you care about the last second, and then the mini-block stream, the placeholder blockHash and the storage gas line in your estimates change your code. Subscribe to miniBlocks first and watch the cadence, then replace polling with realtime_sendRawTransaction and stateChanges.

To try it on Dwellir, create a free API key and run the eth_chainId check above against api-megaeth-mainnet.n.dwellir.com. For a dedicated MegaETH cluster or higher limits, contact the Dwellir team.

Frequently asked questions

What is MegaETH?

MegaETH is an Ethereum Layer 2 built on the OP Stack by MegaLabs. A single sequencer executes transactions and seals a mini-block about every 10 milliseconds and a standard EVM block about every second, then streams the results to replica nodes in several regions. Transaction data goes to EigenDA and state proposals are secured on Ethereum with Kailua ZK fault proofs. Public mainnet opened on 9 February 2026 with chain ID 4326.

What is the difference between a MegaETH mini-block and an EVM block?

A mini-block is a compact, sequencer-signed block sealed about every 10 ms with the transactions, receipts and state changes executed in that window. It has no state root or bloom filter. An EVM block is a standard Ethereum block sealed about every second that bundles the roughly 100 mini-blocks produced in that interval. Every transaction appears in exactly one of each. Standard tooling reads EVM blocks; the miniBlocks WebSocket subscription reads mini-blocks.

Is MegaETH mainnet live, and what is its chain ID?

Yes. MegaETH public mainnet has been open since 9 February 2026 with chain ID 4326 (0x10e6). The current testnet uses chain ID 6343; the original testnet at chain ID 6342 is deprecated. The MEGA token launched on 30 April 2026, after the network crossed its first usage milestone.

How do fees work on MegaETH?

MegaETH uses a dual gas model: compute gas, which matches Ethereum's gas schedule, plus storage gas for operations that create persistent data. Every transaction pays 60,000 intrinsic gas (21,000 compute plus 39,000 storage). The base fee read on 9 November 2026 was 0.001 Gwei with a zero priority fee, so a plain transfer cost about 0.00000006 ETH. Always call eth_estimateGas against a MegaETH endpoint; Ethereum toolchains underestimate storage gas.

Which RPC providers support MegaETH?

MegaETH's tooling page lists dRPC, Dwellir and Chainstack among its RPC providers, plus a rate-limited public gateway at mainnet.megaeth.com. Dwellir serves MegaETH mainnet over HTTPS and WSS from archive nodes, including the miniBlocks subscription, realtime_sendRawTransaction, and the trace and debug namespaces, at one credit per response.

Sources

Chain readings (eth_chainId, eth_blockNumber, eth_gasPrice, eth_maxPriorityFeePerGas, eth_getBlockByNumber with the latest, safe and finalized tags, web3_clientVersion, a five-second miniBlocks subscription, historical eth_getBalance and trace_block) were taken from the MegaETH public gateway and Dwellir's MegaETH endpoint on 9 November 2026. Third-party pages were read the same day.

• MegaETH docs: Architecture, Mini-Blocks, Realtime API, eth_subscribe, realtime_sendRawTransaction, Gas Model, Resource Limits, Transaction Execution, Operations and limits, Force inclusion, Developer FAQ, Tooling, Network upgrades
• MegaETH: Revisiting the World Computer, How we've achieved 10ms blocks, How we break performance limits with EigenDA, $MEGA is Live, 30 Apr 2026
• L2BEAT: MegaETH
• The Block: MegaETH raises $20 million, 27 Jun 2024
• Cointelegraph: MegaETH mainnet launch locked in for Feb. 9, 28 Jan 2026; ForkLog: MegaETH team launches public mainnet, 9 Feb 2026