$ man validator

Run a RogueLayer Validator (newbie track)

Before you start. Running a validator is real responsibility. You sign blocks; if your node misbehaves, your stake gets slashed. Set aside a weekend, a dedicated Linux box (or VPS), and the patience to read error messages.

Time: 2–4 hours initial setup. Cost: $20–80/month VPS, plus your self-delegated stake. Risk: If you run two copies of your validator key at the same time, you will be slashed. There is no recovery. Don't do that.

Chain constants

Key	Value
Chain ID	`roguelayer-1`
Binary	`rogued`
Native denom	`urogue` (micro-ROGUE)
Display denom	`ROGUE` (10^6 urogue)
Genesis URL	`TBD — set during launch`
Seed peers	`TBD — set during launch`
Persistent peers	`TBD — set during launch`
P2P port	`26656`
RPC port	`26657`
REST/API port	`1317`
gRPC port	`9090`
EVM JSON-RPC	`8545`
Min Go version	`1.22`
Recommended OS	Ubuntu 22.04 LTS / Debian 12

Note: TBD rows are intentional. They are filled in at chain launch. Doc lint tolerates TBD only in this shared file.

The table above is your reference card — keep it open in another tab.

Prerequisites

Resource	Minimum	Recommended
CPU	4 cores	8 cores
RAM	8 GB	16 GB
Disk (SSD)	200 GB	500 GB
Network	100 Mbps symmetric	1 Gbps
OS	Ubuntu 22.04 / Debian 12	same
Open ports	26656/tcp (P2P) inbound	26656/tcp
Go	1.22+	1.22+
Tools	`git`, `make`, `jq`, `curl`	+ `systemd`

Open P2P (26656) at your firewall. RPC/REST/gRPC ports should NOT be exposed to the public internet on a validator — bind to localhost or to a sentry.

If you're new to Linux servers: rent a VPS (Hetzner, OVH, DigitalOcean are fine), install Ubuntu 22.04, and SSH in. Don't run this on a laptop you close at night.

Step 1 — Install rogued

rogued is the chain binary. We build it from source so you know what's running.

git clone https://github.com/stepheniervella/RL1.git ~/rogue
cd ~/rogue
make install

This compiles the binary and places it at ~/go/bin/rogued. Make sure that directory is on your $PATH. Verify:

rogued version

You should see a version string like v0.x.y. If you see "command not found," add export PATH=$PATH:~/go/bin to your ~/.bashrc and re-source it.

Step 2 — Initialize the node

init creates the data directory at ~/.rogued/ and a placeholder genesis. We'll replace the genesis in the next step.

export MONIKER=your-validator-name   # appears in the explorer; pick something memorable
rogued init "$MONIKER" --chain-id roguelayer-1

If it complains "already initialized," that's fine — you can rm -rf ~/.rogued to start clean, but only if you haven't created keys yet.

Step 3 — Fetch genesis and configure peers

The chain's genesis file is the shared starting state. Every node on the network needs the same one — get it from the official source listed in the chain constants above.

curl -sSL "$GENESIS_URL" -o ~/.rogued/config/genesis.json
sha256sum ~/.rogued/config/genesis.json

Compare the printed hash against the published one. If they don't match, stop and ask in the #operators channel before proceeding.

Now tell your node who to peer with. Edit ~/.rogued/config/config.toml and find the seeds = "" line:

sed -i 's|^seeds = ".*"|seeds = "'"$SEED_PEERS"'"|' ~/.rogued/config/config.toml

(If sed is unfamiliar, open the file in nano ~/.rogued/config/config.toml, find the seeds = "" line, and paste the seed peer list between the quotes.)

Step 4 — Run under systemd

systemd is Linux's "auto-restart this if it crashes" system. Create the service file:

sudo tee /etc/systemd/system/rogued.service > /dev/null <<'EOF'
[Unit]
Description=RogueLayer node
After=network-online.target

[Service]
User=YOUR_LINUX_USERNAME
ExecStart=/home/YOUR_LINUX_USERNAME/go/bin/rogued start
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

Replace YOUR_LINUX_USERNAME with the output of whoami.

Then:

sudo systemctl daemon-reload
sudo systemctl enable --now rogued
journalctl -u rogued -f

You should see a stream of "Committed state" / "Executed block" log lines. Press Ctrl-C to stop watching (the node keeps running in the background).

The node now starts catching up. This can take hours, depending on chain height. Check progress with:

rogued status 2>&1 | jq .sync_info

When catching_up reads false, you're synced. Don't move to Step 5 until then — creating a validator while still syncing wastes the gas fee.

Step 5 — Create your validator

Generate a wallet for the validator operator (separate from the consensus key):

rogued keys add validator

Write down the mnemonic offline. Don't store it on the same machine; if the machine is compromised, your validator and stake are gone.

Fund the address shown by the command with enough $ROGUE to cover your self-delegation plus gas. How you fund depends on whether you're on testnet (faucet) or mainnet (exchange or OTC).

Now register the validator on-chain:

rogued tx staking create-validator \
  --amount=1000000urogue \
  --pubkey="$(rogued tendermint show-validator)" \
  --moniker="$MONIKER" \
  --chain-id=roguelayer-1 \
  --commission-rate=0.10 \
  --commission-max-rate=0.20 \
  --commission-max-change-rate=0.01 \
  --min-self-delegation=1 \
  --from=validator \
  --gas=auto --gas-adjustment=1.3

A few notes on those flags:

--amount=1000000urogue — that's 1 ROGUE (1 ROGUE = 10^6 urogue). Adjust to your self-delegation amount.
--commission-rate=0.10 — you take 10% commission from delegators' rewards.
--commission-max-change-rate=0.01 — you can change commission by at most 1 percentage point per day.

Confirm with y.

Verify

rogued query staking validator $(rogued keys show validator --bech val -a)

You should see your validator's details and status. Congratulations — you're a validator.

Common failures

catching_up: true for hours. Check your peer count: curl -s localhost:26657/net_info | jq '.result.n_peers'. If it's 0 or 1, your seeds are wrong or 26656 isn't open at the firewall. Open it: sudo ufw allow 26656/tcp.
insufficient funds on create-validator. Your validator address doesn't have enough ROGUE. Send more, then retry.
Node halts at a specific height. A scheduled upgrade fired. Check the chain's upgrade notes, rebuild rogued with the new version, restart with sudo systemctl restart rogued.

Operating your validator

Back up ~/.rogued/config/priv_validator_key.json to a cold device. If you lose this and your node dies, you can't sign as your validator any more.
Don't run two copies of your node with the same key. Two nodes signing with the same key is "double-signing" — the chain slashes you for it. There is no recovery.
Monitor missed blocks:
```
rogued query slashing signing-info $(rogued tendermint show-address)
```
If your missed_blocks_counter climbs, your node is unhealthy.

→ Dev track · Agent instructions

Run a RogueLayer Validator (dev track)