01The relationship in one sentence
The private key derives the public key; the public key derives the address. The chain runs one way: holding the key lets you compute the other two, while holding the address computes neither.
Sensitivity decreases along the chain: never give out the private key, the public key is rarely needed day to day, and the address is meant to be seen.
02Think of it as a seal
The private key is the seal itself. The public key is a description of what its imprint looks like. The address is the number on your door. Someone with the description can recognise your imprint; nobody can carve the seal from it.
Extending that:
- To spend, you press the seal onto a page saying "move X to Y" — that is a signature.
- To check the transfer really came from you, anyone compares the imprint against the description. The seal never leaves your hand during this.
- To send you money, someone only needs the door number, which is the address.
The analogy also explains why signing never requires transmitting the key: a verifier needs the imprint and the description, not the seal. So anyone who asks you to hand over the seal is not verifying you, they are taking your things. The full version of that reasoning is in seed phrases and private keys.
03Why it does not run backwards
Because the derivation uses a class of mathematics where the forward computation is fast and the reverse requires a search long enough to be meaningless. This is not "nobody has cracked it yet" — it is not achievable with the computing power that exists.
You do not need the algorithm names, only the property: computing a public key from a private key is one definite calculation and it is quick. Going the other way means searching an enormous space. The address step adds a hash on top, and hashing is one-way too.
Which answers a common worry: if the address is public, could somebody work out my key? Under current conditions, that is not a realistic attack path. Real-world losses come almost entirely from an exposed seed phrase or a signed approval, not from broken cryptography. The full list is in how wallets actually get drained.
04Is it risky to publish your address
Not for the safety of the funds. It is for privacy. A public address cannot be spent by anyone else, but it does let anyone look up every transaction it has ever made and what it currently holds.
Chain data is public, which means:
- Posting an address publicly exposes that address's holdings and counterparties.
- If that address has ever interacted with your verified exchange account, working out who it belongs to is not difficult.
- Publicly visible high-balance addresses attract targeted phishing and fake airdrop messages.
Address reuse costs privacy, not security
On chains like Bitcoin, wallets generate a fresh address for each incoming payment. That is not to make it safer; it is to stop observers stitching your receipts into a single financial picture. Ethereum-style systems typically reuse one address because the account model works differently.
In practice this reduces to one rule: the address you intend to publish long term should not be the address holding the bulk of your assets. The first gets looked at repeatedly; the second should not be easily linked to you.
When you need to publish a receiving address, use one dedicated to that, not the one holding your main balance. The separate-by-purpose idea is introduced in setting up your first wallet and solves more than it first appears to.
05Where the seed phrase sits in this chain
At the top. The phrase derives a master key, which derives a series of private keys, each with an address. So the phrase carries more authority than any single key.
That hierarchy explains two things:
- Why one phrase covers many addresses across many chains. It is the root of the tree.
- Why leaking the phrase is far worse than leaking one key. The latter loses an address; the former loses the tree.
Worth clearing up a beginner misconception too: on most Ethereum-style chains, the same phrase derives the same address, so your address looks identical across those networks. Identical addresses do not mean identical chains, and you still have to pick the right network when sending — see what a chain is, and what happens when you pick the wrong one.
One class of address has no key behind it
Everything above applies to ordinary account addresses. Chains also carry contract addresses, which are computed from a deployment transaction and have no corresponding private key at all. Nobody can sign assets out of one, unless that contract's own code contains logic to send them.
This is why "tokens sent to a token contract address are usually unrecoverable": not because nobody is willing to help, but because the operation does not structurally exist. Multi-signature wallets are contract addresses too — with code stating that several designated addresses must sign together before anything moves.
For what these words look like on a wallet screen, see the glossary.