UTXO Model

The Unspent Transaction Output (UTXO) model is a blockchain accounting paradigm where the ledger state is represented as a set of discrete, unspent transaction outputs. Unlike an account-based model that tracks balances, the UTXO model treats cryptocurrency not as an account balance but as a collection of individual, chainable coins or notes. Each UTXO is an immutable record specifying an amount of cryptocurrency and the cryptographic condition (typically a digital signature) required to spend it. A transaction in this model consumes one or more existing UTXOs as inputs and creates one or more new UTXOs as outputs, which then become available for future transactions.

The model's architecture provides several core technical benefits. It enables parallel transaction processing, as unrelated UTXOs can be validated independently. It offers strong privacy through pseudonymous addresses and the potential for coin mixing. Most importantly, it provides a simple, deterministic mechanism for double-spend prevention: a UTXO, once spent, is permanently removed from the set of unspent outputs, and any attempt to spend it again will be rejected by the network's consensus rules. This state transition logic is inherently verifiable, making it efficient for lightweight clients using Simplified Payment Verification (SPV).

Contrasting with the account model used by Ethereum and similar networks highlights key differences. In an account model, global state stores each account's balance, which is directly debited and credited. The UTXO model, however, has no inherent concept of an account; "balances" are calculated by summing all UTXOs locked to a user's addresses. This makes the UTXO model inherently stateless for validation, as nodes only need to check the existence and validity of the referenced inputs, not the entire historical state. Prominent implementations include Bitcoin, Litecoin, and Cardano's Extended UTXO (EUTXO) model, which adds smart contract capabilities.

The Unspent Transaction Output (UTXO) model is a fundamental accounting system used by blockchains like Bitcoin to track ownership of the native cryptocurrency. In this model, the total supply of coins is not stored in account balances but is instead represented as a distributed set of discrete, unspent transaction outputs. Each UTXO is an indivisible chunk of cryptocurrency, created as the output of a previous transaction, which can be spent in its entirety as an input to a new transaction. This creates a chain of ownership where the validity of a new transaction is verified by proving control over the referenced UTXOs, ensuring that each unit of value is spent only once.

A UTXO-based transaction works by consuming existing UTXOs as inputs and creating new UTXOs as outputs. For example, if Alice wants to send 0.6 BTC to Bob and she owns a single UTXO worth 1.0 BTC, her transaction will specify that UTXO as an input. The transaction will then create two new outputs: one for 0.6 BTC locked to Bob's public key (the payment) and one for 0.4 BTC locked back to her own key (the change). The network nodes validate this by checking that Alice's signature authorizes spending the input and that the total value of the new outputs does not exceed the value of the inputs, with any difference becoming the transaction fee paid to the miner.

This model provides several key advantages. Its stateless verification allows nodes to validate transactions in isolation by simply checking the cryptographic proofs and the history of the specific UTXOs being spent, without needing the global state of all accounts. This enhances security and parallelism. Furthermore, the model inherently prevents double-spending, as a UTXO is destroyed upon being used as an input and cannot be referenced again. The entire set of UTXOs, known as the UTXO set, represents the current state of the blockchain and is constantly updated as new blocks are added, providing a clear and auditable ledger of ownership.

The UTXO (Unspent Transaction Output) model is a ledger accounting method where the blockchain's state is represented not by account balances, but as a set of discrete, unspent transaction outputs, each acting as a unique, spendable piece of digital currency. In this system, a transaction consumes one or more existing UTXOs as inputs and creates one or more new UTXOs as outputs, which then become available for future spending. This creates a verifiable chain of ownership, as each output can be cryptographically traced back to its creation. Unlike the account-based model used by Ethereum, there is no persistent global state for an address; its "balance" is the sum of all UTXOs it can currently unlock with its private key.

Implementing smart contracts within this discrete-output paradigm requires a different architectural approach. Instead of storing contract code and mutable state at a single address, UTXO-based smart contract platforms treat contracts as validators. A contract is defined by a spending condition (a script, like Bitcoin's Script or Cardano's Plutus) attached to a specific UTXO. To interact with the contract, a new transaction must reference that UTXO as an input and provide the necessary data and signatures to satisfy the script's logic. The contract's "state" can be encoded within the data of the UTXO itself or in subsequent outputs it creates, enabling complex, multi-step applications through a sequence of discrete transactions.

This model offers distinct advantages, including inherent parallelism—since unrelated UTXOs can be processed simultaneously—and strong privacy through mechanisms like CoinJoin. However, it also introduces challenges for developers accustomed to the persistent-state model. Managing off-chain state and oracle data requires careful design, as each contract interaction is a discrete event. Leading implementations include Cardano's Extended UTXO (EUTXO) model, which adds datum fields and native tokens, and Stacks, which brings Turing-complete Clarity smart contracts to Bitcoin via a layer-1 blockchain that reads the Bitcoin UTXO set.