Chain Fit

Stop comparing chains. Compare your contract.

Every chain comparison you have read is a table of numbers about the chain. This one runs your contract, watches what it actually does, and prices that execution under each chain's real gas schedule. Where Monad costs more, it says so.

Seven places you would notice the difference

The development journey, one stage at a time. Each stage has a single parameter that decides something, and the friction it costs you, on every chain including this one.

Will the thing I want to build even fit?

Maximum contract size

EIP-170 caps a deployed contract at 24 KB almost everywhere, which is the constraint that pushes large systems into proxies and diamonds before a line of business logic is written. Monad raises it to 128 KB.

  • Monad128 KBA large system deploys as one contract.
  • Ethereum24 KBAnything larger needs a proxy or a diamond split.
  • Base24 KBAnything larger needs a proxy or a diamond split.
  • Arbitrum24 KBAnything larger needs a proxy or a diamond split.
  • Polygon24 KBAnything larger needs a proxy or a diamond split.
  • BNB24 KBAnything larger needs a proxy or a diamond split.

What it costs you here

  • Monad EIP-4844 blobs are not supported, so a design that reads blob hashes needs another data availability path.
  • Monad An EIP-7702 delegated account cannot use CREATE or CREATE2, and cannot be taken below 10 MON.
Try a contract over 24 KBSourceStage 1 of 7

The networks, right now

Read from each chain's own public RPC when this page was generated. Nothing here is quoted from a blog post.

The same app, once it has users

Gas fees per call at the live gas price, multiplied out to a monthly bill.

  • Monad$270.99
  • Base$1,481
  • Polygon$2,791
  • BNB$3,668
  • Arbitrum$4,937
  • Ethereum$14,127

Monthly, at 50,000 transactions a day. Execution gas only: the rollups additionally bill for posting calldata to Ethereum, so their real figures are higher than shown.

Now do it to a contract

Pick a sample or paste your own. Nothing is stored.

Six fields of one struct land in consecutive slots, so they share a storage page. Monad pays the page charge once and then 100 gas a slot, where every other chain here pays per slot every time. This is the case Monad's storage model is built for.

Put this on your own page

The journey above, as an iframe. It reads the same live data, follows your page's colour scheme, and needs no script on your side.

Theme
Chains
Paste this
<iframe
  src="https://www.monsmith.com/embed/journey"
  title="Monsmith: the EVM development journey, measured"
  width="100%"
  height="620"
  loading="lazy"
  style="border:0;border-radius:16px"
></iframe>
Optional: let the frame size itself
The embed posts its height; this resizes the frame to match.
<script>
  window.addEventListener("message", function (event) {
    if (event.data && event.data.type === "monsmith:height") {
      var frame = document.querySelector('iframe[src^="https://www.monsmith.com/embed/"]');
      if (frame) frame.style.height = event.data.height + "px";
    }
  });
</script>

Preview it at www.monsmith.com/embed/journey

How the numbers are produced

01

Compile and run it

Your contract is compiled with solc and deployed into a local EVM. Every state-changing function is then called and traced opcode by opcode, so the Ethereum gas figure is what a real EVM charged rather than a static estimate.

02

Reprice the same execution

Monad keeps Ethereum's costs everywhere except four places: cold state access, the granularity at which storage warms, four precompiles, and memory expansion. Those four are recomputed against that one trace. Everything the two chains price the same cancels and is never modelled.

03

Price it in money

Gas units are converted at the gas price read from each chain's public RPC at page load. Block times come from the gap between two real block timestamps. Numbers that drift are measured; protocol constants carry the link they came from.

What this does not measure

  • Rollups charge for publishing calldata to Ethereum on top of execution gas, and that is not included here. Measured against their live fee oracles it comes to about $0.0001 on Base and $0.00002 on Arbitrum for a 39 KB deployment, three to four orders of magnitude under the execution cost shown. Blobs made it nearly free; before EIP-4844 it would have dominated.
  • Functions are called with synthesised arguments. One guarded by a balance or permission check reverts, and a reverted call is marked rather than folded into a total.
  • Gas units are not money, and money is not the whole decision. Ecosystem depth, liquidity and the maturity of the tooling around a chain are real and are not on this page.