--- title: "Sui vs Ethereum: Finality, Fees, and Architecture Compared" description: "Compare Sui and Ethereum on speed, fees, security, and scalability" author: "Sui Foundation" datePublished: 2026-10-20 dateModified: 2026-10-20 category: "Infrastructure" readTime: "8 min" canonical: https://www.sui.io/blog/sui-vs-ethereum-finality-fees-architecture --- # Sui vs Ethereum: Finality, Fees, and Architecture Compared ## Main Takeaways - Ethereum scales through Layer 2 rollups, which now carry roughly 95 percent of its transactions. Sui scales on the base layer through parallel execution, so a developer does not pick a rollup or move value across layers, and composability stays intact on one layer. - Fees are no longer the gap they were. After Fusaka, a basic Ethereum transfer costs under $0.03 and a token swap around $0.21, with Layer 2 fees a fraction of a cent. Sui averages under $0.02, and stablecoin transfers are gasless at the protocol level, so moving them costs nothing. - Finality is still the gap. Sui settles in roughly 390 milliseconds, deterministically. Ethereum produces a block every 12 seconds and finalizes in about 15 minutes. Single-slot finality is still research. - The security cases differ in kind. Ethereum's rests on a decade of scrutiny and a large catalog of audited components. Sui's rests on Move, where assets are resources the type system will not let you copy or destroy. Ethereum and Sui are solving the same problem from opposite ends of a decade. Ethereum proved that programmable money works and built the largest developer ecosystem and the deepest liquidity in crypto along the way. Sui started from a clean architecture in 2023, with the benefit of seeing where the first generation hit its limits. This page lays out where each chain is strong, where the tradeoffs fall, and which one fits which kind of project. ## The short version Ethereum is the incumbent, and the numbers say so. About $49 billion sits in Ethereum DeFi, against $5.9 billion on Solana and $473 million on Sui (DefiLlama, September 2026). Ethereum has the most developers, the most audited contracts, and the longest track record. If your project needs to reach that liquidity or the EVM tooling around it, that is a strong reason to build there. Ethereum's base layer stays deliberately conservative on throughput, which is why its scaling strategy moved to Layer 2 rollups. That choice solved cost for most use cases and introduced a different set of tradeoffs around finality, liquidity spread across rollups, and cross-layer complexity. Sui takes the other path. It is a high-performance Layer 1 that scales on the base layer itself, with sub-second finality, asset safety built into the language, and an integrated stack of storage, access control, and financial primitives. Where Ethereum asks you to assemble a system across mainnet and rollups, Sui gives you one place to build. ## Architecture: rollup-centric versus a scalable base layer Ethereum's roadmap is rollup-centric. The base layer stays secure and decentralized while staying limited on throughput, and the scaling happens on Layer 2s. Rollups now carry about 95 percent of Ethereum's transactions, and the L1 typically runs well below its block target ([ethereum.org](http://ethereum.org), 2026). Two designs dominate: optimistic rollups, which assume transactions are valid and rely on a challenge window, commonly seven days, before withdrawals to mainnet finalize; and zero-knowledge rollups, which post validity proofs and finalize withdrawals faster. Rollups brought costs down by changing what mainnet has to pay for. A rollup executes transactions away from L1 and posts the results back in compressed batches, so one L1 posting cost covers every transaction in the batch. EIP-4844 then gave that batch data its own lane, called blobs, priced separately from execution gas and deleted after a short window rather than stored forever. Pectra doubled blob capacity in May 2025, and Fusaka's PeerDAS, live December 2025, let validators sample blob data rather than download all of it, which raised capacity again. Cheaper data per batch, more batches per block, lower cost per user transaction. The architecture asks something in return. A developer building across Ethereum decides which rollup to deploy on, works out how liquidity is split across rollups, and reasons about how value and messages move between layers. Composability, the ability for any contract to call any other, was one of Ethereum's defining strengths on mainnet, and it weakens when applications are spread across separate rollups that do not share state directly. Sui keeps everything on one layer. The object model lets the chain identify exactly which objects a transaction touches, so transactions that do not overlap execute in parallel with no coordination overhead. The scaling model is horizontal: add hardware and throughput rises to meet demand, without congestion pricing. A developer on Sui does not choose a rollup or reason about cross-layer bridges, because the base layer is where the performance lives. ## Finality and cost Finality is where the two architectures still diverge. Ethereum produces a block roughly every 12 seconds, and a transaction included in a block is usually treated as confirmed within that window. Full finality under Ethereum's proof-of-stake design takes about 15 minutes, because it spans two consensus epochs. Single-slot finality would compress that, and it sits in the research phase, expected after substantial upgrades such as Verkle trees and Danksharding ([ethereum.org](http://ethereum.org) roadmap). For most consumer activity the practical wait is the block time. For high-value settlement, 15 minutes is the number that matters. Sui settles in roughly 390 milliseconds with deterministic finality. Once a transaction settles, there is no probabilistic waiting period after it. For payments, trading, and agent-driven workflows, settling in well under a second changes what kind of product you can build. Cost has moved in Ethereum's favor. As of May 2026, standard gas on Ethereum sat around 0.15 gwei, putting a basic ETH transfer under $0.03, an ERC-20 transfer near $0.08, and a token swap near $0.21. Layer 2 fees run a fraction of a cent. Sui's average transaction cost is under $0.02, and stablecoin transfers on Sui are gasless at the protocol level, so moving them costs nothing at any size. The fee gap on ordinary transactions has largely closed. What remains on the Sui side is the gasless path for stablecoins and the absence of congestion pricing when demand spikes, because Sui adds throughput horizontally rather than rationing block space. ## Security: maturity versus language design Ethereum's security case is its track record. The EVM has been running since 2015, billions of dollars in value have stress-tested it, and its catalog of audited libraries and hardened patterns is the largest in crypto. Sui's case starts earlier in the stack. Most major smart contract exploits in blockchain history came from Solidity letting dangerous patterns compile, the reentrancy bugs and accounting errors that have drained billions. Sam Blackshear, who created Move and co-founded Mysten Labs, designed the language so those patterns cannot be expressed at all. Assets in Move are resources the type system protects from being copied or destroyed, and Sui's object model gives every asset explicit on-chain ownership. A developer gets that protection without having to remember every defensive pattern. Audits still matter on Sui, and the tooling around them has grown. The Sui Foundation runs the Sui Security Expansion Program with HackenProof, which gives ecosystem projects bug bounties, crowdsourced audits, and pre-launch review from Move and Rust researchers. Six firms work on Sui audits: Asymptotic, which built the Sui Prover for formal verification of Move contracts; Certora, which pairs mathematical verification with manual review; MoveBit; OtterSec; Zellic; and [Blaize.Security](http://Blaize.Security). Move Registry publishes package source, documentation, and audit reports on-chain alongside the deployed contract, so anyone can check what was audited against what is running. The two security cases are not interchangeable. Accumulated scrutiny is what a deep bench of audited Solidity components buys you. A language where the common mistakes will not compile is what Move buys you. Which one matters more depends on whether your team is extending contracts that already exist or writing new ones that will hold valuable assets. ## Ethereum and Sui at a glance Dimension Ethereum Sui Architecture Rollup-centric: conservative base layer, scaling on L2s Scalable Layer 1, parallel execution on the base layer Time to finality ~12s block time; full finality ~15 min ~390ms deterministic Typical cost Under $0.03 basic transfer, ~$0.21 swap on mainnet; fraction of a cent on L2s Under $0.02 average; gasless stablecoin transfers Share of activity ~95% of transactions on rollups Single layer Smart contract language Solidity / EVM Move, designed for asset safety Data model Account model Object model Composability Strong on mainnet, fragmented across L2s Native across one integrated layer Ecosystem depth ~$49B DeFi TVL, largest developer base ~$473M DeFi TVL, integrated full stack Built-in stack Storage and identity via third parties Walrus, Seal, Nautilus, DeepBook native Swipe or scroll horizontally to compare all columns. _TVL figures: DefiLlama, September 2026. Ethereum fee figures:_ [_ethereum.org_](http://ethereum.org)_, May 2026. Re-verify before publishing._ ## The integrated stack Benchmarks miss the stack. Sui ships Walrus for decentralized storage, Seal, which encrypts data and manages the access policies that decide who can decrypt it, Nautilus for trusted off-chain computation, DeepBook for on-chain liquidity, gasless stablecoin transfers, zkLogin for one-step sign-in with an existing Google or Apple account, and confidential transfers, in public beta on devnet, which shield transaction amounts from public observers while remaining observable to specific parties when required. These components were built to compose with each other. On Ethereum, the equivalents exist as separate third-party projects, often excellent ones, that a developer assembles and trusts individually. The tradeoff is familiar from any platform decision. Ethereum's open ecosystem gives more options and more maturity per component. Sui's integrated stack gives fewer decisions and tighter composability, because the pieces were designed as one system. ## Which one should you build on If your project depends on existing Ethereum DeFi liquidity, needs the largest pool of Solidity developers and audited components, or benefits from the EVM's network effects, Ethereum and its rollups remain the rational choice. The market is large enough for more than one winner, and the builders who know they need the EVM already know it. If your project needs high throughput on the base layer, sub-second deterministic finality, asset safety enforced by the language, gasless stablecoin movement, or an integrated stack you do not have to assemble from parts, Sui was designed for exactly that. For payments, agentic commerce, consumer applications at scale, and anything where base-layer settlement speed decides whether the product feels like software, the architecture is the reason to look closely. ## FAQ **Is Sui faster than Ethereum?**‍ On the base layer, yes. Sui settles transactions in roughly 390 milliseconds with deterministic finality. Ethereum produces blocks about every 12 seconds and reaches full finality in about 15 minutes. Ethereum Layer 2 rollups improve throughput and add their own finality and bridging considerations. **Is Sui cheaper than Ethereum?** The gap has narrowed. Sui averages under $0.02 per transaction and makes stablecoin transfers gasless, so they cost nothing. Ethereum mainnet has fallen to under $0.03 for a basic transfer and around $0.21 for a swap as of May 2026, and Layer 2 fees are a fraction of a cent. Sui's remaining cost advantages are the gasless stablecoin path and the absence of congestion pricing under load. **Why does Sui use Move instead of Solidity?** Move was designed so that assets are resources the type system protects and every asset has explicit ownership through the object model. Many exploit classes that are possible in Solidity cannot be expressed in Move, which makes asset safety a property of the language. **Does Sui need Layer 2s like Ethereum?** No. Sui scales horizontally on the base layer through parallel execution, so it does not rely on rollups. Applications stay on one integrated layer, which keeps composability intact across the whole chain. **How much of Ethereum activity happens on Layer 2s?** About 95 percent of Ethereum transactions run on rollups, with the L1 typically operating below its block target ([ethereum.org](http://ethereum.org), 2026). ## Sources and further reading - Sui architecture, Move, and the object model at [docs.sui.io](https://docs.sui.io) - [Building on Ethereum in 2026](https://ethereum.org/latest/building-on-ethereum-in-2026/), [ethereum.org](http://ethereum.org), for Fusaka, PeerDAS, current gas figures, and the rollup share - [Single slot finality](https://ethereum.org/roadmap/single-slot-finality/), [ethereum.org](http://ethereum.org), for Ethereum's current 15-minute finality and SSF status - [DefiLlama chain TVL](https://defillama.com/chains) for current DeFi totals - [Greater Ecosystem Security Through Audits and Move Registry](https://www.sui.io/blog/security-audits-and-move-registry) and the [Sui Security Expansion Program](https://hackenproof.com/sui-security-expansion) - Sui Dollar, gasless stablecoin transfers, and the Sui Stack at [sui.io/blog](https://www.sui.io/blog)