A node that has never run before knows nothing and trusts nobody. Within a minute it holds eleven connections, and it learned about every one of them from a domain name maintained by a volunteer it has never met.
getaddr→addr
People say “the Bitcoin network” the way they say “the electricity grid” — as if there were infrastructure somewhere, with an operator, a control room, a map. There is no map. There is a bootstrap procedure and a set of quotas, and if you read the code you find that the whole thing is held together by the fact that attacking it is more expensive than it looks.
This is the layer nobody writes about, because it has no price chart. It is also the layer where the two most interesting design decisions in Bitcoin live: how a stranger joins, and how a block crosses the planet.
Layer one: eight domain names you have never heard of
Start a fresh node and it faces a circular problem. It needs a peer to learn about peers. Bitcoin’s answer, since 2012, is DNS.
The binary ships with a hardcoded list of seed hostnames — seed.bitcoin.sipa.be and its siblings — each run by a different volunteer. Some are dynamic: the operator runs a crawler that probes the network continuously and publishes the IP addresses of nodes that are actually reachable. Some are static, updated by hand. Query one and you get A records: a handful of IPs that will probably accept an inbound connection on port 8333.

The elegance is that DNS is the one naming system on earth that is already everywhere, already cached, already resolvable from a machine with no configuration. The problem is that a DNS answer is unauthenticated. A malicious seed operator — or anyone in a position to intercept the lookup — can hand you a list containing only nodes it controls, and you will happily build your entire view of the world on top of them. That is an eclipse attack, and the seed layer is where it starts.
Which is why the seed is never the only path. A node that has run before keeps a peers.dat file of addresses it has met, and on restart it spends up to 11 seconds trying those before it gives up and asks DNS. If no seed answers within 60 seconds, it falls back to a hardcoded list of IP addresses compiled into the binary at release time. Three mechanisms, deliberately redundant, each one worse than the last.
The history here is a decent reminder of how young this all is. Bitcoin v0.1 did not use DNS seeds at all. It joined an IRC channel — #bitcoin on irc.lfnet.org — announced its IP, and read the channel to find others. That was the primary discovery mechanism for four years, and it was removed in v0.8.2 in 2013. For a while, the peer-to-peer money network bootstrapped through a chat room.
Layer two: an address book written by strangers
Once one connection exists, the seed stops mattering. Peers exchange addr messages — small announcements that say “here is an address I know about” — and over weeks a node accumulates thousands of them. This is the actual decentralised mechanism: the network’s membership is remembered by the network, in ten thousand slightly different copies.
BIP-155 extended this in 2020 with addrv2, which carries Tor v3, I2P and CJDNS addresses natively rather than trying to squeeze them into a format designed for 32-bit IPv4. That matters more than it sounds: a node that can gossip onion addresses can build a peer set that reveals nothing about where it is.
The bootstrap sequence, in the order it happens:
- Read
peers.datand try known addresses for up to 11 seconds. - If that fails, resolve the DNS seeds and connect to what comes back.
- If no seed answers in 60 seconds, fall back to the hardcoded IP list.
- Once connected, send
getaddrand collectaddrmessages to refill the book. - Keep the good addresses, evict the dead ones, persist the rest.
Layer three: the asymmetry that keeps you honest
Here is the detail I find most revealing. A default node runs 8 outbound full-relay connections, 2 block-relay-only outbound connections, and 1 feeler that connects, handshakes, and immediately disconnects to test whether an address is alive. Inbound capacity is up to 125.
Eleven outbound slots against a hundred and twenty-five inbound is not an accident of defaults. It encodes a trust judgement: a node trusts the peers it chose more than the peers that chose it. Outbound peers were selected by the node’s own address manager, which is why they are allowed to relay transactions and addresses. Block-relay-only peers exist to receive blocks without revealing the node’s mempool — a nod to the fact that transaction announcements leak information about origin.
Layer four: how a block crosses the planet in under a second
A new block is the one message where latency has a price. If another miner finds a competing block while yours is still propagating, you may lose the race and the reward with it. That is an orphan, and the orphan rate is a direct function of how long a block takes to reach the rest of the network.
The legacy protocol was stupid in a way that only becomes obvious at scale. A miner sends inv — “I have block X”. Peers that lack it reply getdata. The miner sends the full block, megabytes of transactions that most recipients already have in their mempools. Every hop repeats this. Propagation took ten-plus seconds across the globe.
BIP-152, compact block relay, replaced the payload with a hint. The announcement carries the block header plus 6-byte truncated transaction IDs for every transaction in the block. The recipient matches those against its own mempool, reconstructs the block locally, and requests only the handful of transactions it is missing via blocktxn. A 1 MB block becomes roughly a 25 KB announcement.
The “high-bandwidth” mode goes further: a node may designate a few peers to receive compact blocks before the sender has fully validated them, cutting a round trip out of the critical path. That is a deliberate trade — bandwidth and a little trust for latency — and it is why the best-case block propagation is now under a second to most of the network rather than ten.

| Mechanism | Since | What it carries | What breaks it |
|---|---|---|---|
| DNS seeds | 2012 | A records for reachable nodes | unauthenticated answers, seed capture |
| addr / addrv2 | v0.1 / BIP-155 | addresses of known peers | poisoning, stale entries |
| inv + getdata | v0.1 | full blocks and transactions | bandwidth, multi-second latency |
| compact blocks | BIP-152 | header + 6-byte short IDs | mempool divergence, missing txs |
| Erlay | BIP-330, not deployed | set difference of mempools | still a proposal as of 2026 |
Erlay and the thing it does not fix
Erlay is the proposal I keep hearing described as finished work. It is not. BIP-330 replaces full inventory announcements with set reconciliation: two peers compare their mempool sets and transmit only the difference, which for a node with a large mempool is a small fraction of the current traffic. The design is by Pieter Wuille, Gregory Maxwell and others, and as of 2026 it is still not deployed in a release.
What Erlay would fix is bandwidth. What it would not fix is the property that makes this layer interesting: there is no global state to agree on. Every node’s mempool is a local opinion. Consensus only starts at the block. Erlay makes the gossip cheaper, not the opinions identical.

That is the part I wish more people understood about this layer. The network is not a thing that exists and then does consensus. It is a procedure for letting strangers find each other cheaply enough that no single party can stand between them, and every design choice in it — eight seeds, eleven slots, six-byte IDs — is a compromise struck against a specific attack.
“The Bitcoin network” is not infrastructure. It is a habit that ten thousand machines keep.
Satoshi’s first sentence in the whitepaper was not about money. It was about exactly this: a system of electronic transactions “based on cryptographic proof instead of trust, allowing any two willing parties to transact directly with each other without the need for a trusted third party.” Fifteen years later the cryptography gets the attention, and the plumbing that makes two willing parties findable is still eight domain names and a volunteer’s crawler.
(The End)


