Validators

Validators

What you actually need to run a Roko validator: ordinary server hardware, a Rust build (or a pre-built binary/image), a time source the node can classify, and a pwROKO bond. No time card is required — joining the live testnet validator set is currently coordinated with the team.

Build requirements

The node builds with Rust 1.80.0 (pinned by `rust-toolchain.toml`, with the `wasm32-unknown-unknown` target) plus `build-essential`, `protobuf-compiler`, `clang`, and `llvm-dev` on Ubuntu/Debian. 

# One runtime feature is mandatory: testnet OR mainnet
cargo build --release --features testnet -j2

The build needs a minimum of 8 GB RAM and 50 GB free disk; the `-j2` flag limits parallel compilation because Substrate builds exhaust memory on machines with less than 32 GB RAM — drop it on larger machines for faster builds.

Runtime hardware

Production validator guidance from the deployment guide:

ComponentMinimumRecommended
CPU4 cores8 cores
RAM16 GB32 GB (high-traffic)
Storage500 GB SSD1 TB
Network100 Mbps—

The network even runs a real Raspberry Pi CM5 validator on the testnet (with a GNSS module and Timebeat for timing), so the floor is genuinely modest.

Time source

Validators self-classify their time source — Timebeat PTP daemon, chrony, GNSS/PPS, or NIC hardware timestamping — and announce a measured root distance to UTC. GNSS/PPS hardware earns Anchor tier; the modes are `Auto` (default), `MockAnchor` (testnet), and `SystemOnly`.

TierRoot distanceSourceHardware cost
Anchor< 1 µsGNSS/PPS-disciplined clock~$30–300 GNSS receiver
Standard< 10 µsNTP via chronynone
Minimal> 10 µsSystem clocknone

No timing hardware is required to participate on testnet: `--timesync-time-source mock-anchor` bypasses detection (development/testnet only).

Time quality is recorded on-chain per validator, with time-sync offences defined (slash fractions: excessive offset 0%, persistent drift 1%, low reputation 1%, contradictory offsets 5%) — but offence enforcement is currently disabled in both compiled runtimes, so violations are detected and scored without slashing.

Bonding and economics

Staking is denominated in pwROKO, not native ROKO, in both runtimes; the genesis pattern bonds 50 ROKO worth of pwROKO per validator.

pwROKO mechanics in brief: `lock(amount)` reserves your native ROKO 1:1 and mints pwROKO; unlocking is a two-step flow — `unlock_request` starts a cooldown, then `complete_unlock` releases the backing ROKO. pwROKO itself is non-transferable: it can only be minted by locking and burned by unlocking.

The unlock cooldown is governance-adjustable: 14 days at mainnet parameters, a 10-block placeholder on testnet.

Staking rewards follow the standard Substrate reward curve as configured: min inflation 2.5%, max inflation 10%, ideal stake 50%. These are runtime parameters, not an APY promise — the rewards model remains under active design.

Joining the network

The honest current path, in order:

1. Run a dev node — `roko-node --dev --alice --database auto` gives you a single-validator chain with pre-funded accounts. 2. Run a local 3-validator time mesh — `./run-e2e-local.sh --keep` starts Alice/Bob/Charlie on ports 9944–9946 with a fresh chain spec, using mock-anchor time. 3. Join the live testnet validator set — currently admin-coordinated: the documented registration flow requires the testnet sudo key to fund the account with 200 ROKO, lock 50 ROKO into pwROKO, bond, set session keys, and signal validate intent. Active status takes effect the next staking era (~5 minutes on testnet). You cannot self-register today; contact the team.

For single-validator and local setups, two flags matter: `--timesync-no-enforce` (a lone node has no peers to converge with) and `--db-storage-threshold 0` (avoids storage-monitor crashes on low-disk systems).

Operations

  • Monitoring: Prometheus metrics on port 9615 include time-source type, root distance, and mesh convergence state; an in-repo Prometheus + Grafana + AlertManager stack ships under `docker/monitoring/`.
  • Mesh health: check `temporal_getMeshState` and `system_health` over RPC.
  • Security basics: `--rpc-methods safe` in production, reverse-proxy TLS in front of 9944, firewall everything except P2P (30333) and proxied RPC.

For context on chain timing: the current testnet runtime runs 2-second blocks (6 seconds is the stated production-testnet target, per the in-code M-19 note), and the mainnet runtime is compiled at 3 seconds.

See also