Object-centric Execution (Sui) vs Account-based (Ethereum): Which Model Powers Faster DeFi?

Key Takeaways

• Sui’s object-centric model treats every asset as an independent object, enabling parallel processing that can handle over 297,000 transactions per second with sub-second finality.
• Ethereum’s account-based model processes transactions sequentially, which creates bottlenecks during high demand and has historically caused gas fees to spike above $70 during network congestion.
• Parallel execution in Sui allows unrelated DeFi transactions to process simultaneously, meaning DEX trades, NFT mints, and payments can all happen at once without competing for block space.
• Ethereum’s sequential processing ensures state consistency but requires each transaction to complete before the next begins, limiting throughput to around 15-25 transactions per second on the base layer.
• For DeFi applications, Sui’s model reduces latency and costs while Ethereum relies heavily on Layer 2 solutions like Arbitrum and Optimism to achieve similar scalability improvements.

Sui’s object-centric execution model enables parallel transaction processing by treating each asset as an independent object, while Ethereum’s account-based model processes transactions sequentially to maintain global state consistency. This fundamental architectural difference impacts transaction speed, costs, and scalability for DeFi applications.

Understanding the Object-centric Model in Sui

The object-centric execution model represents a fundamental shift in how blockchains handle data and transactions. Instead of maintaining a global state where all information lives in one interconnected ledger, Sui treats every asset as a distinct, independent object with its own owner and properties.

Think of it like the difference between a shared Google Doc where everyone edits the same document sequentially versus individual Word files where multiple people can work on separate documents at the same time. Sui’s approach allows the network to process transactions in parallel when they don’t interact with the same objects, dramatically increasing throughput and reducing wait times.

How Objects Work in Sui’s Architecture

Each object in Sui exists independently with unique identifiers and ownership metadata. When you own an NFT or hold coins in Sui, you’re directly controlling objects on the blockchain rather than updating a balance in an account. These objects can be owned by individuals, shared among multiple users, or immutable.

The Move programming language powering Sui enforces strict rules about object ownership and capabilities. Objects have specific abilities including key (unique identification), store (allowing hierarchical ownership), copy (controlled duplication), and drop (proper disposal). These built-in safeguards prevent common security issues like double-spending while enabling complex asset management.

Validators can determine which transactions affect which objects before execution begins. This clear separation allows Sui to process non-overlapping transactions simultaneously across multiple validation threads, achieving throughput rates that would be impossible with sequential processing.

Parallel Execution Explained

Parallel execution means that independent transactions can be processed at the same time without waiting for each other to complete. When Alice sends coins to Bob while Carol trades on a DEX and Dave mints an NFT, all three transactions can execute simultaneously because they involve completely different objects.

Sui’s validators can dynamically allocate more computational power to handle transaction loads during peak activity. The network processed over 297,000 transactions per second during testing with just 390 milliseconds of latency. These numbers represent a ten-fold improvement over most competing networks.

Not all transactions can be parallelized, however. When multiple transactions need to modify the same shared object—like trading against the same liquidity pool—those must be processed sequentially to prevent conflicts. Smart contract developers on Sui optimize for parallelism by minimizing shared objects and maximizing owned objects in their application design.

How Ethereum’s Account-based Model Functions

Ethereum pioneered the account-based model for smart contract platforms, choosing simplicity and flexibility over the UTXO model used by Bitcoin. In this architecture, the blockchain maintains a global state where every account stores its balance and associated data.

Accounts come in two types: externally owned accounts controlled by private keys and contract accounts that execute code. When you check your ETH balance, you’re viewing a number stored in your account within Ethereum’s global ledger. Every transaction modifies this shared state, updating balances and smart contract storage.

Sequential Transaction Processing

Ethereum processes transactions one after another in a strict sequence determined by nonces and gas prices. Each transaction must fully complete and update the global state before the next transaction begins execution. This sequential approach ensures state consistency and prevents race conditions where multiple transactions might try to spend the same funds.

The Ethereum Virtual Machine executes transactions sequentially even when they’re completely independent. If Alice sends ETH to Bob while Carol trades on Uniswap, these unrelated transactions still queue up and process one at a time. This fundamental limitation constrains Ethereum’s base layer to approximately 15-25 transactions per second.

During the 2021 bull run, sequential processing combined with massive demand caused transaction fees to exceed $150 during peak congestion. Users competed for limited block space by bidding up gas prices, making small transactions economically unfeasible. Even in 2024, gas fees spiked to 70 gwei during periods of high activity related to new token launches and DeFi trading.

Why Ethereum Chose Sequential Processing

Sequential execution simplifies smart contract development and interaction. Developers can write contracts assuming they operate on a single, consistent global state without worrying about concurrent execution conflicts. This makes it easier to build complex DeFi protocols where contracts call other contracts within the same transaction.

The model also ensures predictable behavior. When you submit a transaction, you know exactly what state the blockchain is in at that moment. Every validator processes transactions in the same order, reaching consensus on the resulting state changes. This determinism is crucial for financial applications where precision matters.

Ethereum’s design prioritized supporting arbitrary state and code over raw transaction throughput. The network needs to handle everything from simple transfers to complex multi-contract interactions in decentralized exchanges, lending protocols, and governance systems. Sequential processing provides the reliability these applications require, even at the cost of scalability.

Comparing Scalability and Performance

The performance gap between these models becomes most apparent during periods of high network activity. Sui’s architecture allows it to scale horizontally by adding more validation workers, while Ethereum’s sequential model creates inherent throughput limits regardless of validator hardware.

Real-World Performance Implications

Sui’s DeFi ecosystem grew to over $2 billion in total value locked by early 2025, with trading volumes reaching $44.3 billion in Q4 2024 alone. This rapid growth occurred without the gas fee spikes that typically accompany increased activity on Ethereum. The network maintained low fees and fast confirmations even as usage surged.

Ethereum relies on Layer 2 solutions to achieve comparable performance. Networks like Arbitrum and Optimism process transactions off-chain then submit batches to the mainnet, reducing costs to around $0.01 per transaction. However, these solutions add complexity for users and developers while cannibalizing base layer revenue. Since the March 2024 Dencun upgrade, Ethereum’s mainnet fee revenue dropped 99% as activity migrated to Layer 2s.

The trade-off involves more than just speed and cost. Sui’s model requires developers to think about parallelization and object design upfront. Applications that rely heavily on shared objects may not achieve the full performance benefits. Ethereum’s sequential model provides simpler development patterns but pushes scalability solutions to additional layers.

DeFi Applications and Use Cases

The architectural differences between Sui and Ethereum create distinct advantages for different types of decentralized finance applications. Understanding these strengths helps developers choose the right platform and users select optimal networks for their activities.

Where Sui’s Model Excels

Decentralized exchanges on Sui can process trades with near-instant finality and minimal fees, making them competitive with centralized exchanges. Cetus, Sui’s largest DEX, evolved from $170 million to $213 million in total value locked during Q4 2024, with quarterly volume reaching $17.3 billion. The platform’s ability to handle high-frequency trading without congestion gives it advantages over traditional AMMs on Ethereum.

NFT marketplaces benefit enormously from parallel execution. During an NFT mint event, thousands of users trying to claim assets simultaneously don’t impact other network activities. Regular payment transactions and DeFi operations continue unaffected while the mint processes in parallel. This eliminates the “gas wars” common on Ethereum where users compete by paying excessive fees to ensure their transactions go through.

Lending protocols like Suilend more than doubled their TVL from $222 million to $519 million in late 2024, becoming one of the fastest-growing lending platforms across all networks. The protocol can process loan originations, liquidations, and interest calculations simultaneously for different users without creating bottlenecks. This enables more responsive liquidation mechanisms during volatile market conditions.

Ethereum’s Strengths for Complex DeFi

Ethereum’s global state model simplifies interactions between multiple protocols within single transactions. Flash loans, a DeFi innovation where users borrow massive amounts without collateral and repay within the same transaction, rely on Ethereum’s ability to guarantee atomic execution across multiple smart contract calls.

Complex yield farming strategies that involve depositing to one protocol, using receipt tokens as collateral elsewhere, and compounding rewards across multiple platforms work seamlessly on Ethereum. The sequential execution guarantees that all steps either complete successfully or fail together, protecting users from partial execution risks.

Established DeFi protocols like Uniswap, Aave, and Curve have billions in liquidity and years of battle-tested code on Ethereum. These platforms process transactions reliably despite higher costs, and users trust them with significant capital. The network effects and liquidity depth on Ethereum remain unmatched, even as newer platforms offer better performance metrics.

Gaming and Interactive Applications

Blockchain gaming demands rapid transaction processing and low latency for in-game actions. Sui’s architecture allows players to trade items, upgrade characters, and complete quests without waiting for block confirmations or paying prohibitive fees. Multiple players can interact with different game assets simultaneously without blocking each other’s transactions.

Ethereum-based games typically process game logic off-chain and only record final states or valuable assets on-chain due to cost and speed limitations. This hybrid approach works but requires trusted intermediaries for the off-chain components, reducing decentralization benefits.

Developer Experience and Smart Contract Development

Building on Sui requires developers to adopt a different mental model focused on objects and ownership. The Move language prevents common security issues like reentrancy attacks and resource duplication through its type system. Assets cannot be accidentally lost or copied because the language enforces explicit handling of every object.

Ethereum offers a mature development ecosystem with extensive documentation, auditing services, and deployment tools. Solidity has a larger developer community and more educational resources. However, developers must carefully implement security patterns to prevent vulnerabilities that the language doesn’t prevent by default.

Optimizing for Each Platform

Sui developers maximize performance by designing applications around owned objects rather than shared state. A well-designed Sui application might allow each user to own their trading account object, enabling parallel order processing. Only the shared liquidity pool object requires sequential access when trades execute.

Ethereum developers optimize gas costs by minimizing storage operations and computation complexity. They batch operations when possible and leverage Layer 2s for high-frequency interactions. The focus is on making each transaction as efficient as possible since sequential processing inherently limits throughput.

Security Considerations

Both execution models provide security through different mechanisms, and understanding these trade-offs helps assess risks for DeFi applications and user funds.

Sui’s Security Model

The Move programming language provides memory safety and asset ownership guarantees at the language level. Resources cannot be copied or destroyed implicitly, preventing entire categories of bugs. When you own an object in Sui, the blockchain enforces that only you can transfer or modify it based on the object’s defined capabilities.

Parallel execution introduces new considerations around transaction ordering for shared objects. Developers must carefully design applications to avoid race conditions when multiple transactions might access shared state. The transparency of object declarations helps auditors verify correct usage patterns.

Sui’s consensus mechanism and object versioning ensure that even with parallel execution, the network reaches agreement on the final state. Byzantine fault tolerance protects against malicious validators, while cryptographic proofs verify object ownership and transaction validity.

Ethereum’s Battle-Tested Security

Ethereum’s sequential execution model eliminates certain concurrency issues but requires careful attention to reentrancy and other smart contract vulnerabilities. The platform has processed trillions in transaction value over years of operation, revealing and patching numerous security issues through real-world usage.

Extensive auditing infrastructure exists for Ethereum smart contracts, with firms specializing in identifying vulnerabilities before deployment. Formal verification tools help prove contract behavior matches specifications. This mature security ecosystem provides confidence despite the language’s complexity.

The global state model means contract interactions are transparent and predictable. Developers and auditors can trace exactly how contracts call each other and modify state. This auditability is crucial for high-value DeFi protocols handling billions in assets.

Case Study: DeFi Protocol Migration

Cetus Protocol launched on both Sui and Aptos blockchains, providing direct comparison data for object-centric versus account-based architectures. On Sui, the DEX achieved quarterly trading volume of $17.3 billion with minimal fee spikes during high activity. The protocol’s TVL grew consistently as users discovered they could execute complex trades during volatile markets without competing for block space through gas bidding.

Suilend’s lending protocol demonstrated how parallel execution enables responsive liquidation mechanisms that protect lenders. When collateral values dropped suddenly during market volatility, the protocol could process multiple simultaneous liquidations without congestion delays. This prevented the cascade failures that occasionally impact over-extended lending platforms on congested networks.

The Future of Blockchain Execution Models

Both Sui and Ethereum continue evolving their execution models to address current limitations. Ethereum’s roadmap includes sharding and further Layer 2 development to increase effective throughput. Research into parallelization within the EVM explores ways to execute independent transactions concurrently while maintaining sequential guarantees for dependent operations.

Sui focuses on refining its object model and expanding developer tools to make parallel execution more accessible. The network’s ability to scale horizontally by adding validator capacity provides a clear path to handling increased demand without fundamental architecture changes.

The emergence of hybrid approaches suggests future blockchains may combine elements from both models. Some Layer 2 solutions experiment with UTXO-like structures for improved parallelization while maintaining EVM compatibility. Understanding the trade-offs between object-centric and account-based execution helps evaluate these emerging architectures.

Conclusion

The choice between Sui’s object-centric model and Ethereum’s account-based approach reflects fundamental trade-offs in blockchain design. Sui delivers superior throughput and lower costs through parallel execution, making it ideal for DeFi applications requiring speed and efficiency. Ethereum provides battle-tested security, extensive developer resources, and deep liquidity through its sequential execution model and mature ecosystem. For developers building new DeFi protocols, evaluate whether your application’s performance needs justify learning Sui’s object model or whether Ethereum’s established infrastructure better serves your users. For DeFi participants, understanding these architectural differences helps you choose platforms that align with your priorities for cost, speed, and security.

Sui Object Model vs Account FAQs

What is the main difference between Sui’s object model and Ethereum’s account model?

Sui’s object model treats every asset as an independent object that can be processed in parallel with other unrelated transactions, while Ethereum’s account model maintains a global state where all transactions process sequentially to ensure consistency.

Why can Sui process transactions faster than Ethereum?

Sui processes transactions faster because its object-centric architecture allows unrelated transactions to execute simultaneously across multiple threads, achieving over 297,000 TPS compared to Ethereum’s 15-25 TPS sequential processing on the base layer.

Does Sui object model vs account model affect DeFi transaction costs?

Yes, the Sui object model significantly reduces transaction costs because parallel execution eliminates congestion-based fee spikes, with typical fees around $0.001-0.002 versus Ethereum’s fees that can exceed $70 during high network demand.

Can all transactions on Sui run in parallel?

No, transactions involving the same shared objects must execute sequentially to prevent conflicts, but transactions affecting different objects can process simultaneously, allowing most DeFi operations to benefit from parallelization.

Is Ethereum’s account model better for complex DeFi applications?

Ethereum’s account model simplifies certain complex DeFi operations like flash loans and multi-protocol interactions within single atomic transactions, though Sui’s growing ecosystem increasingly supports similar functionality through its object model.

Sui Object Model vs Account Citations

1. Sui Documentation – Comparison | Sui Documentation. Available at: https://docs.sui.io/sui-compared
2. Sui Blog – All About Parallelization. Available at: https://blog.sui.io/parallelization-explained/
3. Medium – Fundamentals of Parallelizing Smart Contract Execution by Rez. Available at: https://medium.com/@0xZorz/fundamentals-of-parallelising-smart-contract-execution-8e75694697c3
4. Nervos – Parallel vs Sequential Transaction Execution in Blockchain. Available at: https://www.nervos.org/knowledge-base/The_Difference_Between_Parallel_and_Sequential_Transaction_Execution_in_Crypto_(explainCKBot)
5. arXiv – Accelerating Blockchain Scalability: New Models for Parallel Transaction Execution in the EVM. Available at: https://arxiv.org/html/2504.01370v1
6. Stakin – Sui Blockchain: A Deep Dive. Available at: https://stakin.com/blog/sui-blockchain-a-deep-dive
7. Stakin – Tipping Point: Exploring The Amazing Progress of Sui’s DeFi Ecosystem. Available at: https://stakin.com/blog/exploring-the-amazing-progress-of-suis-defi-ecosystem
8. Kraken Learn – What is Sui Network? Available at: https://www.kraken.com/learn/what-is-sui-network-sui
9. Crypto Daily – Ethereum Gas Fees in 2024: What’s Driving the Recent Surge? Available at: https://cryptodaily.co.uk/2025/01/ethereum-gas-fees-in-2024-whats-driving-the-recent-surge
10. QuickNode – What is Sui (SUI)? A Comprehensive Guide to Web3 Scalability. Available at: https://blog.quicknode.com/what-is-sui-a-comprehensive-guide-to-web3-scalability/