Two planes
Nodes (the data plane) store shards, route requests over QUIC and answer storage challenges. They have no wallet, no blockchain connection and no balances. An upload is accepted when it carries a valid voucher, which a node checks offline against a public key.
The control plane sells vouchers, holds operator stake, runs audits and computes payouts. It is off the data path, and it never learns what was stored: vouchers are blind-signed (RFC 9474), so the control plane can’t link a voucher it sold to the upload that spent it.
From file to shards
- The uploader’s client encrypts the file (ChaCha20-Poly1305) and cuts it into slabs.
- Each slab is erasure-coded with Reed-Solomon into data and parity shards. Any k of them rebuild it.
- The shards go to different nodes, the ones whose IDs are closest to the slab’s address, with a cap per host so a machine failing can’t take a slab with it.
- The link to the file is
slab://<root>#<key>. The key sits after the#and never goes over the network.
| Profile | Used for | Slab | Shards | Survives losing | Overhead |
|---|---|---|---|---|---|
| RS 32+16 | files above about 1 MiB | 1 MiB | 48 | any 16 | 1.5× |
| RS 10+6 | small files and directory listings | 256 KiB | 16 | any 6 | 1.6× |
Keeping three full copies would cost 3×. Large files get the wide stripe because a file is lost if any one of its slabs is: a 1 GiB file is a thousand slabs. When 10 % of nodes fail at once, our model loses that file with 0.2 % probability on 32+16, and with 87 % if it were stored as 10+6. Small files are one slab, where 10+6 is plenty and a 1 MiB slab would mostly be padding.
Keeping data alive
- Repair. Every 10 minutes the nodes holding a slab check each other, and ask for proof that peers really hold what they claim. When too few shards are healthy (under 40 of 48 for 32+16; under 14 of 16 for 10+6), the node nearest the slab’s address rebuilds the missing ones and places them on other nodes.
- Audits. Once per epoch (a day on the testnet), nodes commit to what they hold, then answer 16 random challenges with Merkle proofs. A fake answer is detected and slashed.
- Reads ask the 24 nodes around a slab’s address for any shard, and the first k verified answers win, so a slow node doesn’t slow the read. Several slabs are fetched at once, so a large file doesn’t download one slab after another.
What nobody learns
| Who | Sees | Doesn’t see |
|---|---|---|
| A node | encrypted shards, the voucher that paid for them | content, file names, who paid |
| The control plane | accounts and how many vouchers each bought | what they were spent on |
| The audit service | which slabs are paid for (ciphertext addresses) | who bought them |