Bitcoin Spaces

← Back to all insights

Send bitcoin to a name, not to 62 random characters. Spaces lets you own that name on Bitcoin itself.

The problem

A Bitcoin address looks like the line below. Nobody can say it out loud, print it on a card, or check it by eye. One wrong character and the money is gone.

Names already exist on the internet. You know them from email and websites. But those names are rented. A company called a registrar keeps the record, and a chain of companies and governments sits above it. If one of them changes the record, your name points somewhere else, or nowhere.

Spaces asks a simple question. What if the name lived on Bitcoin, held like a coin, where only your key can move it?

What Spaces is

• A space is a name that starts with @, like @bitsaga. You win it in an auction on Bitcoin. After that it is a small Bitcoin coin that only your key can spend.
• A handle is a name under your space, like rob@bitsaga. You hand them out yourself, without asking anyone. One tiny note on Bitcoin covers as many as you like.
• A record says where to pay. Mine is a silent payment address, which gives every payer a fresh private address. I wrote about that here.

How a payment finds you

The parts, in more detail

Winning a name

You open an auction with one Bitcoin transaction and place a bid. Names open for bidding at a fixed pace, about ten a day, so nobody can grab thousands at once. The highest bid wins. The bid is not paid to anyone: it is burned. Nobody else bid on @bitsaga, so my bid burned just 1,000 sats. One more transaction then registers the name to me.

Keeping a name

A space is a lease of about a year (52,560 blocks). Every transaction that updates it renews it, and I will renew it before it ends. If you forget, the name expires. That is the price of having no registrar: nobody sends you a reminder.

Handing out handles

Your handles live in a list, and the list stays off Bitcoin. What goes on Bitcoin is one 32-byte fingerprint of the list, called a Merkle root, in a small transaction. Each handle you add gets a certificate that says: this name belongs to this key, for good. Every new fingerprint builds on the earlier ones, so nobody can later slip in a second owner for a handle you already issued. That is also why a handle cannot be moved to another address afterwards.

Saying where to pay

Records say where a name pays. On a space, they sit inside a Bitcoin transaction. On a handle, they are signed with the handle's key and shared off Bitcoin. I wrote three records: a silent payment address (sp), a plain Bitcoin address as the fallback (btc), and my website. Spaces has no standard yet for the names of payment records, so sp and btc are my own choice. A wallet has to agree on them.

How a wallet trusts the answer

A wallet receives a proof: the certificate, the signed records, and the path from the handle up to Bitcoin. It is about 3 KB. Mine is 3,003 bytes, and checking one takes about a tenth of a millisecond. To finish the check, the wallet needs one more thing: an anchor. That is a fingerprint of all of Spaces at one moment. Anyone who runs a Spaces node can compute it from Bitcoin, about every six hours. I computed mine on my own node.

What a relay does

A relay is a small server that keeps the proofs for names and hands them to wallets. It is only a messenger. It can be slow, or offline. It cannot lie, because the wallet checks every proof against Bitcoin. Relays also copy from each other, so one relay can answer for names it has never met.

Spaces, BIP 353 and silent payments

These three are not rivals. They answer different questions.

• Silent payments (BIP 352) answer: what kind of address should I give out? One that is private and reusable.
• BIP 353 answers: how do people find that address from a name? Through the domain system.
• Spaces answers the same question, but the name lives on Bitcoin instead of in DNS.

The two kinds of name can point at the same silent payment address. Mine do:

There are practical differences too:

• Standard. BIP 353 is a published standard with a fixed record format. Spaces has no agreed record names for payments yet, so a wallet would have to learn mine.
• Freshness. A DNS proof stays valid for about a day and a half. A Spaces anchor covers about two weeks. I measured both on my own server in September.
• Size. A BIP 353 proof is about 3 KB. A handle under my own small space is about 3 KB too. A handle under a big shared space is not: alice@bitcoin needs 230,466 bytes, because the whole space has to be proven. Owning a small space avoids that cost.
• Setup. BIP 353 takes a DNS record. Spaces takes an auction, a handful of transactions, and a relay.

What I did

I bought @bitsaga on Bitcoin. Nobody else bid. All the network fees together came to 6,882 sats. I wrote my payment address into the name, so the name itself already says where to pay. Then I created the handle rob@bitsaga, and signed its records: a silent payment address as the main record, and a plain Bitcoin address as the fallback.

I also run my own relay, at spacesrelay.bitsaga.be. It follows my own Bitcoin node. I put the proof for rob@bitsaga on it. Then I asked my public relay for the name from a clean client, and checked the answer against my own node. It returned both addresses, and showed the handle as final. That way I did not have to trust anyone, including myself.

Check it yourself

You need your own Bitcoin node and the Spaces node spaced. To look at the space itself:

space-cli getspace @bitsaga
space-cli getfallback @bitsaga

To resolve rob@bitsaga through my relay and verify the answer against your own node:

pip install libveritas
curl -O https://bitsaga.be/files/resolve-via-relay.py
python3 resolve-via-relay.py rob@bitsaga https://spacesrelay.bitsaga.be

The script asks the relay for the proof. Then it checks the proof against the anchors of your own spaced node, and prints the addresses it finds. The relay is only the messenger.

Run your own relay

Anyone can run a relay. It is one program. This is what I ran:

cargo install --git https://github.com/spacesprotocol/certrelay.git \
  relay --bin certrelay --locked

I pointed mine at my own Spaces node, so the proofs it serves rest on my own Bitcoin node. A relay can also start its own light client, so you do not need a full node to try it. The more relays there are, the less any one of them matters.

What does not work yet

• Almost no wallet understands Spaces names today. The public network is tiny: my own relay currently sees 9 others. It is very early.
• There is no agreed way yet to name payment records, so sp and btc only work where a wallet chooses to read them.
• A space is a lease. I have to renew it about once a year.
• A handle's address is fixed for good. rob@bitsaga will always point to the address I chose.
• Spaces is a second kind of name next to BIP 353. It does not replace it. For now, both can point at the same silent payment address.

The Spaces protocol and its tools come from spacesprotocol.org.