Running a node

Your spare RAM, rented by the hour.

A server you already pay for has memory sitting idle. One container turns it into something that earns. There is no wallet key on the machine and nothing runs as root.

What you need

A server: anything with RAM you can spare — a VPS is fine
Docker: that is the whole runtime
A public address: a hostname or IP renters can reach
Open ports: one per rental, from a range you choose
DRAM: 100 per mebibyte you actually rent out
A wallet: stays on your own machine, never on the server

Stake is charged on memory that is rented, not on memory you advertise. Idle capacity costs you nothing, which is what lets a small machine join at all.

Post stake

Open Run a node in the console and post DRAM. Only the part backing memory that is actually rented is held; the rest you can take back at any time.

Four gibibytes fully rented needs 409,600 DRAM. You can post more than you need — the page shows how much more capacity your stake would cover.

Withdrawing stake takes seven days from the request. That delay is the point: stake that could leave the moment a node started failing would never be there when it mattered. You can cancel a request at any time during it.

Declare a node

Say how much memory the machine is willing to give up, and give it a region number — any number you like; the network only uses it to group nodes in the list.

Declare what the machine can really spare. Once a day the network fills the free part of your node and reads it back. A node that advertises memory it does not have fails that check, and a run of failures takes it off the line.

You can change the figure later, as long as the new one is not below what is currently rented.

Run one command

Press Launch line. You get a complete docker run, already filled in with the coordinator’s address and your node’s capacity. Replace the one placeholder — your server’s public address — and run it there.

docker run -d --name dramnet --restart unless-stopped \
  -p 7400-7460:7400-7460 \
  -v dramnet:/var/lib/dramnet \
  -e DRAMNET_API=https://... \
  -e DRAMNET_TOKEN=dn_... \
  -e DRAMNET_PUBLIC_HOST=<this server's address> \
  -e DRAMNET_CAPACITY_MB=4096 \
  ghcr.io/.../dramnet-agent:latest

DRAMNET_API: where the coordinator lives
DRAMNET_TOKEN: one-time, claims this node once, then is replaced
DRAMNET_PUBLIC_HOST: what renters connect to
DRAMNET_CAPACITY_MB: what you declared on chain
DRAMNET_PORT_RANGE: optional, defaults to 7400-7460 — one port per rental
The volume: keeps the node identity across restarts — do not drop it

The launch line carries no wallet key. Everything that needed a signature happened in your browser; what reaches the server is a string good for claiming one node once. A stolen server costs you a node, not a wallet.

Watch it come up

Within fifteen seconds the node shows on air in the console and appears in the renters’ list. From then on it needs no attention: it reports what it is running, the coordinator answers with what should be running, and the agent makes the machine match.

There is no command queue and nothing to replay. If the container dies and comes back it simply reconciles again.

What the network checks

Once a minute, for every live rental on your node:

Does it answer: inside the timeout, at the address you gave
Is the ceiling right: the instance still has the size that was bought
Is it holding data: a pinned canary is read back at a random offset

And once a day, against the free part: the network fills it and reads it back. That is the check that makes an advertised gibibyte worth believing, and it is why the figure you declare has to be honest.

Minutes that fail are never billed to the renter — and never paid to you. They simply do not enter the sum.

What failing costs

A run of failures takes the node off the line. It keeps serving the rentals it already has, but receives no new ones until it is healthy and you put it back.

Stake can also be taken for a node that fails badly enough. That is switched off at launch and will stay off until there is enough history to know how often an honest operator fails through no fault of their own.

Getting paid

Ninety per cent of what a renter pays goes to you, ten to the network. It accumulates in the contract as you serve and you claim it whenever you like — there is no schedule and nothing expires.

Moving or reinstalling

Keep the volume and the node survives a restart untouched. If you are moving to another machine, or you lost the line, press Issue a new one.

A new launch line kills the old one immediately. The agent still running on the previous machine loses access the moment the new one registers — which is exactly what you want when the old machine is gone, and worth remembering when it is not.

More than one node on a machine

Possible: one wallet can declare as many nodes as it likes, and each runs as its own container with its own volume and its own port range. Worth asking why, though — two nodes on one server split the same RAM, and the daily proof will hold real memory for both.