Ethereum operates on a robust account-based model that fundamentally distinguishes it from other blockchain systems like Bitcoin. While Bitcoin relies on unspent transaction outputs (UTXOs), Ethereum introduces a more intuitive balance-based system using two distinct types of accounts: external accounts and contract accounts. This structure not only simplifies user interaction but also enables advanced functionality such as smart contracts and decentralized applications (dApps).
In this comprehensive guide, we’ll explore the architecture of Ethereum accounts, how they function within the network, and their role in executing transactions and maintaining blockchain state.
The Two Types of Ethereum Accounts
Ethereum supports two primary account types, each serving a unique purpose in the ecosystem:
- External Accounts (EOAs) – Controlled by private keys and typically owned by users.
- Contract Accounts – Governed by code and activated when triggered by external or other contract accounts.
Both account types share a common structure consisting of four key components:
- Nonce – A counter that tracks the number of transactions sent from an external account or the number of contracts created by a contract account.
- Balance – The amount of Ether (ETH) held by the account.
- Code – Present only in contract accounts; contains the smart contract logic executed on the Ethereum Virtual Machine (EVM).
- Storage – A persistent data store for contract information, initially empty for most contracts.
👉 Discover how Ethereum's account system powers next-generation decentralized apps
External Accounts: User-Controlled Wallets
External accounts are created when a user generates a public-private key pair. These accounts do not contain any code and are primarily used to send transactions, interact with dApps, and manage digital assets.
Key characteristics:
- Controlled solely by private keys.
- Can initiate transactions (e.g., sending ETH or triggering a smart contract).
- Cannot hold executable code.
- The nonce prevents replay attacks by ensuring each transaction is processed only once.
Because EOAs are tied to cryptographic keys rather than code, they represent the human-facing side of Ethereum — your wallet address is an external account.
Contract Accounts: Automated, Code-Driven Entities
Contract accounts are deployed on the blockchain through a transaction initiated by an external account. Once deployed, they operate autonomously based on pre-written logic encoded in smart contracts.
Notable features:
- Possess associated EVM bytecode that defines their behavior.
- Can store data and maintain internal state via storage.
- Cannot initiate transactions independently — they respond only to incoming messages or calls.
- Their code is immutable after deployment, ensuring trustless execution.
This immutability means developers must be meticulous during deployment — bugs cannot be patched without redeploying a new contract.
Smart contracts enable powerful use cases such as automated token transfers, decentralized finance (DeFi) protocols, and non-fungible token (NFT) marketplaces.
How Transactions Work in Ethereum
In Ethereum, a transaction is a signed data packet representing an action initiated by an external account. It serves as a state transition mechanism, altering the current state of the blockchain when executed.
A typical transaction includes:
- Recipient address – The destination account.
- Signature – Generated using the sender’s private key for authentication.
- Value – Amount of ETH to transfer.
- Gas limit and gas price – Parameters determining computational cost.
- Optional data field – Used to pass input to smart contracts.
When a transaction is processed:
- The sender’s balance is debited.
- The nonce increments to prevent replay attacks.
- If targeting a contract, its code executes according to the input.
- The resulting state changes are recorded in the next block.
Unlike Bitcoin, where blocks store raw transactions, Ethereum uses a Merkle Patricia Trie (MPT) to store the complete state of all accounts after each block. This means every full node maintains an up-to-date snapshot of:
- Account balances
- Contract code
- Storage values
This state-centric design allows Ethereum to support complex interactions beyond simple value transfers.
👉 Learn how real-time transaction processing powers Ethereum’s dynamic network
Smart Contracts and Multi-Signature Wallets
One of the most powerful applications of contract accounts is the implementation of multi-signature (multisig) wallets. These require multiple parties to approve transactions before execution, enhancing security for organizations or shared funds.
For example:
- Alice wants to send 20 ETH from a multisig wallet to Bob.
- The contract stipulates that both Alice and Charles must sign off.
- Alice initiates the transaction, which enters a pending state.
- Charles receives a notification and signs the transaction.
- Only after both signatures are verified does Bob receive the funds.
This model reduces single points of failure and is widely used in DAOs (Decentralized Autonomous Organizations), treasury management, and custodial solutions.
Frequently Asked Questions (FAQ)
Q: Can a contract account create another contract?
Yes. A contract account can deploy new contracts during execution, often used in factory patterns where one contract generates multiple child contracts (e.g., NFT collections).
Q: Are Ethereum addresses different for external and contract accounts?
No. Both types use the same 40-character hexadecimal format (e.g., 0x...). However, you can check if an address has associated code using blockchain explorers — if it does, it’s a contract account.
Q: Why can’t contract accounts initiate transactions?
To preserve determinism and prevent infinite loops or unauthorized actions. All executions must be triggered externally, ensuring predictable and auditable behavior.
Q: Is it possible to upgrade a smart contract?
While contract code is immutable by default, developers use proxy patterns to redirect calls to upgraded logic contracts, enabling limited upgradability while preserving data.
Q: What happens if I lose access to my external account?
Since control depends on private keys, losing them means permanent loss of access. There’s no central authority to recover accounts — self-custody requires strong security practices.
The Role of State in Ethereum’s Architecture
Ethereum’s use of MPTs to store account states sets it apart from UTXO-based blockchains. Each block doesn’t just record transactions — it captures the global state root, a cryptographic hash summarizing all account data at that moment.
This enables:
- Faster balance verification
- Efficient light client operations
- Seamless dApp interactions with live contract data
Developers building on Ethereum benefit from direct access to real-time state information, making it ideal for applications requiring dynamic data retrieval and interaction.
👉 Explore how Ethereum's state management fuels innovation across DeFi and Web3
By combining user-controlled external accounts with programmable contract accounts, Ethereum creates a flexible and secure foundation for decentralized innovation. Whether you're sending ETH, interacting with dApps, or deploying smart contracts, understanding these account types is essential for navigating the ecosystem safely and effectively.
As blockchain technology evolves, Ethereum’s account model continues to inspire new platforms and improvements in scalability, privacy, and usability — solidifying its role as a cornerstone of the Web3 revolution.