What Singula is

Open alpha. The network runs on Arbitrum Sepolia, a test network, and is paid in a test token. No real money is at stake.

Singula is a network of servers that carry other people’s traffic and are paid for it by a smart contract. Anyone can run a server and earn. Anyone can write a client and use the network. Nobody needs permission for either.

A VPN is the obvious thing to build on a network like this, and one exists. The protocol itself is simpler: it gives a client the address of a server, counts the seconds that server worked for the client, and pays for them. What the client builds from the servers it gets — one hop, a chain, something of its own — is up to the client.

• Use it — install Wanderer, the app for Windows, Linux and Android.
• Run a node — one container and one transaction.
• Build a client — start here.

The parts

A Star is a participant, a record in the StarRegistry contract. Every Star has two addresses:

• the owner — a cold wallet that receives the money. It is set at registration and never changes;
• the signer — a hot key on the server that signs the Star’s working messages. The owner can replace it at any time.

A node is a Star that carries traffic. It runs Xray with four REALITY inbounds, accepts sessions and reports to a Control Plane.

A Control Plane is a Star with the CP role. No traffic passes through it. It checks that a client is entitled to a session, picks a node, passes sealed credentials along, collects reports, and writes the seconds served to the chain. Control Planes publish their addresses in CPEndpointRegistry, and a client picks one itself.

A client is anything that speaks the protocol. Wanderer, our app for Windows, Linux and Android, is the first implementation, with no special rights.

One program for every role. The star program is the same on every server: at start it finds itself in StarRegistry and switches on what its role needs.

What an Orbit is

An Orbit is a subscription to the network, held as an NFT. It lasts 30 days from activation, not from purchase. When you buy one you choose its slots, 1 to 5: a slot is one connection at a time — one device, or one hop of a route. Each slot costs 10 sUSDC.

Until it is activated, an Orbit is an ordinary token: you can buy one and give it away, and one address can hold up to ten unactivated. Activation binds it to its holder.

Buying needs no ETH. You sign an EIP-712 intent and a token permit, GasStation sends the transaction, and you pay its gas in USDC along with the price.

There are no accounts, logins or API keys. A client shows it is entitled to a session in one of two ways:

• with a wallet — it signs a short text naming the Control Plane, which checks the Orbit on chain;
• with a proof — it proves in zero knowledge that it holds one of the Orbits registered in SubscriberRegistry, without saying which. The Control Plane learns only that some subscriber connected.

How money reaches a server

The network pays for time served, in USDC. Bytes only tell a working tunnel from an idle one; they do not change the amount.

Each Orbit is split like this: 70% to the node pool, 10% to the DAO treasury, 10% to protocol liquidity, 5% to the Control Plane pool and 5% to the founder. A node is paid a fixed rate for every second credited to it, and a Control Plane a fixed amount for every epoch it holds a seat. The contract owner can change the split; SubscriptionNFT.getSplit() returns the current figures.

An epoch is 24 hours. When it closes, claimNode and claimCp pay out. Anyone may call them, because the money always goes to the Star’s owner as recorded in the registry. An operator needs no ETH to get paid.

The shape of it

flowchart TB
    chain["Arbitrum<br/>SingulaProtocol · StarRegistry<br/>SubscriberRegistry · EpochAttestations"]
    client["Client<br/><i>picks its own route</i>"]
    cp["Control Plane<br/><i>issues sessions, collects reports</i>"]
    node["Node<br/><i>carries the traffic</i>"]

    client -->|"wallet signature or ZK proof"| cp
    cp -->|"PrepareSession"| node
    client ==>|"traffic — VLESS + REALITY"| node
    node -->|"heartbeat, signed interval"| cp
    cp -->|"signed intervals"| chain
    chain -.->|"addresses, roles, the epoch clock"| client

Traffic goes from the client straight to the node. The Control Plane is never on that path.

Where it runs

The network runs on Arbitrum Sepolia, chain id 421614. Payment is in sUSDC, a test token with 18 decimals.

One address is worth remembering, because everything else is read from it:

SingulaProtocol  0xC7aA88375cE5B1d43768EA0545069CB294Fc2992

snapshot() on that contract returns the current epoch, its parameters and the address of every other contract.

Where to go next

You want to run a server — run a node: one container and one transaction. If you already hold the Control Plane role, run a Control Plane.

You are writing a client — start with build a client; the details are in the gRPC API and the API reference. For sessions without a wallet, see anonymous access and building a proof.

You are building a product on the network — build on Singula: your own device, holding its own Orbit.

You are deciding whether the network suits you — who sees what and limits.

About these pages

These pages describe what the code does, and the figures were read from the deployed contracts. Where an owner can change a value — the split, the price, the circuit version — the call that returns it is named, so you can check the live figure instead of trusting the page.

If something here does not match what you see on the network, tell us.