You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Cardano is an Unspent Transaction Output (UTXO)-based blockchain, which utilizes a different accounting model for its ledger from other account-based blockchains like Ethereum. Cardano implements an innovative Extended Unspent Transaction Output (EUTXO) model to support multi-assets and smart contracts while maintaining the core advantages of the UTXO approach.
10
10
11
+
## Why Accounting Models Matter
12
+
13
+
Before Bitcoin, data structures like linked lists (invented in 1955) could chain together transaction records. What makes blockchains different isn't just chaining data—it's achieving **decentralized consensus** on which chain is valid. Multiple parties with conflicting interests must agree on a single version of transaction history without a central authority.
14
+
15
+
This consensus challenge directly impacts how blockchains represent value and execute transactions. Two fundamentally different approaches emerged: account-based and UTXO-based models.
16
+
17
+
## Account-Based Model: The Familiar Approach
18
+
19
+
Most blockchains like Ethereum use an **account-based model**—the same mental model as traditional banking. Each address maintains a balance that increases and decreases with transactions. When you send 10 ETH, the system updates two account balances simultaneously: subtracting from the sender, adding to the receiver.
20
+
21
+
This model is intuitive because it mirrors how people conceptualize money. However, transactions are **stateful**—they depend on and modify the current global state of all accounts. A transaction's validity and outcome can change based on other transactions processed before it, creating unpredictability between transaction creation and execution.
22
+
23
+
24
+
*Cardano's EUTXO model represents assets as a directed graph of unspent outputs, while account-based blockchains maintain a database of account balances that update with each state transition.*
25
+
11
26
## Understanding the UTXO Foundation
12
27
13
28
In a UTXO model, the movement of assets is recorded as a directed graph where transactions consume some UTXOs and create new ones. Think of UTXOs like physical cash - if you have $50, it might be composed of different bill combinations, but the total remains the same. Similarly, your wallet balance is the sum of all unspent UTXOs from previous transactions.
@@ -16,7 +31,41 @@ In a UTXO model, the movement of assets is recorded as a directed graph where tr
16
31
17
32
**Transaction inputs** reference previous outputs using this unique identifier: the transaction hash and output index. To spend an input, you must provide witnesses (signatures or script validations) that satisfy the spending conditions.
18
33
19
-
Each UTXO can only be consumed once and as a whole which introduces the concept of 'change', just like cash transactions where you can't split a bill into smaller pieces.
34
+
Each UTXO must be consumed completely in an "all-or-nothing" manner, introducing the concept of 'change' similar to cash transactions where you can't split a bill into smaller pieces.
*A transaction consumes existing UTXOs as inputs and creates new UTXOs as outputs. The consumed UTXOs are removed from the UTXO set, while the new outputs become available for future transactions.*
38
+
39
+
### Example: Alice Sends Bob 10 ADA
40
+
41
+
Let's make this concrete. Say Alice has a single UTXO worth 100 ADA and wants to send Bob 10 ADA.
42
+
43
+
44
+
45
+
Alice's transaction must:
46
+
1.**Consume** her entire 100 ADA UTXO as input (all-or-nothing)
47
+
2.**Create** two new outputs:
48
+
- 10 ADA to Bob's address
49
+
- 90 ADA back to Alice's address as "change"
50
+
51
+
After this transaction executes, the UTXO set contains:
52
+
- Alice: 90 ADA (new UTXO)
53
+
- Bob: 10 ADA (new UTXO)
54
+
- Alice's original 100 ADA UTXO: **spent** (removed from UTXO set forever)
55
+
56
+
### Combining Multiple UTXOs
57
+
58
+
Now suppose Bob has two UTXOs (his original 50 ADA plus the 10 ADA from Alice) and wants to send Charlie 55 ADA. Neither UTXO alone is sufficient.
1.**Consume** both his 50 ADA and 10 ADA UTXOs as inputs
64
+
2.**Create** two new outputs:
65
+
- 55 ADA to Charlie's address
66
+
- 5 ADA back to Bob's address as change
67
+
68
+
This demonstrates how UTXOs can be combined to meet transaction requirements, with any remainder returned as change.
20
69
21
70
## Atomic Transactions and Genesis Bootstrap
22
71
@@ -43,24 +92,49 @@ The EUTXO model combines:
43
92
- Redeemers: User-supplied arguments passed to scripts during validation
44
93
- Context: Transaction information available to scripts during validation
45
94
95
+
96
+
*In EUTXO, spending conditions are defined by scripts rather than simple signatures. The transaction provides a redeemer (arbitrary data) that the script validates against the datum and transaction context.*
Deep dive into [Cardano's EUTXO accounting model here](https://ucarecdn.com/3da33f2f-73ac-4c9b-844b-f215dcce0628/EUTXOhandbook_for_EC.pdf).
50
102
:::
51
103
104
+
### Script Validation: Bitcoin vs Ethereum vs Cardano
105
+
106
+
The scope of information available to validator scripts fundamentally differs across blockchain models:
107
+
108
+
**Bitcoin (UTXO)**: Scripts can only see the redeemer (the signature/unlocking data). This makes validation simple and secure but severely limits smart contract capabilities—hence "dumb contracts."
109
+
110
+
**Ethereum (Account-Based)**: Scripts can see and modify the entire blockchain state. This unlimited access enables powerful contracts but introduces security complexity and unpredictability.
111
+
112
+
**Cardano (EUTXO)**: Scripts can see all inputs and outputs of the specific transaction, plus contextual information—but not arbitrary global state. This middle ground has been mathematically proven to provide equivalent computational power to Ethereum while maintaining stronger security guarantees.
113
+
114
+
### Plutus Script Purity
115
+
116
+
Plutus scripts are **pure functions**: given identical inputs (datum, redeemer, script context), they always produce identical outputs. This purity enables:
117
+
118
+
**Mathematical Security Proofs**: You can prove a script is secure by analyzing the transaction inputs alone, not the entire unpredictable blockchain state. The limited scope makes comprehensive security analysis tractable.
119
+
120
+
**Fail-Fast Validation**: If a transaction references an already-spent input, validation fails immediately off-chain before reaching the network—costing you nothing. The script's deterministic nature allows complete local validation.
121
+
122
+
**No Partial Failures**: Unlike account-based systems where a transaction can fail mid-execution (after consuming gas fees), EUTXO transactions are validated atomically. Either all conditions are met and the transaction succeeds, or it fails completely without cost.
123
+
52
124
## eUTxO Advantages for Developers
53
125
54
126
**Parallelization**: Transactions can be processed in parallel as long as they don't consume the same inputs, offering superior scalability. The level of concurrency is limited only by the degree of contention for shared UTXOs.
55
127
56
128
**Local State**: Unlike account-based models where every transaction affects global state, EUTXO validation occurs locally, preventing many classes of errors and attacks.
57
129
58
-
**Predictable Fees**: Transaction costs can be calculated precisely off-chain before submission. Unlike other blockchains where network activity can influence gas costs, Cardano's fees are deterministic and fixed at transaction creation time.
130
+
**Predictable Fees**: Transaction costs can be calculated precisely off-chain before submission. Cardano's fees are deterministic and fixed at transaction creation time—no surprises from network congestion or gas price spikes. Critically, if a transaction is invalid (e.g., an input was already spent), it fails validation off-chain before submission, costing you nothing. This contrasts sharply with account-based models where you pay fees even for failed transactions, and gas costs fluctuate unpredictably based on network activity.
59
131
60
-
**Deterministic Validation**: Transaction success depends only on the transaction itself and its inputs. Users can predict locally (off-chain) how their transaction will impact the ledger state without encountering unexpected validation failures, fees, or state updates. If inputs are available when validated, the transaction is guaranteed to succeed. This contrasts with account-based models, where a transaction can fail mid-script execution.
132
+
**Deterministic Validation**: UTXO transactions are **stateless**—they explicitly include all inputs and outputs within the transaction itself. Validity depends solely on the transaction and its referenced UTXOs, not on external blockchain state that might change. This means if the UTXOs are unspent when your transaction is validated, it is guaranteed to succeed. The transaction's effect is fully determined at creation time. By contrast, account-based transactions are **stateful**—they depend on current account balances that can change between transaction creation and execution. A stateful transaction might fail mid-execution even if it appeared valid when created, and you still pay fees for the failed attempt.
61
133
62
134
**Zero-Knowledge Proof Compatibility**: EUTXO's deterministic nature makes it ideal for zero-knowledge scaling solutions. Since transaction outcomes are deterministic and predictable, you can execute complex computations off-chain and generate proofs against known state. The proof can then be verified on-chain without re-executing the computation. This contrasts with account-based models where global state changes unpredictably, making it difficult to construct valid ZK proofs since the state may change between proof generation and verification.
63
135
136
+
**Enhanced Privacy**: The UTXO model naturally encourages privacy-preserving behavior. Best practice is to generate a new address for each incoming transaction, including change addresses. Since your balance is distributed across discrete UTXOs at different addresses rather than consolidated in a single account, it becomes significantly harder to link multiple transactions to a single owner. Account-based models inherently encourage address reuse—the account itself links all transactions together, making transaction history trivially traceable to one entity.
137
+
64
138
## TPS vs. eUTxO
65
139
66
140
Which is better, high transactions per second or eUTxO?
0 commit comments