Monad vs Ethereum: Contract Differences That Affect Security

Video transcript

Monad runs Ethereum bytecode, but compatible is not identical. Its documented differences can break assumptions your contracts and bots make.

Parallel execution keeps Ethereum's results, so reentrancy and ordering behave the same. What changes is timing. Some included transactions revert and still pay gas.

Monad charges the gas limit, not gas used. Relayers and paymasters pay whatever limit a request names, refunds from gasleft undercount, and wallet fallback limits land on users.

Cold account access rises from 2,600 to 10,100 gas, and ecRecover doubles to 6,000. Contracts can reach 128 kilobytes. Retest fixed stipends and hard-coded gas checks.

Delegated EOAs cannot drop below 10 MON, and cannot use CREATE. Withdraw-all flows revert below that floor, so undelegate first.

Settle deposits on the finalized tag, about 600 milliseconds out. With no global mempool, monitor blocks instead. Nodes keep little old state, so emit events for values you need.

Diff every hard-coded gas value. Cap gas limits in relayers and bots. Handle included but reverted transactions. Then test on Monad itself, not just a fork.

Routine checks matter too. Guardian's USDT zero Monad report flagged Safe signers that differed from some other chains.

Guardian audits can target exactly these differences. Read the full article, or talk to Guardian at guardian.security.

Monad's mainnet launched on November 24, 2025. The Block described it as EVM bytecode-compatible, so developers can redeploy Ethereum applications.

Bytecode compatibility is not identical behavior. Monad's docs list the differences, and each one can break an assumption your contracts or bots make.

Below is what each difference means for security, read from Monad's docs on November 6, 2026. For the chain-side view, see our custom EVM audit guide.

Parallel Execution and Ordering

Monad runs transactions optimistically in parallel. If one read data that an earlier transaction changed, it is re-executed with the correct data.

Monad's docs say the result of a block "is identical between Monad and Ethereum." Blocks remain a linear order of transactions.

So reentrancy, ordering and same-block logic behave as on Ethereum. Parallelism does not add race conditions inside a block.

What changes is timing. Consensus orders transactions before they execute, and a block's state root is included 3 blocks later.

Consensus therefore checks balances against slightly old state. Monad's Reserve Balance rules cover the gap, so some transactions are included, revert at execution, and still pay gas.

Gas Is Charged on the Limit

Monad charges the gas limit a transaction sets, not the gas it uses. The sender pays value plus gas price times gas limit.

Leaders build blocks before execution finishes. Charging gas used would let a transaction reserve a large limit cheaply, which Monad's docs call a denial-of-service vector.

Each transaction is capped at 30M gas. The security impact falls on whoever pays:

• Relayers and paymasters pay for whatever limit a request names. Cap it, or callers can make you overpay.
• Refunds measured with gasleft() undercount what a relayer actually paid.
• Wallet fallbacks: some wallets, including MetaMask, set a very high limit when estimation fails. On Monad, the user pays it.

Set limits from measured execution plus a small margin, not from Ethereum habits.

Repriced Opcodes and Larger Contracts

Monad prices state reads from disk higher relative to computation. Warm access still costs 100 gas.

Storage is warmed a page of 128 consecutive slots at a time. After the first access, other slots on that page read for 100 gas.

What tends to break:

• Fixed gas stipends for callbacks, hooks and cross-chain message handlers.
• Signature checks with hard-coded gas, since ecRecover costs 6,000 on Monad.
• Batches that fit on Ethereum but exceed Monad's 30M cap at the new prices.
• Code that grows memory past 8 MB, which now halts the call frame.

Larger contracts cut the other way. A contract over 24 KB deploys on Monad but cannot deploy on Ethereum, so keep Ethereum's limit if you need one address on every chain.

EIP-7702 Accounts and the Reserve

EIP-7702 delegation works as on Ethereum, with two exceptions. For the base model, see EIP-7702 vs ERC-4337.

• A 10 MON floor. A transaction that would draw a delegated EOA below 10 MON reverts.
• No CREATE. When a delegated EOA is called as a contract, CREATE and CREATE2 are banned.

The floor exists because anyone can debit a delegated account, and consensus sees balances 3 blocks late.

A delegated EOA need not hold 10 MON. A transaction that leaves its balance level or higher is fine.

The impact for wallet teams:

• Delegate code that deploys contracts from the account fails on Monad.
• Sweep and withdraw-all flows revert below the floor. Monad says to undelegate first to empty an account.
• Contracts can call dippedIntoReserve() on the 0x1001 precompile. It must be invoked with CALL; other call types revert.

Finality, RPC and Validators

Finality and reorgs

MonadBFT targets 300 ms blocks. A block is speculatively final after one slot and fully final after two, about 600 ms.

The RPC tags map to these states: latest is Proposed, safe is Voted and finalized is Finalized.

Data from non-final blocks can change between requests, and abandoned blocks get no explicit event. Monad's docs say to use finalized for value settlement. See finality by chain.

Mempool and RPC

• There is no global mempool. Transactions go to the next few leaders.
• newPendingTransactions subscriptions are not supported, so mempool-based alerts do not carry over.
• Nodes may accept transactions with nonce gaps or short balances, since they may become valid later.
• eth_getLogs is capped at 100 blocks per request on some providers.

Old state

Full nodes serve every block, receipt, log and trace, but not arbitrary past state. Monad says a 2 TB disk has recently held about 40,000 blocks of it.

A separate Monad RPC service answers some historical state queries. Still, emit events for any value you will need later, as Monad recommends.

Validators

The active set is the top 200 validators by stake. Each needs 10,000,000 MON delegated, including 100,000 MON self-delegated.

Automated in-protocol slashing is not implemented yet. Monad's docs point to logging for accountability.

Porting Checklist

1. Diff every hard-coded gas value against Monad's opcode and precompile prices.
2. Cap gas limits in relayers, paymasters and bots: the limit is the bill.
3. Retest memory-heavy paths against the 8 MB cap.
4. Check delegate code for CREATE or CREATE2.
5. Handle included-but-reverted transactions in interfaces and accounting.
6. Credit deposits and settle on the finalized tag.
7. Move mempool-based monitoring to block-based detection.
8. Emit events for every value you will need to rebuild.
9. Re-verify owners, roles and multisig signers on the Monad deployment.

The last item is routine and easy to skip. Guardian's public USDT0 Monad deployment report flagged that the Monad Safe's signers differed from some other chains' Safes (I-02, acknowledged).

Test on Monad itself, not only on an Ethereum fork.

How Guardian Helps

Guardian's smart contract audit runs in three passes: design review, an invariant suite, then senior researchers attack what is left.

For a port, point that scope at the differences above: gas assumptions, account rules, finality handling, and the roles and signers on the new deployment.

Guardian also runs pre-production reviews for new protocols, markets, chains and token systems. After launch, Managed Security monitors contracts on every block for privileged calls, upgrades and large fund movements.

Frequently Asked Questions

Is Monad fully EVM compatible?

It runs Ethereum bytecode and matches in-order results, but it is not identical. Gas is charged on the limit, several opcodes and precompiles are repriced, contracts reach 128 KB, blob transactions are unsupported, and delegated EOAs follow extra rules.

Does parallel execution on Monad create race conditions?

Not inside a block. Monad re-executes any transaction that read stale data, and its docs say block results are identical to Ethereum's. Timing does change: execution trails consensus, so some included transactions revert and still pay gas.

Why does Monad charge the gas limit instead of gas used?

Leaders build blocks before transactions execute. Charging gas used would let a transaction reserve a large limit cheaply, which Monad calls a denial-of-service vector. So set tight gas limits, especially in relayers and bots.

How fast is finality on Monad?

Monad targets 300 ms blocks, with speculative finality after one slot and full finality after two, about 600 ms. Use the finalized block tag for deposits and settlement; latest reflects proposed blocks that can still change.

Sources

• Monad docs: Differences between Monad and Ethereum (read November 6, 2026)
• Monad docs: Gas pricing (read November 6, 2026)
• Monad docs: Opcode pricing (read November 6, 2026)
• Monad docs: Precompiles (read November 6, 2026)
• Monad docs: Reserve Balance (read November 6, 2026)
• Monad docs: EIP-7702 on Monad (read November 6, 2026)
• Monad docs: Parallel execution (read November 6, 2026)
• Monad docs: Asynchronous execution (read November 6, 2026)
• Monad docs: MonadBFT (read November 6, 2026)
• Monad docs: RPC differences (read November 6, 2026)
• Monad docs: Historical data (read November 6, 2026)
• Monad docs: Staking (read November 6, 2026)
• Monad docs: Release notes, including MIP-12 300 ms blocks and the 30M per-transaction gas limit (read November 6, 2026)
• The Block: Monad mainnet launches (November 24, 2025)
• Guardian: USDT0 Monad Deployment report (November 2025)
• Guardian: Custom EVM Audit, What to Review in a Forked or Modified EVM