Validator Operations

Integralayer Validator Setup Guide

Complete guide for setting up and managing validators on the Integralayer mainnet network

Network Status

Integralayer mainnet is live. This guide covers the production mainnet setup.

Network Configuration

Essential network parameters for Integralayer mainnet validators

Chain Parameters

Chain ID (Cosmos)

integra-1

Chain ID (EVM)

26217

Native TokenIRL

Base Denominationairl

Decimals18

Address Prefixintegra

Endpoints

Cosmos RPC

https://rpc.integralayer.com

REST API

https://api.integralayer.com

EVM JSON-RPC

https://evm.integralayer.com

Block Explorer

https://explorer.integralayer.com

WebSocket

wss://rpc.integralayer.com/websocket

Unbonding Period

21 Days

Max Validators

100

Block Time

~5 sec

System Requirements

Hardware specifications for running a reliable validator node

MINIMUM REQUIREMENTS

4+ CPU cores (2.0 GHz+)

16GB RAM

500GB SSD (NVMe preferred)

100 Mbps connection

Cloud Provider Quick Start

Recommended VM specifications on popular cloud providers:

DigitalOcean

General Purpose 4vCPU / 16GB

~$96/mo (gp-4vcpu-16gb)

AWS

m6i.xlarge (4vCPU / 16GB)

~$140/mo on-demand

Hetzner

CPX41 (8vCPU / 16GB)

~$28/mo

Select Ubuntu 24.04 LTS x64 image. Ensure ports 26656 (P2P), 26657 (RPC), 8545 (EVM RPC) are open.

Step 1: Install Dependencies

Required software and tools for validator setup

Update system and install build tools:

Terminal

# Update system packages
sudo apt update && sudo apt upgrade -y

# Install essential build tools
sudo apt install -y build-essential git curl wget jq lz4 make gcc

Install Go 1.21+ (required for building from source):

Install Go

# Download Go 1.21.5
wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz

# Remove old Go and extract new version
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

# Add Go to PATH (add to ~/.bashrc for persistence)
echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> ~/.bashrc
source ~/.bashrc

# Verify installation
go version
# Expected output: go version go1.21.5 linux/amd64

Step 2: Install intgd Binary

Download or build the Integralayer daemon

Binary Name

The Integralayer daemon is called intgd. All commands use this binary.

Important: Build Location

The intgd binary is built from the integra/ subfolder, NOT the repository root. Running make install at the root builds the generic evmd binary which will not work.

Build from source

# Clone the repository
git clone https://github.com/integralayer/integra-evm.git
cd integra-evm

# Checkout latest stable release
git checkout main  # Or specific version tag

# IMPORTANT: Build from the integra/ subfolder
cd integra
make install

# Verify installation
intgd version

# The binary is installed to $HOME/go/bin/intgd
# Ensure $HOME/go/bin is in your PATH

Step 3: Initialize Node

Configure your node for the Integralayer network

Home Directory

The Integralayer node uses ~/.intgd/ as its home directory. If you see references to ~/.evmd elsewhere, those are for the generic EVM daemon - always use ~/.intgd/ for Integralayer.

Initialize the node with your validator moniker:

Initialize node

# Set your validator name (replace with your chosen name)
MONIKER="YourValidatorName"

# Initialize the node
intgd init "$MONIKER" --chain-id integra-1

# This creates the config directory at ~/.intgd/
# All config files are in ~/.intgd/config/
# Data is stored in ~/.intgd/data/

Download the genesis file:

Download genesis

# Download genesis from RPC
curl -s https://rpc.integralayer.com/genesis | jq '.result.genesis' > ~/.intgd/config/genesis.json

# Verify genesis file (should show chain_id: integra-1)
cat ~/.intgd/config/genesis.json | jq '.chain_id'

Configure persistent peers and seeds:

Configure peers

# Get peers from the network (example peers - get actual peers from Discord)
PEERS="node_id@ip:26656,node_id@ip:26656"

# Update config.toml
sed -i "s/persistent_peers = ""/persistent_peers = "$PEERS"/" ~/.intgd/config/config.toml

# Set minimum gas prices (important!)
sed -i 's/minimum-gas-prices = ""/minimum-gas-prices = "0.025airl"/' ~/.intgd/config/app.toml

Configure pruning (recommended for validators):

Configure pruning

# Edit app.toml for efficient storage
sed -i 's/pruning = "default"/pruning = "custom"/' ~/.intgd/config/app.toml
sed -i 's/pruning-keep-recent = "0"/pruning-keep-recent = "100"/' ~/.intgd/config/app.toml
sed -i 's/pruning-keep-every = "0"/pruning-keep-every = "0"/' ~/.intgd/config/app.toml
sed -i 's/pruning-interval = "0"/pruning-interval = "10"/' ~/.intgd/config/app.toml

Step 4: Create Validator Keys

Generate your validator and operator keys

Security Critical

Back up your mnemonic phrase! Store it securely offline. Loss of this phrase means loss of access to your validator and funds.

Create a new validator key:

Create validator key

# Create a new key (will prompt for keyring password)
intgd keys add validator --keyring-backend file

# IMPORTANT: Save the mnemonic phrase shown!
# It will look like: "word1 word2 word3 ... word24"

# Show your validator address
intgd keys show validator -a --keyring-backend file
# Output: integra1xxxxxxxxxxxxxxxxxxxxxxxxx

# Show your EVM-compatible address
intgd keys show validator --keyring-backend file | grep "address" | head -1

Or recover an existing key:

Recover existing key

# Recover from mnemonic phrase
intgd keys add validator --recover --keyring-backend file
# Enter your 24-word mnemonic when prompted

Step 5: Start Node & Sync

Start your node and sync with the network

Create a systemd service for automatic management:

/etc/systemd/system/intgd.service

sudo tee /etc/systemd/system/intgd.service > /dev/null <<EOF
[Unit]
Description=Integralayer Node
After=network-online.target

[Service]
User=$USER
ExecStart=$(which intgd) start --chain-id integra-1
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

Required: --chain-id Flag

The --chain-id integra-1 flag is required when starting the node. Without it, you'll get an "invalid chain-id on InitChain" error.

Enable and start the service:

Start node

# Reload systemd
sudo systemctl daemon-reload

# Enable service to start on boot
sudo systemctl enable intgd

# Start the node
sudo systemctl start intgd

# Check logs (Ctrl+C to exit)
sudo journalctl -u intgd -f -o cat

Check sync status:

Check sync status

# Check if node is syncing
intgd status | jq '.SyncInfo'

# Wait until catching_up: false before creating validator
# This may take several hours depending on chain height

State Sync (Optional - Faster)

For faster syncing, you can enable state sync. Contact the team on Telegram for current state sync configuration.

Step 6: Create Validator

Prerequisites

Your node must be fully synced (catching_up: false)
You need IRL tokens for self-delegation and gas fees
Request tokens from the faucet or team for initial setup

Get your validator public key:

Get validator pubkey

# Show your validator consensus public key
intgd tendermint show-validator

# Output will look like:
# {"@type":"/cosmos.crypto.ed25519.PubKey","key":"BASE64_KEY_HERE"}

Create the validator transaction:

Create validator

# Create validator (adjust values as needed)
intgd tx staking create-validator \
  --amount=1000000000000000000airl \
  --pubkey=$(intgd tendermint show-validator) \
  --moniker="YourValidatorName" \
  --website="https://yourwebsite.com" \
  --details="Your validator description" \
  --identity="YOUR_KEYBASE_ID" \
  --security-contact="security@youremail.com" \
  --chain-id=integra-1 \
  --commission-rate="0.05" \
  --commission-max-rate="0.20" \
  --commission-max-change-rate="0.01" \
  --min-self-delegation="1" \
  --gas=auto \
  --gas-adjustment=1.5 \
  --gas-prices=0.025airl \
  --from=validator \
  --keyring-backend=file \
  -y

Parameter Explanation:

--amount: Self-delegation amount (1000000000000000000airl = 1 IRL)
--commission-rate: Starting commission (0.05 = 5%)
--commission-max-rate: Maximum commission you can ever charge (0.20 = 20%)
--commission-max-change-rate: Maximum daily commission change (0.01 = 1%)
--identity: Your Keybase.io identity for avatar display

Verify your validator was created:

Verify validator