How Ethereum Accounts Work: EOAs, Contract Accounts, and Why It Matters for Your Trades

Two Account Types: EOAs vs. Contract Accounts

Ethereum's backbone is simple: there are only two kinds of accounts on the network, and they behave very differently.

Externally owned accounts (EOAs) are what you control with your private key. When you create a wallet in MetaMask or any other Ethereum wallet, you're creating an EOA. You own it, you can initiate transactions from it whenever you want, and creating one costs you nothing. An EOA can send ether, receive tokens, and call smart contracts—it's your primary interface to the chain.

Contract accounts are different. They're smart contracts deployed to the Ethereum network—bundles of code that live at their own address. You can't initiate a transaction from a contract account on your own. Instead, a contract can only react. When an EOA (yours or someone else's) sends a transaction to a contract's address, the contract executes its code. That execution might move tokens, trigger a swap on Uniswap, mint an NFT, or liquidate a position in a lending protocol.

Why does this matter for trading? If you're executing a trade on a DEX, you initiate it from your EOA, but the contract on the other end receives your transaction and executes the swap logic. You can't trade through a contract account directly—only through an EOA.

Balance, Nonce, and Gas: The Three Pillars

Every account on Ethereum tracks three critical pieces of data.

Balance is straightforward: how much ether you hold. It updates every time you send or receive ether or tokens. If you're tracking your portfolio on TradingView or in a spreadsheet, this is the number you care about.

Nonce is a counter that increments each time an EOA sends a transaction. It starts at 0 and goes up by one for every outgoing transaction from that account. Ethereum uses nonces to prevent double-spending and ensure transactions execute in order. If you send two transactions in a row, the first has nonce 5, the second has nonce 6. If the network sees them arrive out of order, it won't process the second until the first is confirmed. This is crucial: if you're trying to cancel a pending transaction by broadcasting a new one with the same nonce, you're racing against the network. Nonce management matters when you're setting slippage limits or trying to front-run or sandwich-avoid.

Gas is the fee you pay for computation. Every operation on Ethereum—transferring ether, calling a contract function, minting a token—consumes gas. You pay in gwei (a unit of ether), and the total cost is gas used × gas price. Importantly, you pay gas whether your transaction succeeds or fails. If you set slippage too tight on a swap and it reverts, you still lose the gas. This is why gas monitoring is critical for profitable trading on-chain, especially during high-volatility moments when fees spike.

State, State Transitions, and the EVM

Ethereum is a state machine. "State" is simply the current snapshot of all account balances, nonces, and contract storage across the entire network.

Every transaction you submit changes the state. You send 1 ether to a friend—your balance drops, theirs rises, your nonce increments. You swap 10 USDC for ETH on Uniswap—the balances of multiple accounts shift, the contract's liquidity pool state updates, and multiple accounts' nonces tick up (including yours and the protocol's). All these state changes are bundled into a block, validated, and added to the chain. Every full node on Ethereum stores the entire state history, which is why the network is decentralized and tamper-proof.

The Ethereum Virtual Machine (EVM) is the engine that executes this. When your transaction hits a node, the EVM processes the code (whether it's a simple transfer or a complex smart contract interaction), applies the state transitions deterministically, and either confirms the change or reverts it. This determinism is crucial: the same transaction always produces the same result on every node. No surprises, no favoritism.

For traders, this means: every order, every swap, every position you open is a state transition. Understanding that state changes are atomic (all-or-nothing, thanks to the EVM) helps you reason about slippage, reverts, and failed transactions.

How This Differs from Bitcoin (and Why)

Bitcoin uses a completely different model called UTXO (unspent transaction output). Instead of accounts with balances, Bitcoin tracks individual coins. When you receive 1 BTC, you're holding one or more UTXOs. When you spend, you unlock those UTXOs and create new ones. It's more like physical cash: you hand over a bill, get change back.

Ethereum's account model is more like a bank ledger—balances are centrally updated. Why did Ethereum choose this? Accounts are simpler to reason about, especially for smart contracts. A contract needs to know "how much ether does address X hold?" With UTXOs, you'd have to track every unspent output—messy and expensive. Accounts also enable more sophisticated features: a contract can check your balance in one operation, or a protocol can charge fees based on your account state. This flexibility is why Ethereum enabled DeFi, yield farming, and lending protocols.

The downside: accounts require more state storage. Bitcoin's UTXO model is leaner. But for a platform that prioritizes programmability and smart contracts, Ethereum's choice made sense.