The account model is a way of designing a blockchain ledger in which the network keeps a running record of every account and its current balance, much as a bank keeps a balance for each customer. A transaction simply debits one account and credits another, and the network updates both entries. Ethereum is the best-known chain built this way, and many later networks, including BNB Smart Chain, Solana, Tron, Tezos and Algorand, also use accounts as the basic unit of their ledger.
It is usually contrasted with the unspent transaction output (UTXO) model used by Bitcoin, in which there are no stored balances at all, only a set of discrete coins that are consumed and created by each transaction. The choice between the two affects how smart contracts are written, how transactions are protected against replay, how easily a chain can process work in parallel and how much privacy users have.
How the account model works
In an account-based chain, the network maintains a "world state": a mapping from every address to a small record of data. On Ethereum each account record holds four fields: a balance, a nonce, a storage root and a code hash. The state is organised in a Merkle Patricia trie, a variant of the Merkle Tree, so that a single root hash in each block header commits to the entire state and any account's data can be proven against it.
Ethereum distinguishes two kinds of account:
- Externally owned accounts. An externally owned account is controlled by a private key and can start transactions by signing them.
- Contract accounts. A contract account holds code and its own storage, and runs only when a transaction or another contract calls it.
When a transaction is included in a block, the Ethereum Virtual Machine executes it against the current state, deducts the fee, applies the transfer or contract logic and writes the new state. The fee is paid in gas, which caps how much computation a transaction can consume.
Nonces and replay protection
Because a balance can be spent many times, the account model needs a way to stop the same signed transaction being submitted twice. Each externally owned account therefore carries a nonce, a counter that starts at zero and rises by one with every transaction the account sends. A transaction is valid only if its nonce equals the account's current nonce, so a copied transaction is rejected once the original has been processed. This blocks a replay attack within the same chain; protection across different chains relies on a chain identifier included in the signed data.
The nonce also forces an account's transactions to be processed strictly in order. If a transaction with a low nonce is stuck because its fee is too low, every later transaction from that account waits behind it, a problem often reported as a nonce error in wallets.
Comparison with the UTXO model
| Feature | Account model | UTXO model |
|---|---|---|
| What the ledger stores | Balances and state per address | A set of unspent coins |
| Replay protection | Account nonce | Each output can be spent only once |
| Smart contracts | Natural fit for shared, changing state | Harder; state must be carried in outputs |
| Transaction size | Usually small and fixed | Grows with the number of inputs and outputs |
| Parallel validation | Harder, because transactions may touch the same state | Easier, because outputs are independent |
| Privacy | Addresses tend to be reused | A new change address can be used each time |
The account model is simpler to reason about for developers and makes balance queries cheap. The UTXO model makes double spending checks straightforward, since each output is either spent or not, and lets nodes verify unrelated transactions independently. Hybrids exist: Cardano uses an extended UTXO design that attaches data and scripts to outputs.
Parallelism and scaling
A drawback of shared account state is that two transactions touching the same account or contract cannot safely run at the same time, so early account-based chains executed transactions one after another. Newer designs address this. Solana requires each transaction to declare in advance which accounts it will read and write, allowing non-overlapping transactions to run in parallel, and some chains based on the Move language organise state as objects for the same reason. Research into blockchain parallelism and sharding is largely an effort to recover parallel execution without giving up the convenience of accounts.
Privacy and usability trade-offs
Account-based chains tend to concentrate a user's history under one public address, which makes activity easier to trace than on a UTXO chain where coins can be split across many addresses. On the other hand, accounts allow features such as account abstraction, where wallet logic, recovery rules and fee payment are handled by contract code rather than a single key. These trade-offs mean neither model is strictly better; each suits different priorities in distributed ledger design.
Ref 1070001092