Early test network: unaudited, and nothing on it has real value. What this means

How it works

SmartNodes splits a VPN into parts that no single party controls: people who pay, operators who run nodes, probers who check them, and a blockchain that keeps the rules. Each part learns as little as it can about the others.

The parts

Your deviceHolds anonymous tickets and runs the client.
Entry nodeSees your address, not where you go.
Exit nodeSees where you go, not who you are.
ProbersTest nodes at random through real sessions.
The chainRegisters nodes, pays them, keeps the rules.

The chain is its own network, SmartNodes, built with the Cosmos SDK. Its token, SNODE, is used for node bonds, staking and fees; see the token page.

Paying with tickets

You buy a batch of tickets in one purchase. Before the issuers sign them, your device blinds them: it hides each ticket behind a random factor, so the issuers sign without seeing what they sign. Your device then removes the factor and has a valid ticket that nobody has ever seen.

When you connect, you hand a node a ticket made out to that node. The node shows it to the chain to be paid. The chain checks the issuers' signature and that the ticket was not spent before, but it cannot link the ticket to the purchase: the purchase is public, the spend is public, and nothing connects them. One ticket buys one session of a set length.

  • Each ticket can be spent once, at one named node, and the chain refuses a second spend.
  • The chain never pays out more tickets than it saw issued, which caps the damage if an issuer key were ever misused.
  • Unspent tickets expire with their issuer key; their value goes to the community pool, not to anyone's pocket.

Today one issuer key signs tickets on the test network. Before real value is involved, signing will be split between several independent issuers, so that no single key can create tickets. That design is with the cryptographer.

Two hops

Your traffic goes through an entry node and then an exit node, run by different operators. The connection to the exit runs inside the connection to the entry, so:

  • the entry node sees your address and that you use SmartNodes, but only encrypted traffic to an exit;
  • the exit node sees the websites you visit, but only the entry node's address, never yours;
  • name lookups go to the exit's own resolver, through the tunnel, never to your local network.

The client keeps a kill switch: if the tunnel drops, your traffic stops rather than leaking outside it.

Pay before serve

A node checks with the chain that a ticket is genuine and unspent before it serves you, so nobody can use a node for free. The exit is paid ahead, and the client waits a random time between paying it and first using it, so that the chain's record of the payment cannot be lined up with the moment you connected.

The disguise

WireGuard, which carries the tunnel, is fast but easy to recognise, and some countries block it. Entry nodes can also offer a disguise built on Xray REALITY. To anyone watching, your device makes an ordinary encrypted visit to a well-known website, by default www.microsoft.com. A censor that connects to the node itself is passed through to that real site and sees its real certificate.

The client tries WireGuard first and switches to the disguise by itself when WireGuard is blocked, then remembers for a day that it is blocked where you are.

Bridges

A disguise hides what the traffic is, but listed entry nodes' addresses are public on the chain, so a determined censor can block all of them. Bridges are entry nodes on no public list: the chain stores only a fingerprint of each bridge's details, never its address.

  1. Handed out for a ticket. A device spends one ticket, through its exit node, for one bridge line. The chain picks a bridge at random; the bridge answers with its line sealed to a one-time key only that device holds. Each line goes to a limited number of people, so a censor must pay for every line it collects, and its payments go to bridge operators.
  2. Checked twice. The device asks a second node, not just the exit it bought through, for the same answer, and checks the line against the fingerprint the bridge committed to.
  3. Rubbish is punished. A bridge is paid only after a waiting period. If its answer does not match its fingerprint, the device proves it on the chain: part of the bridge's bond is burned, it is not paid, and another bridge is asked.
  4. Dead lines are replaced. A device whose line stops working reports it, proving it was given the line without saying who it is. Once enough of the people given a line report it, the line stops being handed out, and the operator moves the bridge to a new address or port. Nobody already using it is cut off.

Bridges are never tested by public probers, because probing would reveal their addresses to anyone who signs up as a prober. They are checked by their own users instead.

Checking nodes

Probers are independent, bonded participants who test nodes the way a user would: they pay with real tickets, connect through two hops, measure speed and check that traffic arrives untouched. Each round, the chain assigns probers to nodes at random, from a seed nobody can steer, so operators cannot choose who tests them.

  • Probers seal their results first and reveal them a round later, so none can copy another.
  • A node that fails several rounds in a row is jailed: hidden from users until its operator fixes it. Being down costs income, never bond.
  • A node that every assigned prober catches tampering with traffic loses part of its bond.
  • On the test network these penalties are switched off: results are recorded, but nobody is jailed or loses bond until the rules have been tried in public.
  • Probing is aimed: new nodes, failing nodes and nodes just back from jail are tested more often; nodes with a long clean record less often, but never not at all.
  • A customer who had a bad session can flag the node, spending one ticket made out to it. A flag is not a verdict: it only makes probers look more often for a while. The ticket pays the node as usual, so flagging a rival costs you money and earns them some.

How often a node is probed does not change what it earns over time: each pass is worth less when a node is probed more, so neither flags nor aiming can be used to hurt an honest node.

How nodes earn

  • Tickets. Every ticket a node redeems pays its operator the ticket price, less a 5% protocol fee.
  • Availability. A reward pool pays nodes for passing verification, never for ticket volume, because volume could be faked by an operator spending tickets at their own node.
  • Bridges earn from the tickets that buy their lines.

Every node posts a bond, which it gets back when it leaves after a waiting period. Early operators can be sponsored: a bond lent from a sponsor pool, which returns to the pool when the node leaves.

Nothing to log

The node software keeps session details in memory only. It locks its memory against being swapped to disk, warns if swap or the system log could record anything, and in strict mode refuses to start at all. It logs only totals: sessions open, tickets redeemed. It also refuses to run with the operator's main key in strict mode; a separate service key, which can only redeem tickets, does that job.

The chain

The chain is a sovereign Cosmos SDK network with its own validators. Some of its rules are designed against problems seen on other networks:

  • Half of validator income is paid equally to every validator, so the largest do not keep growing simply by being largest.
  • Validator commission is capped at 20%.
  • Stake held by listed accounts, such as a treasury, can be barred from governance votes, so that holding tokens does not mean controlling the rules.
  • Every chain process that runs on its own copes with a failure by recording it and carrying on, rather than halting the chain.