Two Blockchain Models: Why Ergo Chose Differently
Ergo's transaction model is designed for more predictable, lower-risk, and more privacy-friendly (when used with appropriate patterns) blockchain operations than EVM platforms.
TL;DR
Transaction Models Matter
How blockchains track ownership affects reliability, security, and risk factors. Two paradigms: eUTXO vs Account.
eUTXO: Specific Outputs
Like cash payments - transactions move specific 'boxes' with attached logic. Deterministic and predictable execution.
Account: Global State
Like bank accounts - simple balance updates on shared ledger. Powerful composability but shared risks.
Security Trade-offs
eUTXO reduces cross-contract interference and re-entrancy risks. Account model increases attack surface.
Philosophy: Safety First
Ergo chose predictability over flexibility. 'Don't trust, verify' - eliminate vulnerability classes at platform level.
Blockchains come in all different forms, and use different approaches to record transactions and update state trustlessly. The specific transaction model can have far-reaching implications for the way the blockchain operates, its reliability, and risk factors.
Two of the most influential blockchain architectures are Ergo's eUTXO model and Ethereum's account model. These represent fundamentally different ways of managing transactions and smart contracts. Understanding their differences helps explain why and how Ergo takes a distinctive approach to scalability, security, and decentralized finance.
At present, the largest other eUTXO-based blockchain besides Ergo is Cardano.
📊 What Is A Transaction Model In Blockchain?
A blockchain's transaction model keeps track of who owns what. It's the way that the blockchain does its accounting, recording user balances and transfers.
Bitcoin, the first blockchain platform, used the UTXO or "Unspent Transaction Output" model. In this approach, users transact by moving specific "outputs", or bundles of coins. A bundle belongs to one user, and the transaction "consumes" it by cryptographically registering it to the recipient. Where necessary, the bundle is split into two, and the change is registered back to the sender.
You can think of it a bit like paying in cash. When you pay $11.43, you can do so in different ways, but it involves handing over specific coins and notes. For example, you might pay with a ten-dollar bill, a one dollar coin, four dimes, and three pennies. There are many other ways to make up the amount; you could even pay with 1,143 pennies. Often, you won't have the right change, so you might pay with a $10 and $5 bill, and receive $3.57 in coins back.
On the Bitcoin blockchain, of course, you're moving chunks of Satoshis, but the principle is the same. You're spending bundles of coins that have been registered to your address in previous transactions.
Cash vs Card analogy: UTXO is like paying with specific bills and coins (moving exact outputs), while Account model is like a digital card payment (simple balance deduction).
This is very different from the Account model, used by most other blockchains. In this case, it's more like a bank account or a tab in a digital ledger. Let's say you pay by card instead of cash. Your account starts with $154 in it, and the transaction simply deducts $11.43, leaving $142.57.
These two different transaction models have big implications for blockchain state and security.
🏦 Ethereum's Account Model Explained
Ethereum is the best-known example of the Account-based model described above. It records account balances and contract states like a bank account.
Ethereum has two types of accounts: Externally-Owned Accounts (EOAs), and smart contract accounts. EOAs are regular user accounts controlled by a private key, while smart contracts are controlled by code. Account balance and state are simply updated as required when transactions are made. It's a very straightforward and intuitive approach, and allows Ethereum to support complex logic and decentralized applications of all kinds, on-chain.
All of this makes Ethereum very powerful and composable. Smart contracts can easily interact with one another, so developers can plug their code into existing dApps and build on the existing ecosystem easily.
The catch: All accounts share a global, mutable state. The blockchain is a bit like a single, shared spreadsheet, where every cell represents a different account. It's simple to edit and link to other cells, but it becomes harder to manage when hundreds or thousands of people are trying to change it at the same time.
Transactions can interfere with one another, and parallel execution can introduce serious problems. For example, a re-entrancy attack is a type of exploit where a malicious smart contract repeatedly calls a function in a vulnerable contract before the initial function call is finished and the contract's state is updated. This allows the attacker to drain the vulnerable contract of its funds, or manipulate its state in other unintended ways.
(To its credit, the Ethereum ecosystem uses patterns and tools like checks-effects-interactions, reentrancy guards, and formal verification to mitigate such classes of bugs.) The global shared state can also increase computational costs, limiting scalability and increasing gas costs.
In short, Ethereum's Account model is powerful, but its flexibility also introduces vulnerabilities.
📦 Ergo's eUTXO Model Explained
Ergo takes a completely different approach. Its eUTXO (extended UTXO) transaction model is derived from Bitcoin's approach.
Bitcoin simply registers UTXOs to different users, updating the ledger to reflect changes to ownership when a transaction is made. While this may seem complicated, it's actually a very clean approach that allows for no ambiguity: each UTXO has precisely one owner at any given time. Ownership of UTXOs can be traced right back through the entire history of the blockchain to the point where they were mined into existence.
Ergo's eUTXO model extends Bitcoin's UTXOs with additional functionality. UTXOs can have data and programming logic attached to them.
Instead of updating global state, as with Ethereum and other Account-based platforms, Ergo smart contracts instead reference specific outputs. This means execution is deterministic, clean, and predictable. Parallelism is safe when transactions spend disjoint boxes; if two transactions try to spend the same box, that specific conflict is serialized/invalidated without impacting unrelated activity.
Analogy: Imagine that you have laid out a hundred $100 bills on a table, and told 100 people they can each take one. You can either tell everyone they can take any $100 bill (though just one), or tell each person they can take a specific, numbered $100 bill. The second option is a little more complicated to organize, but results in a much more orderly and predictable set of transfers!
That's why Ergo's eUTXO model has such significant benefits for security, scalability, and auditability. It also works seamlessly with Ergo's Sigma protocols and privacy features.
| Feature | eUTXO (Ergo) | Account (Ethereum) |
|---|---|---|
| Structure | Based on individual outputs | Single, global account state |
| Contract execution | Deterministic; parallel when boxes are disjoint | "Stateful", generally sequential on shared state |
| Security | Isolated spends reduce cross-contract interference | Shared state increases risk surface |
| Scalability | Easier horizontal scaling via locality of state | Limited by shared global state contention |
| Privacy | More granular control; patterns with Σ-protocols | Transparent by default |
| Composability | Modular and predictable (explicit wiring via boxes and off-chain builders) | Highly composable, but riskier due to tight coupling |
Key takeaway: It's important to recognize that both the eUTXO and the Account model have strengths and weaknesses. Broadly speaking, Ethereum offers greater flexibility, while Ergo emphasizes predictability and security.
🎯 Why Ergo Chose The eUTXO Model
Blockchain developers face a tension between launching new features to compete with other platforms, on the one hand, and safeguarding users' funds, on the other. Countless blockchain networks and dApps have discovered the risks of "moving fast and breaking things" (Facebook's one-time motto).
Ergo's design philosophy has always been to take the long-term view. Every decision and update made to the Ergo blockchain is based on academic research, ensuring the best possible foundations for a secure and sustainable ecosystem.
Ergo takes Bitcoin's beaten-in security model and extends that approach to offer Ethereum-like functionality, without introducing the same degree of shared-state drawbacks and vulnerabilities of the Account-based system. Ergo's developers have prioritized predictable execution for dApps, even if that means taking slightly longer to bring updates to market.
"Don't trust, verify": This decision is part of the core ethos of Ergo, and is simply an extension of the crypto principle "Don't trust, verify". It is best that dApps should run safely and securely because the underlying platform minimizes or eliminates entire classes of vulnerabilities, rather than seeking to mitigate each possible exploit for every dApp.
✨ Conclusion
Ergo's eUTXO vs Ethereum's Account model gets to the heart of why Ergo is different to other blockchain platforms. It's not just a technical difference, but a philosophical one. The trade-off is flexibility vs determinism.
Ethereum may offer simpler dApp design and powerful composability through its shared global state, but that easy versatility can come with additional risk.
By extending Bitcoin's UTXO model to support advanced smart contracts, Ergo offers a pathway towards scalable, secure, and privacy-preserving decentralized applications built on solid cryptographic foundations.
Frequently Asked Questions
Share this post
Help spread the word about Ergo's eUTXO model