What this is

Three authorities seal blocks in round-robin order (Proof of Authority — no mining-style compute cost).
Thin nodes take on a share of the shards via rendezvous hashing; if one dies, the others automatically re-replicate (heal).
Light nodes store only headers and verify via Merkle path and signature — without holding the full record.
Tampering with a single holder is caught immediately: /verify checks hash, Merkle path, header signature and sealer authorization.

Architecture

How the nodes find each other

On its very first start a node needs an entry point: a list of bootstrap addresses (here the three authorities). After that nothing ties it to these addresses — the network finds itself.

Entry: every container gets DV_BOOTSTRAP with several addresses (http://auth1:8080, auth2, auth3). Docker resolves the names on its internal network, so this works the same on every operating system. The list is only used while a node knows fewer than three live peers.
Exchange: every second a node swaps peer lists with a few random neighbours (push-pull, /peers/exchange). That is how it hears about everyone without any centre — new nodes spread like a rumour.
Bounded neighbourhood: each node talks to at most 8 neighbours (3 per round) and regularly swaps one of them. Traffic per node stays the same whether the network has 12 or 1000 nodes — before, everybody probed everybody.
Heartbeat: every node counts up its own heartbeat and it travels along with the lists. Only a higher heartbeat counts as «still alive». A peer without a new heartbeat for 8 seconds is considered gone; thin nodes redistribute the shards and fetch missing ones (heal).
Restart: the peer list is stored on disk (peers.json) and reloaded at startup. A node therefore finds its network even when no bootstrap node is running any more.

Limits: a node with neither an entry address nor stored peers cannot find the network. Several machines are not part of the Docker setup (DV_ADDR and DV_BOOTSTRAP would have to be adapted — untested). Every node needs the full member list to assign shards; in very large networks (far above 100 nodes) the exchange would have to carry larger extracts — the network is tested with up to about 20 nodes. There is no peer authentication yet: anyone who knows the genesis file can join and spread addresses.

Running in three minutes

Docker Engine + Compose plugin (`docker compose version`).

cd testnet
bash dv.sh up
bash dv.sh status

Docker Desktop or Colima (`colima start`), Apple Silicon and Intel.

cd testnet
bash dv.sh up
bash dv.sh status

Docker Desktop with WSL 2, PowerShell 5.1 or newer (preinstalled).

cd testnet
powershell -ExecutionPolicy Bypass -File .\dv.ps1 up
powershell -ExecutionPolicy Bypass -File .\dv.ps1 status

Command reference

dv.sh / dv.ps1	Effect
`up [thin=N] [light=N]`	build and start the network (default: 6 thin, 2 light)
`status`	height, peers, shard coverage of every node
`submit N`	submit N test records
`verify [id]`	check a record: hash, Merkle path, signature, sealer
`kill N`	stop N random thin nodes (simulate failure)
`scale thin N`	change the number of thin nodes
`tamper id`	corrupt a record's local copy (test only)
`smoke`	full run: kill/heal/scale/tamper with checks
`down`	stop the network

Source code

The complete node (Go, standard library only) lives in the repository under testnet/

Not included (deliberately — test entwurf)

no TLS between nodes, no peer authentication, no registry images, no automatic sealer failover if an authority goes down.

When the network is running locally (port 8080), the simulator above can pull real numbers from it in live mode. Simulator →

Testnet