How Crypto Actually Works: A Plain-English Guide

Most people meet crypto through an app. You install a wallet or open an exchange, a balance appears next to a familiar logo, and it feels like a bank account with a different skin. That mental model is comfortable, and it is wrong in ways that cost people money. There are no coins sitting inside your phone. What you actually own is an entry on a shared public ledger, and the ability to change that entry because you hold a secret number that nobody else has. Crypto is a ledger plus keys. Almost everything confusing or dangerous about it flows from that one sentence.

A bank keeps its own private ledger and lets you see a copy. If someone steals your password, the bank can freeze the account, reverse the transfer, and issue you a new card, because the bank controls the ledger. A public blockchain works the opposite way. The ledger is not owned by anyone; thousands of independent computers each keep an identical copy and agree on its contents by following the same rules. The only thing that authorises a change to your part of that ledger is a valid cryptographic signature produced by your private key. There is no support desk with the authority to reverse a signed transaction, because no support desk holds the ledger. This is the trade the technology makes: you get an account nobody can freeze or seize at will, and in exchange you carry the full weight of securing it.

This guide walks through the ten concepts that make the whole system legible: what a blockchain is, how keys and addresses work, what a transaction actually contains, what gas pays for, what the mempool is, how the network agrees on history, what a smart contract can and cannot do, how tokens and NFTs are defined, and how to read a block explorer so you can verify all of it yourself. Each section explains the mechanism in plain English and then says why it matters for staying safe, because the same properties that make crypto powerful are the ones attackers rely on. We keep to how the technology works. There are no prices here, no forecasts, and no suggestion that you should buy anything. Read the one-line summary table below, then dive into whichever concept you want in depth.

The core concepts, explained

1. What a blockchain is

A blockchain is a shared database that many computers maintain together, structured as a chain of blocks. Each block holds a batch of validated transactions, a timestamp, and a cryptographic fingerprint, called a hash, of the block before it. That backward reference is the whole trick. Because every block commits to the exact contents of its predecessor, the blocks are linked in a fixed order. Change a single character in an old block and its hash changes, which means the next block's stored reference no longer matches, which invalidates that block and every block after it. To rewrite history you would have to redo the work for that block and all of its successors faster than the rest of the network extends the honest chain. On a large network that is computationally and economically impractical.

The second half of the design is replication. The ledger is not stored in one place. Every full node keeps its own complete copy and independently checks every transaction and every block against the protocol's rules before accepting it. No central server is trusted; the rules are trusted, and each participant enforces them. This is why people describe a public blockchain as a distributed, append-only ledger. You can add new entries by following the rules, but you cannot quietly edit or delete old ones.

Why it matters for safety. Immutability is a feature and a hazard at the same time. It is what lets you hold value that no company can dilute or delete, and it is exactly why a mistaken or fraudulent transfer cannot be undone. If you send funds to the wrong address or approve a malicious contract, there is no clawback. The ledger did precisely what it was told. Treat every confirmed transaction as final and irreversible, and slow down before you sign, because the system will not save you from yourself. We unpack this further in what a blockchain actually is.

2. Public and private keys

Ownership on a blockchain is proved with cryptography rather than with a username and password. A private key is an enormous random number, on Ethereum a 256-bit value generated from a secure source of randomness. From that private key, elliptic curve cryptography (the secp256k1 curve on both Bitcoin and Ethereum) derives a matching public key. The relationship runs one way only: it is trivial to compute the public key from the private key, and infeasible to reverse the process. This asymmetry is what makes the whole system work.

When you want to move funds, your wallet uses the private key to produce a digital signature over the exact details of the transaction. Anyone on the network can then use the corresponding public key to verify that the signature is genuine and that the transaction has not been altered, all without ever seeing the private key itself. Possession of the private key is ownership. There is no separate account record that a key merely unlocks; the key is the account's authority. Whoever holds it can sign, and whatever they sign, the network will honour.

Because a raw 256-bit number is impossible to write down safely, most wallets present the key material as a recovery phrase using the BIP-39 standard. The wallet generates random entropy, appends a checksum derived from its SHA-256 hash, and slices the result into groups of 11 bits. Each group indexes into a fixed list of exactly 2048 words (2 to the power of 11), producing an ordered phrase of 12 or 24 words. That phrase is then stretched into the actual wallet seed using the PBKDF2 function with HMAC-SHA512 over 2048 iterations. The practical upshot: those words are not a password to your account, they are the master secret from which every private key in the wallet is regenerated.

Why it matters for safety. Anyone who learns your recovery phrase or private key can drain the wallet from anywhere on earth, instantly and permanently, and you cannot change the phrase the way you would reset a password. This is why the single most repeated rule in crypto security is that the seed phrase is generated on your device, stored offline, and shown to no one. No legitimate wallet, exchange, or support agent will ever ask you to type it into a website or a chat. Any request to "verify," "validate," "sync," or "restore" your wallet by entering the twelve or twenty-four words is a theft attempt, without exception. See public and private keys explained for the full walkthrough.

3. Addresses

An address is the public identifier you share to receive funds, and it is derived from your public key by hashing. On Ethereum, the address is the last 20 bytes of the Keccak-256 hash of the public key, written with a leading "0x", producing the familiar forty-hex-character string. Bitcoin applies its own sequence of hash functions to arrive at its address formats. In every case the address is a shortened, one-way fingerprint of a public key, which is itself derived from the private key. You can hand out your address freely; it reveals where funds can be sent, not how to spend them.

Addresses are not tied to your legal identity by the protocol. They are pseudonymous strings. But because the ledger is public and permanent, every transaction an address has ever made is visible forever, and analysis of those patterns can sometimes link an address back to a person or a service. Pseudonymous is not the same as anonymous.

Why it matters for safety. Addresses are long, meaningless-looking, and unforgiving. Send to a wrong or malformed address and the funds are gone. Two specific attacks target this. In clipboard-hijacking malware, a virus watches for a copied address and swaps it for the attacker's before you paste. In address-poisoning scams, an attacker sends you a tiny transaction from a vanity address whose first and last characters match one you use often, hoping you will later copy it from your history. The defence is the same in both cases: verify the full address, or at least several characters from the middle as well as the ends, and confirm the first transaction with a small test amount when sending somewhere new.

4. Transactions

A transaction is a signed instruction to change the ledger. On Ethereum a transaction bundles together several fields: a nonce (a per-account counter that orders your transactions and prevents replays), the recipient address, the amount of native currency to send, an optional data payload, and the gas parameters that cap what you will pay. The whole package is signed with your private key. Once broadcast, any node can check the signature, confirm the nonce is correct, and verify you can cover the cost, before relaying it onward.

The data payload is where a great deal of the risk lives. A plain transfer of value has an empty payload. But when you interact with a smart contract, the payload encodes exactly which function you are calling and with what arguments. Sending funds to a person and granting a contract permission to move your tokens look almost identical in a rushed wallet pop-up, yet they do very different things. The signature you provide authorises the precise contents of that payload and nothing else, which is a strength, but only if you actually understand what the payload says.

Why it matters for safety. Signing is the moment of no return. Every drain, every scam, every exploit ultimately requires you to authorise something, whether a transfer or an approval. Modern wallets try to decode and display what a transaction will do, but decoding is imperfect and attackers deliberately craft confusing payloads. Before you sign, read the summary: what contract am I talking to, what am I sending or approving, and does it match what I intended? If a site rushes you, hides the details, or asks you to sign a "message" you cannot read, stop. The mechanics of confirmation are covered in how a transaction gets confirmed.

5. Gas and fees

Every operation on Ethereum consumes gas, a unit that measures computational work. Sending value costs a small fixed amount of gas; running a complex contract costs more. Gas exists so that the people whose computers execute your transaction are compensated, and so that no one can jam the network for free with endless computation. You do not pay in gas directly; you pay a price per unit of gas, quoted in gwei, where one gwei is one-billionth of one ether.

Since the EIP-1559 upgrade, an Ethereum fee has two parts. The base fee is set by the protocol for each block and is burned, meaning it is destroyed rather than paid to anyone. The base fee moves automatically with demand: each block targets 15 million gas with a hard ceiling of 30 million. If a block is more than half full, the base fee for the next block rises by up to 12.5 percent; if it is less than half full, the base fee falls. On top of the base fee, you add a priority fee, or tip, which does go to the validator who includes your transaction, as an incentive to pick yours sooner. Your wallet also lets you set a maximum fee, a cap above which you refuse to pay even if the base fee spikes.

Why it matters for safety. Fees are unavoidable, and that fact is weaponised. Scam tokens are engineered so that you spend real gas trying to sell something you can never actually sell. "Gas fee" phishing pages ask you to sign a transaction framed as a small network fee that is really an approval draining a token. And because fees rise with congestion, urgency-based scams push you to transact during busy periods when you are least likely to check carefully. Understand that a fee pays for computation and inclusion, never for "unlocking," "activating," or "releasing" funds that a site claims are stuck. Read what gas fees actually pay for for the details.

6. The mempool

Between the instant you broadcast a transaction and the moment it lands in a block, it waits in the mempool. The mempool is the set of pending, valid, but not-yet-confirmed transactions that each node holds in memory and gossips to its peers across the network. It is not a single queue in one location; every node keeps its own view, and those views broadly converge. When a validator builds a block, it selects transactions from the mempool, generally favouring those offering a higher priority fee.

Crucially, the public mempool is exactly that: public. Anyone running a node can watch pending transactions before they are confirmed. That visibility enables a category of activity known as maximal extractable value, where sophisticated actors reorder, insert, or sandwich transactions to profit from what they see coming. A common example is front-running, where a bot spots a profitable pending trade and pays a higher tip to have its own transaction executed first.

Why it matters for safety. The mempool is why a transaction is not safe simply because you have broadcast it. Until it is included and confirmed, it can be dropped, replaced, or, in the case of a trade, exploited by observers. For most users the practical takeaways are modest: do not assume a pending transaction is final, be cautious about large trades on illiquid assets where sandwiching is most damaging, and understand that "pending" in your wallet means "announced to the world," not "done." It also explains why a transaction can appear stuck: if your priority fee is too low, validators simply have no reason to pick it out of the crowd.

7. Consensus: proof of work versus proof of stake

Consensus is how thousands of nodes that do not trust one another agree on a single version of the ledger. Two mechanisms dominate, and the difference between them is one of the most misunderstood parts of crypto.

Proof of work, used by Bitcoin, secures the chain with computation. Miners race to find a number that, when combined with the block's contents and hashed, produces an output below a target threshold. Finding it requires trillions of guesses; verifying it takes one hash. The miner who finds a valid solution proposes the next block and earns the block reward. Bitcoin targets one block roughly every ten minutes, and every 2,016 blocks (about two weeks) it adjusts the difficulty of the puzzle to hold that pace as computing power joins or leaves. The block reward began at 50 BTC and halves every 210,000 blocks, roughly every four years: it fell to 25, then 12.5, then 6.25, and to 3.125 BTC in 2024. That schedule is what enforces Bitcoin's fixed ceiling of 21 million coins.

Proof of stake, which Ethereum adopted when it completed "the Merge" on 15 September 2022, replaces physical computation with economic stake. To become a validator you deposit, or stake, a minimum of 32 ETH. Time is divided into 12-second slots and 32-slot epochs; in each slot the protocol pseudo-randomly selects one validator to propose a block and a committee of others to attest that it is valid. Validators who behave honestly earn rewards; those who go offline lose small amounts, and those who try to cheat the protocol can be "slashed," losing a portion of their stake and being ejected. The security assumption shifts from "attacking the chain costs enormous electricity" to "attacking the chain costs enormous, forfeitable capital." Ethereum has stated the switch cut its energy use by roughly 99.95 percent.

Why it matters for safety. Consensus is not the layer where ordinary users get robbed; almost every real-world loss happens at the key or approval level, not by breaking the chain's agreement. Understanding consensus mainly inoculates you against a category of confident-sounding nonsense: promises to "double your coins" by sending them to a staking address, fake "validator node" investment schemes, and claims that some new project is safer because it "can't be 51 percent attacked." Staking your own funds is a protocol action with real conditions; sending coins to a stranger who promises returns is simply giving them away.

8. Smart contracts

A smart contract is a program stored on the blockchain that runs exactly as written when called. On Ethereum, contracts execute inside the Ethereum Virtual Machine, and because every node runs the same code over the same inputs, they all reach the same result deterministically. Once deployed, a contract's code lives at an address just like an account, and anyone can call its functions by sending a transaction to it. Contracts are what turn a blockchain from a simple payment ledger into a platform: tokens, exchanges, lending markets, and NFTs are all smart contracts.

The phrase "code is law" captures both the promise and the danger. A contract does what its code says, not what its marketing says and not what you assumed. It has no judgement, no ability to recognise that you were tricked, and no off-switch unless the developers deliberately built one in. Many contracts are immutable after deployment; others are upgradeable, which introduces its own trust question, because whoever controls the upgrade can change the rules. A contract is also only as honest as its author. Bugs have drained hundreds of millions of dollars from flawed contracts, and malicious contracts are written specifically to look benign while doing harm.

Why it matters for safety. When you interact with a smart contract you are trusting its code, the people who wrote it, and anyone who can upgrade it. The most common self-custody loss is not a stolen key at all; it is a user who was persuaded to sign a transaction calling a contract's approval function, handing an attacker ongoing permission to move their tokens. A contract cannot reach into your wallet on its own. It can only do what you signed to authorise. That is why reading the transaction, checking whether a contract is verified and audited, and revoking approvals you no longer use are core habits. We separate the reality from the hype in what a smart contract is and isn't.

9. Tokens: ERC-20 and NFTs

Most of the "coins" people hold on Ethereum are not the native currency at all; they are tokens defined by smart contracts that follow shared standards. Standards matter because they let wallets, exchanges, and explorers handle thousands of different tokens with one piece of code.

The ERC-20 standard, formally EIP-20, defines fungible tokens, where every unit is interchangeable, like currency. The standard specifies six mandatory functions, including totalSupply (how many exist), balanceOf (how many an address holds), transfer (send tokens), and the trio of approve, allowance, and transferFrom that let one address authorise another, such as an exchange contract, to move tokens on its behalf. It also defines two events, Transfer and Approval, that wallets and explorers watch. That approval mechanism is genuinely useful, because it lets decentralised applications operate on your tokens without taking custody of them, but it is also the single most abused feature in crypto.

The ERC-721 standard, EIP-721, published in 2018, defines non-fungible tokens. Here each token carries a unique tokenId, so that the pair of contract address and token ID is globally unique and no two tokens are interchangeable. Functions like ownerOf return who holds a specific token, and transfers move that one specific item. NFTs are how blockchains represent unique things: a piece of art, a collectible, a membership. The same approval concept exists here too, including a setApprovalForAll function that grants an operator control over an entire collection at once.

Why it matters for safety. The approval model is where most drainer attacks operate. Instead of stealing your key, an attacker tricks you into signing an approve or setApprovalForAll transaction, or an off-chain "permit" signature, that grants their contract permission to move your tokens whenever they like. The tokens stay in your wallet looking safe, right up until the attacker executes the transfer. This is why granting an unlimited allowance to a site you do not fully trust is dangerous, and why periodically reviewing and revoking active approvals is one of the highest-value security habits in all of self-custody.

10. Block explorers

A block explorer is a website that reads the public blockchain and presents it in human-readable form. Etherscan is the best-known for Ethereum; other chains have their own. Because the ledger is public, an explorer is not privileged software; it is simply a searchable window onto data anyone can access. Paste in an address and you can see its balance, its full transaction history, and every token it holds. Paste in a transaction hash and you can see whether it succeeded or failed, what it did, what it cost, and how many confirmations it has. Look up a contract and, if the developers have verified it, you can read its actual source code.

Explorers also expose the tools that turn all of this from trivia into defence. Etherscan's token approval checker, for example, lists every approval an address has granted and lets you revoke ones you no longer want. That single feature is how a user can discover, and cut off, an over-broad permission before it is exploited.

Why it matters for safety. A block explorer is the closest thing crypto has to an independent, always-available source of truth. When a wallet says a transaction is pending, the explorer tells you whether it is really confirmed. When a project claims a token is widely held, the explorer shows how concentrated the holders actually are. When you suspect you signed something bad, the explorer's approval checker shows exactly what permissions are live. Learning to read one turns you from a passenger, dependent on whatever an app chooses to display, into someone who can verify claims directly. Start with how to read a block explorer.

How it all fits together

Follow a single transaction from intent to permanence and every concept above appears in sequence. Suppose you want to move some tokens to a friend. You open your wallet, which is not holding coins but managing the private keys derived from your BIP-39 seed phrase. You enter your friend's address, the 20-byte hashed fingerprint of their public key, and an amount. This particular move is a token transfer, so your wallet constructs a transaction whose data payload calls the token contract's transfer function with your friend's address and the amount as arguments.

Your wallet fills in the housekeeping: the nonce that orders this transaction after your previous ones, an estimate of the gas the contract call will consume, a base fee it reads from recent blocks, and a priority fee to encourage prompt inclusion. It shows you a summary. This is your moment of control and your moment of risk. You confirm that the contract is the real token, that the recipient is correct, and that you are transferring, not approving. Satisfied, you sign. Your private key produces a signature over the exact transaction; the key itself never leaves your device.

The signed transaction is broadcast to a node, which checks the signature, the nonce, and your balance, then relays it into the mempool, where it joins thousands of other pending transactions and propagates across the network. Now it waits, publicly visible, for a validator to notice it. In Ethereum's proof-of-stake system, a pseudo-randomly chosen validator for the current 12-second slot builds a block, selecting transactions from the mempool and generally preferring higher tips. It includes yours, executes the token contract's code in the Ethereum Virtual Machine, deducts the base fee (which is burned) and the priority fee (which it keeps), and updates the ledger: your token balance falls, your friend's rises.

That block is proposed, attested to by a committee of other validators, and appended to the chain, its hash now baked into the block that follows, and the one after that. With each new block your transaction gains confirmations and becomes exponentially harder to reverse. Minutes later you and your friend can both paste the transaction hash into a block explorer and read, from independent public data, that it succeeded. No bank approved it. No company recorded it in a private database. A network of strangers following identical rules agreed it was valid and wrote it into a shared history that no one can quietly erase. The entire arc, from a secret number on your device to a permanent public fact, ran on the ten concepts in this guide.

Where people get confused (and lose money)

Almost every avoidable loss traces back to a handful of misunderstandings about the mechanics above. Naming them plainly is the best protection.

Thinking the wallet holds coins. It holds keys. Lose the seed phrase and the funds are unreachable even though they still sit on the ledger; leak the seed phrase and they are gone even though the app still shows a balance. The words are the asset's control, so protect them accordingly, offline and private, and never enter them into any website or message for any reason.

Confusing an approval with a transfer. A transfer moves funds once. An approval grants standing permission for a contract to move your tokens in the future, potentially without limit. Drainer scams live in this gap, because an approval looks harmless in the moment and the theft happens later. Read what you are signing, prefer limited approvals over unlimited ones, and revoke permissions you no longer use.

Believing transactions can be reversed. They cannot. The immutability that protects your holdings also means a mistaken transfer or a signed scam is final. There is no chargeback and no support line with the power to undo a confirmed transaction. This is why verifying an address and reading a transaction before signing are not optional niceties; they are the only safety net that exists.

Trusting a balance that only an app shows. Fake wallet apps, phishing sites, and scam tokens can all display numbers that are not real or not spendable. The blockchain is the source of truth, and a block explorer lets you check it independently. If an app shows a large balance you cannot verify on an explorer, distrust the app, not the explorer.

Mistaking a fee for a fix. Gas pays for computation and inclusion. It never "unlocks," "activates," or "releases" funds. Any site telling you to pay a fee to free stuck coins, or to sign a small "network fee" that turns out to be a token approval, is running a scam that exploits your correct belief that fees are normal.

Assuming pseudonymous means anonymous, or private means secret. Addresses are not linked to your name by the protocol, but the ledger is permanent and public, and behaviour can deprivatise it over time. Meanwhile the public mempool means a transaction is visible the instant you broadcast it, not only once confirmed. Neither property is a reason for alarm, but both are reasons to act deliberately.

The recurring theme is control. On a public blockchain you hold both the keys and the responsibility, and the network will faithfully execute whatever you validly authorise, forever. Security is therefore not a product you buy but a set of habits: guard the seed phrase, read every signature, verify with an explorer, and treat irreversibility as the default. Every concept in this guide is, in the end, a different angle on that one truth.

If a term here was unfamiliar, the glossary defines each concept in a sentence or two, and the linked explainers go deeper on the ones that matter most for keeping your funds safe.

Sources

• ethereum.org — Intro to Ethereum
• bitcoin.org — Bitcoin: A Peer-to-Peer Electronic Cash System (whitepaper)
• eips.ethereum.org — EIP-1559: Fee market change for ETH 1.0 chain
• eips.ethereum.org — EIP-20: Token Standard (ERC-20)
• eips.ethereum.org — EIP-721: Non-Fungible Token Standard (ERC-721)
• github.com/bitcoin/bips — BIP-39: Mnemonic code for generating deterministic keys
• ethereum.org — Proof-of-stake (PoS)
• ethereum.org — Proof-of-work (PoW)
• ethereum.org — The Merge
• ethereum.org — Gas and fees
• ethereum.org — Transactions
• ethereum.org — Introduction to smart contracts
• ethereum.org — Ethereum accounts and addresses
• ethereum.org — ERC-20 Token Standard
• ethereum.org — ERC-721 Non-Fungible Token Standard
• docs.etherscan.io — Etherscan documentation