Running a Node

Run your own RougeChain node to sync the chain, validate transactions, serve an API to others, and — if you stake — produce blocks and earn rewards.

The node software is open source on GitHub.

Type	What it does	Key flags
Full node	Syncs and validates all blocks from peers	`--peers`
Mining / validator node	Votes on blocks once staked (≥ 10,000 XRGE); proposes only while it is the designated proposer (the validator with the most stake)	`--mine`
Public node	Serves an API/RPC to other users and apps	`--public-url` + reverse proxy

RougeChain's node is deliberately lightweight — the Rust daemon is a single ~23 MB binary and the live mainnet validator holds a steady ~40 MB of RAM. The heaviest part is building it, not running it.

To run a node

	Minimum	Recommended (public / validator)
CPU	1 vCPU	2+ vCPU
RAM	1 GB	2–4 GB
Disk	5 GB SSD	20+ GB SSD (chain data grows over time; SSD matters for the embedded `sled` DB)
Network	Any stable broadband	≥ 100 Mbps, static IP or a domain with TLS
OS	Linux (Ubuntu 22.04+), Windows, or Docker	Linux

The daemon itself uses tens of MB of RAM; the extra headroom is for the OS, chain-data growth, and serving concurrent API traffic.

To build from source

	Requirement
Rust	Recent stable toolchain (1.80+); the project builds on 1.94
RAM during compile	~4 GB
Free disk for `target/`	~6 GB
Tools	`git`, a C toolchain (`build-essential` on Debian/Ubuntu)

A clean release build takes roughly 2–5 minutes depending on cores. If you only want to run a node and not build it, you can also use the Docker image.

Quick Start

# Clone and enter the workspace
git clone https://github.com/cyberdreadx/rougechain-node
cd rougechain-node/core

# Build the daemon (release)
cargo build --release -p quantum-vault-daemon

Join Mainnet

Mainnet requires the mainnet genesis file (shipped in the repo) and the mainnet chain-id:

./target/release/quantum-vault-daemon \
  --genesis daemon/genesis-mainnet.json \
  --chain-id rougechain-mainnet-1 \
  --api-port 5100 \
  --data-dir ~/.quantum-vault/mainnet \
  --peers "https://api.rougechain.io/api" \
  --node-name my-node

Add --mine if you intend to validate. Your node only proposes once its key is staked (≥ 10,000 XRGE) and it is the designated proposer, i.e. it holds the most stake — see Staking.

Join Testnet

Testnet uses default parameters (no genesis file needed):

./target/release/quantum-vault-daemon \
  --chain-id rougechain-devnet-1 \
  --api-port 5101 \
  --data-dir ~/.quantum-vault/testnet \
  --peers "https://testnet.rougechain.io/api" \
  --node-name my-testnet-node

Running a Public Node (for other people)

If you want your node to serve an API/RPC to users, wallets, or apps, run it as a public node. Do not expose the daemon port directly — put a TLS reverse proxy (nginx) in front and keep the daemon bound to localhost or firewalled.

Recommended operator setup:

Bind and advertise — run with the default --host 127.0.0.1 and --api-port 5100, and set --public-url https://your-domain/api so peers can reach you through the proxy. Peers use the same REST API; there is no separate P2P port.
Terminate TLS at nginx — proxy https://your-domain/api → http://127.0.0.1:5100. A full nginx example is in Running a Public Node.
API keys (private nodes only) — --api-keys "<key1>,<key2>" makes every route that is not exempt return 401 unless the request sends X-API-Key or Authorization: Bearer. This covers reads too (e.g. /api/blocks, balances) and the peer routes (/api/blocks/import, /api/peers/register, /api/tx/broadcast); peers never send a key, so a keyed node stops accepting pushed blocks and transactions. Exempt: /, /api/health, /api/stats, /api/v2/*, /api/bridge/*, /api/messenger/*, /api/mail/*, /api/names/*, /api/finality/*, the faucet and the bot. Signed routes check their own signatures.
Rate-limit — e.g. --rate-limit-read-per-minute 600 --rate-limit-write-per-minute 60. All limits default to 0 (unlimited); --rate-limit-per-minute is a deprecated alias for both when neither is set. Limits are keyed by the connecting IP, so behind a reverse proxy every client shares one bucket unless you pass --trust-proxy, which keys loopback (proxied) requests by X-Real-IP / the rightmost X-Forwarded-For entry.
Run under systemd — so it restarts on crash/reboot. Example unit and hardening in Public Node and Configuration.
Monitor — poll /api/health (liveness) and /api/stats (height, peers, mining) from your uptime checker.

Security note: legacy v1 write endpoints that accept a raw private key are development-only (enabled with --dev) and return 410 Gone in a normal build — never run a public node with --dev.

Verify It's Working

curl http://127.0.0.1:5100/api/health

Expected response (mainnet):

{
  "status": "ok",
  "chain_id": "rougechain-mainnet-1",
  "height": 12345
}

Check sync progress and peers:

curl http://127.0.0.1:5100/api/stats

Next Steps

Installation — detailed setup, per-OS
Configuration — every CLI flag and environment variable
Running a Public Node — full nginx + systemd operator guide
Mining — block production and validator selection
Staking — the 10,000 XRGE minimum and rewards

RougeChain Documentation