Skip to main content
deCDN has two protocol roles (nodes and clients) plus one external component (origin backends). Only nodes and clients speak CDN protocols.

Nodes

A node is a bonded QUIC endpoint that caches and serves content-addressed blobs.
  • Identity. A network keypair bound on-chain to an Ethereum address at registration (network).
  • Bond. A capacity bond in TOKEN, scaled to declared bandwidth (bond = k × Mbps^α) — the only TOKEN-side requirement to join the mesh, and never below the global minBond entry floor.
  • Discovery. Registered on-chain with its addresses and region; publishes a DHT record for each blob it caches, and quotes its current rate in every signed probe response.
  • Delivery. Serves the paid-delivery protocol — the sole rail for both client→node and node→node traffic.
  • Earnings. Per-MB voucher revenue in USDC.
  • Cache policy. Node-local and pluggable: admission defaults to always and eviction to lru, with W-TinyLFU available for either. Pins and probe-triggered holds are engine-enforced, and a deny-listed hash is evicted even when pinned.
Two deployment shapes: “Origin-backed” is a deployment choice, not a protocol distinction — the network cannot tell them apart at runtime. By default an origin-backed node serves only what its own backend can produce and declines anything else as NotFound, so the client fails over; an operator can opt in to relaying foreign blobs (cache.relay_foreign_namespaces), and then pays upstream like any cache node.

Clients

A client is a lightweight QUIC endpoint that consumes content and pays for it.
  • Identity. A network keypair generated at first startup and persistent across sessions, plus a per-connection binding to an Ethereum address that the node discards on disconnect — no bond, no on-chain registration.
  • Discovery. Takes candidates from its own peer store or the on-chain registry and probes them; it runs no DHT lookup. Publishes nothing and holds no network role.
  • Payment. Opens one on-chain USDC pool, reuses it for every node it buys from, and signs cumulative off-chain vouchers as bytes flow (payments).
  • Trust model. Verifies hashes on all bytes received. Trusts no node for content, and none for availability either — a node may decline to serve, and the client simply re-routes without paying for the attempt.
Every client fetch runs a multi-source scheduler, pulling disjoint segments from up to four holders at once (or from one, when only one holds the blob), and resumes crashed transfers from the last verified chunk-group boundary.

External components

These are not CDN protocol participants. A node reaches its backend over that backend’s own interface — HTTP, the S3 API, a filesystem — not over a CDN protocol. A backend never registers, probes, or bonds.

Origin backend

An S3 bucket, R2 bucket, MinIO instance, NFS mount, or local disk. Holds the canonical bytes. Origin-backed nodes query it on cache miss. Never exposed to the network — the hash→object-key mapping is a private catalog held by the operator.

Who bonds, who pays