$ man validator

Run a RogueLayer Validator (newbie track)

Before you start. Running a validator is real responsibility. Your node signs blocks on behalf of delegators; if it misbehaves, your stake — and theirs — gets slashed. Set aside a weekend, a dedicated Linux server or VPS, and the patience to read error messages carefully.

Time: 2–4 hours initial setup + blocksync time (fast on a young chain). Cost: $20–80/month VPS (or your own hardware), plus your self-delegated stake. Risk: If you run two copies of your validator key at the same time — even briefly — you will be double-sign slashed 5% and permanently tombstoned. There is no recovery. Don't do that.

You will need test ROGUE. Get it free from the public faucet at faucet.roguelayer.one — about 11,000 ROGUE per address, enough to self-delegate and pay gas.

Chain constants

Key Value
Chain ID (Cosmos) rogue_4221-1 — use in every tx
EVM chain-id 4221 (0x107d) — MetaMask only; not needed to validate
Binary rogued (Cosmos SDK v0.53 / CometBFT v0.38 — use rogued comet …, not tendermint)
Node home ~/.evmd
Native denom arogue — atto-ROGUE, 18 decimals (1 ROGUE = 1000000000000000000 arogue)
Min gas price 0.0001arogue
Account prefix rogue1… / valoper roguevaloper1… (keys are eth_secp256k1, coin-type 60)
One-command install bash <(curl -sL http://dl.roguelayer.one/install.sh)
Binary download http://dl.roguelayer.one/rogued-linux-{amd64,arm64} — musl-static, runs on any Linux distro (sha256 at the same URL + .sha256)
Genesis http://dl.roguelayer.one/genesis.json (sha256 1899469fc55dc292891e4d3d12d997524939a5bd7f1ddb1a37f4a831a8e5bf4d)
Seed / peer a4a5cdc25a5809acaedc68325019855f01fa8b35@seed.roguelayer.one:26656 (put in seeds and persistent_peers)
Sync method blocksync from the seed (state-sync not yet available — fine on a young chain)
Test ROGUE public faucet → https://faucet.roguelayer.one (~11,000 ROGUE per address / 24h; accepts rogue1… or 0x…)
Ports P2P 26656 (open inbound) · CometBFT RPC 26657 · REST 1317 · gRPC 9090 · EVM JSON-RPC 8545 (keep everything but 26656 bound to localhost on a validator)
OS / arch any modern x86-64 or arm64 Linux — static binary, no glibc or Go required

All values verified live (2026-06-18). The one-command installer wires the seed, genesis, gas price, and a hardened cosmovisor + systemd service for you; pick the right hardware from the prerequisites below.

The table above is your reference card — keep it open in another tab. Every command in this guide uses those values.

Prerequisites

Resource Minimum Recommended
CPU 4 cores (x86-64 or arm64) 8 cores
RAM 16 GB 32 GB
Disk 200 GB NVMe SSD 500 GB NVMe
Network broadband; 26656/tcp outbound + port-forward 26656 inbound

NVMe is a hard requirement. CometBFT fsyncs every block. A spinning HDD or microSD will cause missed blocks and jail you within minutes. Do not cut corners here.

Port 26656/tcp is the only inbound port you must open. Behind home NAT you can get away with outbound-only (you dial the seed), but port-forwarding 26656 lets other peers dial you and improves connectivity. RPC (26657), REST (1317), gRPC (9090), and EVM (8545) must stay bound to localhost on a validator.

Device examples

  • Raspberry Pi 4/5 (8 GB RAM), 64-bit OS — arm64; the installer pulls rogued-linux-arm64.gz automatically. Mount your data directory on a USB3 NVMe/SSD enclosure — never use the microSD as the chain data drive. Fine for a light testnet validator.
  • Cloud VM — e.g. Hetzner CX42, GCP e2-standard-4, or DigitalOcean 4 vCPU · 16 GB; pick a plan labelled NVMe or SSD storage, and open port 26656 in the firewall dashboard.
  • Home bare-metal / mini-PC (NUC) — any modern x86-64 machine with 16 GB+ RAM and an NVMe drive. Behind home NAT is fine; the node dials out to the seed. Port-forwarding 26656 is optional but recommended.

If you are new to Linux servers: rent a cloud VM (Hetzner, DigitalOcean, and GCP all work), install Ubuntu 22.04 LTS, and SSH in. Do not run this on a laptop you close at night — your validator must stay online continuously.

Step 1 — Install rogued (one command)

rogued is the chain binary. The fastest and most reliable way to install it is the official installer:

bash <(curl -sL http://dl.roguelayer.one/install.sh)

That single command:

  • detects your CPU architecture (x86-64 or arm64) and downloads the matching static binary
  • verifies the sha256 checksum
  • fetches and verifies the canonical genesis
  • sets seeds and persistent_peers to the live seed node
  • configures minimum gas price and security settings
  • installs a hardened cosmovisor + systemd service and starts it

When it finishes, the node is running and blocksyncing. Skip to Step 2.

Manual install (if you prefer to do it yourself)

If you want to see every step, you can install the binary by hand instead:

# Pick the right architecture:
ARCH=$(uname -m)
case "$ARCH" in
  x86_64)  URL=http://dl.roguelayer.one/rogued-linux-amd64.gz
            SHA=a7f310a3211b49093e0ba2b30d93a0025ccbf08c5de11d1907a596638818b086 ;;
  aarch64) URL=http://dl.roguelayer.one/rogued-linux-arm64.gz
            SHA=3ad2e0130c6e504a12f79d993c404484d606b035801626695ee0008aa06ad729 ;;
  *)        echo "Unsupported architecture: $ARCH"; exit 1 ;;
esac

# The binary is served gzip-compressed (~38 MB vs ~127 MB). gunzip checks the
# stream CRC as it decompresses, so a corrupted download fails here loudly.
curl -fL "$URL" -o /tmp/rogued.gz
gunzip -f /tmp/rogued.gz          # produces /tmp/rogued; errors if the download was corrupted
echo "$SHA  /tmp/rogued" | sha256sum -c -
# Only continue if the line above prints: /tmp/rogued: OK
# (SHA is the hash of the decompressed binary. If a step fails, just re-run — re-downloading fixes transient corruption.)
sudo install -m 0755 /tmp/rogued /usr/local/bin/rogued
rogued version

These are musl-static binaries — they run on any Linux distribution without needing a specific glibc version.

Step 2 — What the node is doing / watch it sync

After the installer finishes (or after you run sudo systemctl start rogued in the manual path), the node is blocksyncing — replaying every block from genesis to the chain tip. Watch it:

journalctl -u rogued -f

You will see lines like committed state height=1234 .... Press Ctrl-C to stop watching (the node keeps running).

Check sync progress at any time:

rogued status 2>&1 | jq '.sync_info | {latest_block_height, catching_up}'

When catching_up flips to false, you are fully synced. Do not create your validator until then — submitting the transaction while catching up wastes the gas fee and may fail.

Also confirm you have peers:

curl -s localhost:26657/net_info | jq '.result.n_peers'

This should be at least 1. If it stays at 0, your firewall or network is blocking the seed. See the Common Failures section at the bottom.

Step 3 — Get test ROGUE from the faucet

You need ROGUE to self-delegate (the minimum is 1 ROGUE, but 10,000+ is typical) and to pay gas fees. Get it from the public faucet — no account, no asking around.

First, create your operator key:

rogued keys add validator --keyring-backend file

You will be prompted to set a keyring password (remember it — losing it locks you out permanently). The command prints a mnemonic phrase. Write it down on paper and store it somewhere safe and offline. Never save the mnemonic on the same machine.

Get your address:

rogued keys show validator -a --keyring-backend file
# prints: rogue1...

Request tokens from the faucet — paste your rogue1... address into faucet.roguelayer.one, or do it from the command line:

ADDR=$(rogued keys show validator -a --keyring-backend file)
curl -s "https://faucet.roguelayer.one/send?address=$ADDR"
# → ✓ sent 11,000 ROGUE to rogue1...

The grant lands in the next block (~5s). Then verify your balance:

rogued q bank balances $(rogued keys show validator -a --keyring-backend file)

One grant per address per 24 hours. 11,000 ROGUE is plenty to self-delegate 10,000 and keep headroom for gas. If you need a larger validator stake, ask the team in the operators channel.

The balance is shown in arogue (18 decimal places). For example, 10000000000000000000000arogue = 10,000 ROGUE.

Step 4 — Become a validator

Once catching_up is false and your balance shows ROGUE, you can create the validator.

4a — Get your consensus public key

rogued comet show-validator
# prints something like: {"@type":"/cosmos.crypto.ed25519.PubKey","key":"..."}

Copy the full JSON output — you need it in the next step.

4b — Fill in validator.json

Download the template and fill it in:

curl -fL http://dl.roguelayer.one/validator.json.tmpl -o ~/validator.json

Open ~/validator.json in a text editor and replace the placeholder values:

{
  "pubkey": <paste the full JSON from comet show-validator here>,
  "amount": "10000000000000000000000arogue",
  "moniker": "your-validator-name",
  "identity": "",
  "website": "",
  "security": "",
  "details": "",
  "commission-rate": "0.10",
  "commission-max-rate": "0.20",
  "commission-max-change-rate": "0.01",
  "min-self-delegation": "1000000000000000000"
}

A few notes:

  • amount — your self-delegation in arogue (18 decimals). 10000000000000000000000arogue = 10,000 ROGUE. Must be less than your balance and leave some headroom for gas.
  • commission-rate — "0.10" means you take 10% of delegators' staking rewards.
  • commission-max-change-rate — "0.01" means you can change your commission rate by at most 1 percentage point per day. This is a permanent cap — choose carefully.
  • min-self-delegation — "1000000000000000000" = 1 ROGUE. This is the floor you must keep self-bonded or the chain will unbond your validator. Do not set this to "1" (that is 10⁻¹⁸ ROGUE — effectively no floor, which is a bad look).

4c — Submit the transaction

rogued tx staking create-validator ~/validator.json \
  --from validator \
  --keyring-backend file \
  --chain-id rogue_4221-1 \
  --gas auto --gas-adjustment 1.5 \
  --gas-prices 0.0001arogue \
  -y

You will be prompted for your keyring password. The command prints a transaction hash. After a few seconds, check it landed:

rogued status 2>&1 | jq -r '.node_info.id'  # just to confirm the node is alive
rogued q staking validator \
  $(rogued keys show validator --bech val -a --keyring-backend file)

You should see your validator listed with status: BOND_STATUS_BONDED. Congratulations — you are now signing blocks on RogueLayer.

Step 5 — Operate your validator

Backups (do these now, before anything else)

  • Consensus key: ~/.evmd/config/priv_validator_key.json — this is your validator's signing identity. Copy it to a cold, offline device. If you lose it and your node dies, you cannot sign as your validator anymore.
  • Operator mnemonic: you wrote this down at key creation. Verify it is stored safely.
  • Keyring password: the password you set for --keyring-backend file. Store it offline, separately from the mnemonic.

The double-sign rule (read carefully)

Never run two nodes with the same priv_validator_key.json at the same time. If both nodes sign the same block height, the chain detects this as double-signing and applies a 5% slash plus a permanent tombstone on that consensus key. The tombstone is irreversible — to return to validating you would need to generate a new consensus key and re-create the validator from scratch.

This is the most dangerous thing a validator can do. Even a brief overlap when migrating hosts counts.

To migrate safely: fully stop the old node, copy both priv_validator_key.json and priv_validator_state.json to the new host, then start the new node.

Downtime and jailing

The chain requires you to sign at least 50 out of every rolling 100 blocks. At ~5 seconds per block, missing more than ~8 minutes of continuous uptime can get you jailed: 1% slash and a 10-minute jail timeout.

If you get jailed, wait for your node to catch up (confirm catching_up: false), then unjail:

rogued tx slashing unjail \
  --from validator \
  --keyring-backend file \
  --chain-id rogue_4221-1 \
  --gas auto \
  --gas-prices 0.0001arogue

Monitor your signing health:

rogued q slashing signing-info $(rogued comet show-address)

Watch missed_blocks_counter — if it is climbing, your node is unhealthy.

Chain upgrades

When a governance upgrade is announced, the chain halts at the upgrade height. cosmovisor (installed by the one-command installer) handles this automatically if you pre-stage the new binary at the announced height. The team publishes upgrade heights and binary hashes in the operators channel.

Common failures

Symptom What to check
catching_up: true for a long time, n_peers: 0 Your firewall is blocking port 26656, or the seed is unreachable. Test: nc -vz seed.roguelayer.one 26656. Open inbound 26656: sudo ufw allow 26656/tcp.
n_peers: 0 but port is open laddr in ~/.evmd/config/config.toml might be bound to 127.0.0.1:26656. Change it to 0.0.0.0:26656 and restart.
insufficient funds on create-validator Your balance is too low, or you used the wrong denom. Everything is in arogue (18 decimals) — not urogue, not 6 decimals.
key not found: validator You used a different --keyring-backend than when you created the key. Use --keyring-backend file.
Node halts at a specific height A scheduled upgrade fired. Replace the rogued binary with the version the team announced and restart: sudo systemctl restart rogued.
invalid Bech32 prefix; expected rogue You have the wrong binary (a stock evmd or an old build). Re-run the installer.

→ Dev track · Agent instructions

Run a RogueLayer Validator (dev track)

Chain constants

Key Value
Chain ID (Cosmos) rogue_4221-1 — use in every tx
EVM chain-id 4221 (0x107d) — MetaMask only; not needed to validate
Binary rogued (Cosmos SDK v0.53 / CometBFT v0.38 — use rogued comet …, not tendermint)
Node home ~/.evmd
Native denom arogue — atto-ROGUE, 18 decimals (1 ROGUE = 1000000000000000000 arogue)
Min gas price 0.0001arogue
Account prefix rogue1… / valoper roguevaloper1… (keys are eth_secp256k1, coin-type 60)
One-command install bash <(curl -sL http://dl.roguelayer.one/install.sh)
Binary download http://dl.roguelayer.one/rogued-linux-{amd64,arm64} — musl-static, runs on any Linux distro (sha256 at the same URL + .sha256)
Genesis http://dl.roguelayer.one/genesis.json (sha256 1899469fc55dc292891e4d3d12d997524939a5bd7f1ddb1a37f4a831a8e5bf4d)
Seed / peer a4a5cdc25a5809acaedc68325019855f01fa8b35@seed.roguelayer.one:26656 (put in seeds and persistent_peers)
Sync method blocksync from the seed (state-sync not yet available — fine on a young chain)
Test ROGUE public faucet → https://faucet.roguelayer.one (~11,000 ROGUE per address / 24h; accepts rogue1… or 0x…)
Ports P2P 26656 (open inbound) · CometBFT RPC 26657 · REST 1317 · gRPC 9090 · EVM JSON-RPC 8545 (keep everything but 26656 bound to localhost on a validator)
OS / arch any modern x86-64 or arm64 Linux — static binary, no glibc or Go required

All values verified live (2026-06-18). The one-command installer wires the seed, genesis, gas price, and a hardened cosmovisor + systemd service for you; pick the right hardware from the prerequisites below.

Prerequisites

Resource Minimum Recommended
CPU 4 cores (x86-64 or arm64) 8 cores
RAM 16 GB 32 GB
Disk 200 GB NVMe SSD 500 GB NVMe
Network broadband; 26656/tcp outbound + port-forward 26656 inbound

NVMe is a hard requirement. CometBFT fsyncs every block. A spinning HDD or microSD will cause missed blocks and jail you within minutes. Do not cut corners here.

Port 26656/tcp is the only inbound port you must open. Behind home NAT you can get away with outbound-only (you dial the seed), but port-forwarding 26656 lets other peers dial you and improves connectivity. RPC (26657), REST (1317), gRPC (9090), and EVM (8545) must stay bound to localhost on a validator.

Device examples

  • Raspberry Pi 4/5 (8 GB RAM), 64-bit OS — arm64; the installer pulls rogued-linux-arm64.gz automatically. Mount your data directory on a USB3 NVMe/SSD enclosure — never use the microSD as the chain data drive. Fine for a light testnet validator.
  • Cloud VM — e.g. Hetzner CX42, GCP e2-standard-4, or DigitalOcean 4 vCPU · 16 GB; pick a plan labelled NVMe or SSD storage, and open port 26656 in the firewall dashboard.
  • Home bare-metal / mini-PC (NUC) — any modern x86-64 machine with 16 GB+ RAM and an NVMe drive. Behind home NAT is fine; the node dials out to the seed. Port-forwarding 26656 is optional but recommended.

1. Install rogued

One-command path (recommended):

bash <(curl -sL http://dl.roguelayer.one/install.sh)

Handles binary download + sha256 verify, genesis, peers, cosmovisor, systemd service, and node start. Jump to §6.

Manual path:

ARCH=$(uname -m)
[[ "$ARCH" == "aarch64" ]] \
  && URL=http://dl.roguelayer.one/rogued-linux-arm64.gz SHA=3ad2e0130c6e504a12f79d993c404484d606b035801626695ee0008aa06ad729 \
  || URL=http://dl.roguelayer.one/rogued-linux-amd64.gz  SHA=a7f310a3211b49093e0ba2b30d93a0025ccbf08c5de11d1907a596638818b086

# Served gzip-compressed (~38 MB vs ~127 MB); gunzip CRC-checks the stream on decompress.
curl -fL "$URL" -o /tmp/rogued.gz
gunzip -f /tmp/rogued.gz                     # produces /tmp/rogued; errors on a corrupted download
echo "$SHA  /tmp/rogued" | sha256sum -c -    # hash of the decompressed binary; must print: OK
sudo install -m 0755 /tmp/rogued /usr/local/bin/rogued
rogued version

Musl-static binaries — run on any Linux distro, no glibc requirement. The download is gzipped so it's small enough to transfer reliably; if gunzip or the checksum ever fails, just re-run (re-downloading fixes transient corruption).

2. Init node

rogued init <moniker> --chain-id rogue_4221-1
# node home: ~/.evmd/

3. Fetch genesis

curl -fL http://dl.roguelayer.one/genesis.json -o ~/.evmd/config/genesis.json
echo "1899469fc55dc292891e4d3d12d997524939a5bd7f1ddb1a37f4a831a8e5bf4d  $HOME/.evmd/config/genesis.json" \
  | sha256sum -c -   # must print: OK

4. Configure peers, gas, and security

SEED="a4a5cdc25a5809acaedc68325019855f01fa8b35@seed.roguelayer.one:26656"

# Set both seeds and persistent_peers to the seed node
sed -i "s|^seeds = .*|seeds = \"$SEED\"|" ~/.evmd/config/config.toml
sed -i "s|^persistent_peers = .*|persistent_peers = \"$SEED\"|" ~/.evmd/config/config.toml

# Minimum gas price
sed -i 's|^minimum-gas-prices = .*|minimum-gas-prices = "0.0001arogue"|' ~/.evmd/config/app.toml

# EVM JSON-RPC off (not needed for a validator)
sed -i '/^\[json-rpc\]/,/^\[/ s|^enable = .*|enable = false|' ~/.evmd/config/app.toml

# Double-sign safety: panic rather than sign a height already seen in the last 10 blocks
sed -i 's|^double_sign_check_height = .*|double_sign_check_height = 10|' ~/.evmd/config/config.toml

5. Service (cosmovisor + systemd)

If the one-command installer already set this up, skip to §6.

# Install cosmovisor
go install cosmossdk.io/tools/cosmovisor/cmd/cosmovisor@latest

# Wire the current binary as the genesis version
mkdir -p ~/.evmd/cosmovisor/genesis/bin
cp /usr/local/bin/rogued ~/.evmd/cosmovisor/genesis/bin/rogued

sudo tee /etc/systemd/system/rogued.service > /dev/null <<EOF
[Unit]
Description=RogueLayer (RL1) validator
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=$(whoami)
ExecStart=$(go env GOPATH)/bin/cosmovisor run start \
  --home $HOME/.evmd \
  --minimum-gas-prices=0.0001arogue
Environment="DAEMON_NAME=rogued"
Environment="DAEMON_HOME=$HOME/.evmd"
Environment="DAEMON_ALLOW_DOWNLOAD_BINARIES=false"
Environment="UNSAFE_SKIP_BACKUP=true"
Restart=always
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now rogued

6. Start and blocksync

journalctl -u rogued -f           # watch logs; Ctrl-C exits (node keeps running)
rogued status 2>&1 | jq '.sync_info | {latest_block_height, catching_up}'
curl -s localhost:26657/net_info | jq '.result.n_peers'   # must be > 0

Blocksync from the seed until catching_up: false. Do not proceed until synced.

State-sync is not available yet (no snapshot server). Blocksync from genesis is fast on this young chain.

7. Create operator key

rogued keys add validator --keyring-backend file
rogued keys show validator -a --keyring-backend file   # rogue1...

Back up mnemonic and keyring password offline. Fund the address from the public faucet (~11,000 ROGUE, one grant/address/24h):

ADDR=$(rogued keys show validator -a --keyring-backend file)
curl -s "https://faucet.roguelayer.one/send?address=$ADDR"   # or paste at faucet.roguelayer.one

Confirm balance:

rogued q bank balances $(rogued keys show validator -a --keyring-backend file)
# amounts in arogue; 1 ROGUE = 1000000000000000000arogue

8. Become a validator

# Consensus pubkey (ed25519, auto-generated at init)
PUBKEY=$(rogued comet show-validator)

cat > ~/validator.json <<EOF
{
  "pubkey": ${PUBKEY},
  "amount": "10000000000000000000000arogue",
  "moniker": "$(hostname)",
  "identity": "",
  "website": "",
  "security": "",
  "details": "",
  "commission-rate": "0.10",
  "commission-max-rate": "0.20",
  "commission-max-change-rate": "0.01",
  "min-self-delegation": "1000000000000000000"
}
EOF

rogued tx staking create-validator ~/validator.json \
  --from validator \
  --keyring-backend file \
  --chain-id rogue_4221-1 \
  --gas auto --gas-adjustment 1.5 \
  --gas-prices 0.0001arogue \
  -y

amount is in arogue (18 dec). min-self-delegation is a bare integer in arogue — "1000000000000000000" = 1 ROGUE. Never copy "1" from other chains (that is 10⁻¹⁸ ROGUE).

Verify

rogued q staking validator \
  $(rogued keys show validator --bech val -a --keyring-backend file)
# expect: status: BOND_STATUS_BONDED

Common failures

Symptom Fix
catching_up: true forever, n_peers: 0 nc -vz seed.roguelayer.one 26656; open inbound 26656: sudo ufw allow 26656/tcp
laddr bound to 127.0.0.1 Change to 0.0.0.0:26656 in ~/.evmd/config/config.toml, restart
insufficient funds Check balance is in arogue not urogue; top up at faucet.roguelayer.one (1 grant/address/24h)
key not found: validator Use --keyring-backend file consistently
Node halts at height Upgrade: replace binary (or pre-stage in cosmovisor) and restart

Operating

  • Back up ~/.evmd/config/priv_validator_key.json + priv_validator_state.json to a cold device.
  • Never run two nodes with the same priv_validator_key.json simultaneously. Double-sign = 5% slash + permanent tombstone.
  • Downtime: miss >50 of rolling 100 blocks → 1% slash + 10-min jail. Unjail:
    rogued tx slashing unjail --from validator --keyring-backend file \
  --chain-id rogue_4221-1 --gas auto --gas-prices 0.0001arogue
  • Monitor: rogued q slashing signing-info $(rogued comet show-address)
  • Upgrades: cosmovisor handles halt + restart; pre-stage the new binary at the announced height.

→ Newbie track · Agent instructions