What the wallet actually stores
An Ethereum account is a pair of cryptographic keys. The private key signs transactions, the public key is derived from it, and the 20-byte address you share is taken from the last 20 bytes of the Keccak-256 hash of the public key.[2]
The balance you see is not in the app. It is state on the network, keyed by that address, and any node can report it. Ethereum.org describes a wallet as a window into your account and notes that wallet providers do not have custody of your funds.[1]
This is why you can switch wallet apps at any time without losing funds, as long as the private key or the phrase that generates it survives. Ethereum.org calls the seed phrase the only way to recover a wallet and warns there is no customer support in crypto, which is the practical meaning of self-custody.[1]
There are two account types on Ethereum. Externally owned accounts are controlled by a private key; contract accounts are controlled by code. A classic wallet manages the first kind, and a smart account wallet manages the second.[2]
See also: Glossary: private key · Glossary: self-custody
Seed phrases and derivation paths
Almost every consumer wallet starts from a mnemonic defined by BIP-39. The standard uses a list of 2,048 words and produces phrases of 12, 15, 18, 21 or 24 words, carrying 128 to 256 bits of entropy plus a short checksum.[4]
BIP-39 turns the phrase into a binary seed, which BIP-32 or a similar method then expands into a tree of keys. That is why one seed phrase can restore many accounts, and why it can usually be imported into another wallet brand. The spec notes one catch: the seed depends on the wordlist, so the English list is the safe choice.[4]
The trade-off is concentration. One phrase opens every account derived from it, so it deserves the same protection as all of those balances combined. Ethereum.org describes hardware wallets as devices that keep your crypto offline and advises writing the phrase down rather than storing it on a computer.[1]
See also: Best hardware wallets · Glossary: seed phrase
How a wallet talks to a dapp
A browser wallet exposes a provider object to each page, historically as window.ethereum. EIP-1193 defines its shape: a single request method that takes a JSON-RPC method name and parameters, plus events such as accountsChanged and chainChanged.[3]
When a site asks for eth_requestAccounts, the wallet shows a connection prompt. When it asks for eth_sendTransaction, the wallet builds the transaction, shows it, signs it with the key after you approve, and broadcasts it through an RPC endpoint. The site never touches the key.[3]
Signing is not limited to payments. Wallets also sign messages for logins and sign token approvals. Under the ERC-20 standard, an approval lets a spender withdraw from your account multiple times up to the approved amount, and it stays in force until you overwrite it, so an approval given to a malicious contract is a lasting risk.[9]
See also: MetaMask · Revoke.cash · WalletConnect
Worked example: paying for a simple transfer
Ethereum.org gives a concrete case. A plain ETH transfer uses 21,000 units of gas. With a base fee of 10 gwei and a priority tip of 2 gwei, the fee is 21,000 x (10 + 2) = 252,000 gwei, or 0.000252 ETH.[5]
Of that, 0.00021 ETH (the base fee part) is burned and 0.000042 ETH goes to the validator as the tip. The recipient still gets the full amount sent. Your wallet shows this estimate before you sign, and it needs ETH in the same account to pay it, even if you are sending a different token.[5]
That last point trips up new users. Ethereum.org states that gas fees have to be paid in ether, so an account holding only a stablecoin cannot move it on Ethereum mainnet until it also holds a little ETH for gas, unless a smart account setup lets someone else sponsor the fee.[5]
Layer 2 networks exist largely to cut these costs, and ethereum.org's gas page points to layer 2 scaling as the main route to lower fees. The wallet handles the difference by filling in the fee estimate for whichever network you are on.[5]
See also: Glossary: gas fee · Glossary: gwei
Wallet types compared
Wallets differ mainly in where the key lives and who can use it. The table sorts the common forms by that question rather than by brand.
| Type | Key location | Main risk |
|---|---|---|
| Browser extension or mobile app | Encrypted on your device | Malware or a phishing signature on the same device |
| Hardware wallet | Secure chip on a separate device | Loss of the seed backup; blind signing |
| Custodial exchange account | Held by the company | Company failure or account freeze |
| Smart contract account | Rules in a contract, keys can be several | Bugs in the contract code |
See also: Best software wallets · Best crypto wallets · Safe
Smart accounts after Pectra
Two standards changed what a wallet can be. ERC-4337 created account abstraction without a protocol change: user operations go to a separate mempool, bundlers package them, and a singleton EntryPoint contract executes them. Paymaster contracts in the same design let applications sponsor fees for their users.[6]
EIP-7702 went further by letting a regular key-based address set code for itself. It shipped with the Pectra upgrade, activated on Ethereum mainnet on May 7, 2025 at epoch 364032.[7]
EIP-7702 names batching (for example an ERC-20 approval followed by spending it, which DEXes need two transactions for today) and sponsorship as its main uses. Its security section warns that a poorly designed delegate contract can give a malicious actor near complete control of the account, so a signed delegation deserves the same care as a key.[8]
Checking a wallet before you trust it
Start with custody. Ethereum.org points out that a centralized exchange holds your funds for you, so its financial trouble becomes your risk, while a self-custody wallet leaves the keys and the responsibility with you.[1]
Next, test recovery before funding. Create the wallet, write down the phrase, delete the app, and restore it from the phrase alone. If the same address comes back, the backup works. BIP-39 adds a checksum to the phrase, but the spec itself warns that it is short and will miss some typing errors, so check every word.[4]
Then look at how the wallet shows transactions. A good signing screen names the contract you are calling, decodes the function (for example approve or transfer), and shows the token amount in plain units. A screen that shows only hex data is asking you to sign blind.
Finally, match the wallet to the chains you use. An Ethereum address is the last 20 bytes of a public key hash, and EVM networks such as Base and Arbitrum reuse that format, so one address works across them. Non-EVM chains such as Solana use their own formats and need a wallet that supports them.[2]
Keep two wallets if you use dapps often: a daily one with small balances for signing experiments, and a vault that never connects to new sites. The split costs nothing and limits the damage of any single bad signature.
See also: Phantom · Rabby · MetaMask vs Rabby · Ledger
The bottom line
Pick the wallet by where the key should live for the amount at stake. A browser or mobile wallet is fine for small daily balances and dapp testing; savings belong behind a hardware device or a multi-signer smart account, with the seed phrase written offline in two places.
Educational content, not financial advice. Crypto assets are volatile; do your own research.