Solidus Validator Guide

A complete guide to operating a Solidus validator node — from choosing your tier to monitoring your node’s health and understanding the economics.

Why Run a Validator?

Validators are the infrastructure operators of the Solidus network. Every identity verification, credential issuance, and authentication event is processed by a validator committee. Running a validator is:

Economically rational. Validators earn 70% of all network fees. At network scale, a Core Validator running at full capacity earns significantly more than its infrastructure costs. Light Nodes can be profitable at minimal cost.

Structurally necessary. Decentralized identity requires decentralized infrastructure. Every validator that joins the network increases its resilience, geographic coverage, and censorship resistance.

Governance-weighted. Validators have proportional influence in governance. The people who run the infrastructure shape how the protocol evolves.

Validator Tiers

Choose the tier that matches your stake and hardware capacity. You can upgrade tiers by increasing your stake and hardware at any time.

All tiers run the same solidus-node binary — there is no separate light client, and the tier is purely a function of stake size (it sets your reward weight and the hardware we recommend, not the software you run). Tier minimums are 10,000 (Light), 100,000 (Subnet), and 1,000,000 (Core) SLDS. Rewards are paid in SLDS at the end of each epoch (7 days); actual earnings depend on network activity, uptime, and reputation. (Concrete reward figures aren’t quoted while the network is on testnet — see the tokenomics page for the emission model.)

Hardware Requirements

All tiers run the same solidus-node binary — heavier tiers just warrant beefier hardware for higher stake and throughput. These figures track the canonical, always-current spec at node.solidus.network/docs/hardware.

Reference instances (see node.solidus.network/docs/hardware for the live list): Light — Hetzner CX22 ($5.40/mo, 2 vCPU · 4 GB); Subnet — Hetzner CCX23 ($32/mo, 4 dCPU · 16 GB); Core — a dedicated NVMe instance in the $120–400/mo range. There is no separate light client — every tier runs the full node.

Uptime Requirements

All tiers must maintain 95% uptime averaged over a rolling 30-day window. This allows approximately 36 hours of downtime per month for maintenance.

• > 99% uptime: Full rewards
• 95–99% uptime: Partial rewards (proportional to uptime)
• < 95% uptime: Slashing risk begins (see Slashing section)
• < 80% uptime over 30 days: Automatic removal from active validator set

Software Setup

Step 1: Install Solidus Node

# Download the Solidus node binary
curl -sSL https://releases.solidus.network/latest/install.sh | bash
 
# Verify the installation
solidus-node --version
# solidus-node v1.0.0 (commit: abc1234)

For manual installation:

# Download and verify the binary
wget https://releases.solidus.network/v1.0.0/solidus-node-linux-amd64.tar.gz
wget https://releases.solidus.network/v1.0.0/solidus-node-linux-amd64.tar.gz.sha256
 
sha256sum -c solidus-node-linux-amd64.tar.gz.sha256
# solidus-node-linux-amd64.tar.gz: OK
 
tar -xzf solidus-node-linux-amd64.tar.gz
sudo mv solidus-node /usr/local/bin/

Step 2: Generate Your Node Keys

# Generate a new Ed25519 keypair for your node identity
solidus-node keygen --output /etc/solidus/node-key.json
 
# The output contains:
# {
#   "public_key": "<base58-encoded Ed25519 public key>",
#   "key_file":   "/etc/solidus/node-key.json"
# }

Back up your key file immediately. Losing your node key means losing access to your validator identity and staked SLDS. Store the backup encrypted and offline.

Step 3: Configure Your Node

Create /etc/solidus/config.toml:

[node]
# Node identity
name        = "my-validator-node"
tier        = "light"   # "light", "subnet", or "core"
network     = "testnet" # "testnet" or "mainnet"
key_file    = "/etc/solidus/node-key.json"
 
[network]
listen_addr = "0.0.0.0:9651"
external_ip = "203.0.113.42"   # your public IP
bootstrap_nodes = [
  "bootstrap1.solidus.network:9651",
  "bootstrap2.solidus.network:9651",
  "bootstrap3.solidus.network:9651",
]
 
[consensus]
# Subnets this node participates in (leave empty for auto-assignment)
subnets = []
 
[storage]
data_dir    = "/var/lib/solidus"
# State pruning is planned but not yet available — all nodes currently keep
# full history (there is no separate "light" storage mode).
 
[api]
enabled     = true
listen_addr = "127.0.0.1:9652"
# Never expose the API on a public interface without authentication
 
[metrics]
enabled     = true
listen_addr = "127.0.0.1:9653"
# Prometheus-compatible metrics endpoint

Step 4: Start the Node

# Create systemd service for automatic startup and restart
cat > /etc/systemd/system/solidus-node.service << 'EOF'
[Unit]
Description=Solidus Network Node
After=network.target
Wants=network.target
 
[Service]
Type=simple
User=solidus
Group=solidus
ExecStart=/usr/local/bin/solidus-node start --config /etc/solidus/config.toml
Restart=always
RestartSec=10
LimitNOFILE=65536
StandardOutput=journal
StandardError=journal
 
[Install]
WantedBy=multi-user.target
EOF
 
systemctl daemon-reload
systemctl enable solidus-node
systemctl start solidus-node
 
# Check status
systemctl status solidus-node
journalctl -u solidus-node -f

Step 5: Verify Sync

# Check sync status via the local API
curl http://127.0.0.1:9652/status | jq
 
# Expected output:
# {
#   "synced": true,
#   "block_height": 142857,
#   "block_hash": "0x4f8e2a1b...",
#   "peer_count": 47,
#   "uptime_seconds": 86400
# }

Your node must be fully synced before you can stake. Sync time depends on your hardware and network connection: Light Nodes typically sync in 10-30 minutes; Core Validators with full history may take several hours.

Staking and Registration

Step 1: Fund Your Staking Wallet

You need SLDS tokens equal to or greater than your chosen tier’s minimum stake. Acquire SLDS through the Solidus bridge (from ETH or other chains) or from a DEX listing.

Step 2: Register as a Validator

# Register your node as a validator
# This transaction stakes your SLDS and registers your node identity
solidus-node validator register \
  --tier light \
  --stake 10000 \
  --wallet-address <your-wallet-address> \
  --identity-did <your-personal-did>
 
# You will be prompted to sign the transaction with your wallet.
# After signing, the registration is submitted to the network.

Registration requires:

1. Your node to be running and synced
2. Your SLDS tokens to be in a wallet you control
3. Your identity DID (you must have completed KYC Level 2 to validate)
4. A verified human identity — one human, one validator identity

Step 3: Wait for Activation

Validator registration goes through a 24-hour activation delay. This delay prevents last-second stake manipulation and allows the network to verify your identity and uptime. During the activation period:

• Your SLDS is staked and locked
• Your node is monitored for uptime
• You are not yet earning rewards

After activation, your node appears in the active validator set.

Step 4: Confirm Active Status

solidus-node validator status --node-id <your-node-id>
 
# Output:
# Status:         active
# Tier:           Light
# Stake:          10,000 SLDS
# Reputation:     850 / 1000
# Uptime (30d):   99.2%
# Rewards earned: 842.50 SLDS (this epoch)
# Next payout:    2026-03-21 00:00:00 UTC

Monitoring

Built-in Metrics (Prometheus)

The node exposes Prometheus-compatible metrics at http://127.0.0.1:9653/metrics. Connect Grafana or any Prometheus-compatible dashboarding tool.

Key metrics to monitor:

Log Monitoring

# Watch for errors in real time
journalctl -u solidus-node -f --grep "ERROR\|WARN\|CRITICAL"
 
# Key log events to watch for:
# WARN  consensus_timeout — your node is falling behind on consensus rounds
# WARN  peer_count_low — fewer than 5 peers connected
# ERROR signature_verification_failed — potential network or key issue
# ERROR disk_write_failed — storage problem, act immediately
# CRITICAL node_slashed — immediate action required

Alerting Recommendations

Configure alerts (PagerDuty, Opsgenie, email) for:

• Uptime < 99% over the last 24 hours
• Peer count < 5
• Sync lag > 10 blocks for more than 5 minutes
• Reputation score drop of more than 20 points in one epoch
• Disk space below 100 GB
• Any CRITICAL log entry

Slashing Conditions

Slashing reduces your staked SLDS. These are the behaviors the protocol penalizes:

Slashing is rare in honest operation. The most common cause is unplanned downtime (hardware failure, provider outage, misconfiguration). Maintain backups, monitor aggressively, and use redundant infrastructure for Subnet and Core tiers.

What to Do If You’re Slashed

1. Check the slash event in the dashboard or via solidus-node validator status
2. Identify the cause from your logs
3. Fix the underlying issue before bringing the node back online
4. If you believe the slash was incorrect, submit a governance appeal within 48 hours

Upgrading Your Node

When a new version of solidus-node is released:

# Download the new binary
wget https://releases.solidus.network/v1.x.x/solidus-node-linux-amd64.tar.gz
sha256sum -c solidus-node-linux-amd64.tar.gz.sha256
 
# Stop the node gracefully (allows in-progress consensus rounds to complete)
systemctl stop solidus-node
 
# Replace the binary
tar -xzf solidus-node-linux-amd64.tar.gz
sudo mv solidus-node /usr/local/bin/
 
# Start the node
systemctl start solidus-node
 
# Verify the new version
solidus-node --version

Never run two instances of solidus-node simultaneously with the same key. This will be detected as equivocation and result in a slash.

Major protocol upgrades require all validators to upgrade within a specified window. Failure to upgrade before the activation block results in your node being incompatible with the new protocol version and ejection from the active validator set.

Economics Deep Dive

How Rewards Are Calculated

At the end of each epoch (7 days):

1. Total fees collected across all transactions in the epoch are summed.
2. 70% of that total is allocated to the validator reward pool.
3. Each validator’s share is proportional to their effective stake weight: effective_stake = stake × (uptime_score × reputation_score)
4. Your reward = (effective_stake / total_effective_stake) × reward_pool

Reputation Score Impact

Your reputation score starts at 800 and evolves based on behavior:

A validator with a reputation of 1,000 earns more rewards than one with 800, even at the same stake level, because their effective stake weight is higher.

Break-Even Analysis

Light Node:

Break-even depends on SLDS token price. At $1/SLDS: Low activity returns $50/month on $15/month operating costs — profitable at any meaningful network activity.

Subnet Validator:

FAQ

Q: Can I run multiple validators? One human can control multiple validator nodes, but each node must have a unique identity DID. You cannot use the same DID for multiple nodes. Multiple nodes controlled by the same human entity count toward that entity’s stake weight but do not reduce Sybil resistance (the identity cost is still paid once).

Q: Can I unstake my SLDS? Yes. Submit an unstaking request through the Solidus governance dashboard. There is a 21-day unbonding period during which your SLDS is locked and earns no rewards. After 21 days the tokens are returned to your wallet.

Q: What happens to my stake if I’m slashed? The slashed amount is sent to the protocol treasury. It is not distributed to other validators or burned. You keep the remaining stake.

Q: Do I need a static IP address? Yes for Subnet and Core validators. Light Nodes can operate with dynamic IPs but static IPs result in better peer connectivity and uptime scores.

Q: Can I run a validator from my home? A Light Node can run on a home server or desktop with a stable internet connection. Subnet and Core validators should run on dedicated hardware or in a data center. Home ISPs typically do not offer the bandwidth, uptime guarantees, or static IPs required for higher tiers.

Q: How do I join a specific subnet? Geographic subnets require you to operate your hardware in the subnet’s geographic region (verified by IP geolocation). Organizational subnets require an invitation from the subnet creator. Specialized subnets are assigned by the protocol based on stake and performance.

Q: What is the minimum KYC level to become a validator? All validators must complete KYC Level 2 (document + liveness detection) to verify they are human. This is non-negotiable — under Solidus’s identity-anchored validator model (the “Proof of Identity” eligibility layer on top of the BFT consensus engine), every validator is a verified unique human.

Q: When does mainnet launch? See the Solidus Roadmap (docs/roadmap.md). Testnet validators who operate reliably through Phase 1 will have priority in the mainnet genesis validator set.

Support

• Discord: discord.solidus.network → #validators channel
• Validator Dashboard: validators.solidus.network
• Documentation: dev.solidus.network/docs/validators
• Emergency: [email protected] (for slashing or critical issues only)
• Office hours: Every Tuesday 16:00 UTC, validator Q&A on Discord

Validator operators who have been active on testnet for more than 30 days get priority support response times.