# Welcome

**About Us**

Noderuner is a platform specialized in providing node services within blockchain technology. With our strong server infrastructure, we offer high-performance and seamless operations, contributing to the ecosystem through reliable and efficient node management. Our goal is to add value by supporting the blockchain network and ensuring its stability.

At Noderuner, we not only provide services but also prioritize knowledge sharing. Through setup guides and content, we help newcomers navigate the world of blockchain, fostering community growth. With our trustworthy and innovative solutions, we continue to contribute to the development of the blockchain ecosystem.


# Gno.Land Topaz

<figure><img src="/files/TG8QZW7BNeGlBNImj8VL" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://topaz-gnoland-rpc.noderuner.xyz
```


# 🔌 Installation

## Gno.land Topaz Node Setup Guide

This guide covers how to set up a Gno.land Topaz full node on an Ubuntu VPS, create a systemd service, and maintain the node with useful day-to-day commands.

> Note: Topaz testnet parameters may change over time. Before installing, verify the current `chain_id`, genesis file, branch, and peer information from official Gno.land sources or the latest network announcements.

### Overview

```
Network: Gno.land Topaz
Chain ID: topaz-1
P2P Port: 26656
Local RPC: 127.0.0.1:26657
Branch: chain/topaz
Data path: /root/gno/gnoland-data
```

This guide does not expose RPC publicly. RPC is kept local on `127.0.0.1:26657`. For external network connectivity, only the P2P port `26656/tcp` is required.

### Server Requirements

Recommended minimum:

```
CPU: 4 cores
RAM: 8 GB
Disk: 200 GB+ SSD
OS: Ubuntu 22.04 / 24.04
Network: 100 Mbps+
```

### Environment Variables

The guide uses the following variables:

```
export MONIKER="node-moniker"
export CHAIN_ID="topaz-1"
export GNO_HOME="/root/gno"
export GNO_DATA="/root/gno/gnoland-data"
export GO_VERSION="1.25.12"
```

Replace `MONIKER` with your own node name.

### 1. Prepare the System

Update the server:

```
apt update
apt upgrade -y
```

Install required packages:

```
apt install -y curl wget git jq lz4 unzip tar build-essential make gcc chrony ca-certificates
```

Enable time synchronization:

```
systemctl enable --now chrony
chronyc tracking
```

### 2. Configure Firewall

If you use UFW, allow SSH and the P2P port:

```
apt install -y ufw
ufw allow OpenSSH
ufw allow 26656/tcp
ufw enable
ufw status
```

Do not expose the RPC port publicly:

```
# 26657/tcp should not be opened publicly
```

### 3. Install Go

Remove any old Go installation:

```
rm -rf /usr/local/go
```

Download and install Go:

```
cd /root
wget "https://golang.org/dl/go${GO_VERSION}.linux-amd64.tar.gz"
tar -C /usr/local -xzf "go${GO_VERSION}.linux-amd64.tar.gz"
rm "go${GO_VERSION}.linux-amd64.tar.gz"
```

Add Go and Gno paths:

```
echo 'export PATH=/usr/local/go/bin:$HOME/go/bin:$PATH' >> ~/.bashrc
echo 'export GNOROOT=$HOME/gno' >> ~/.bashrc
source ~/.bashrc
```

Verify the installation:

```
go version
```

### 4. Build Gno From Source

Clone the repository:

```
cd /root
git clone https://github.com/gnolang/gno.git
cd /root/gno
git checkout chain/topaz
```

Build the binaries:

```
make install
make -C gno.land install.gnoland
make -C contribs/gnogenesis install
```

Verify the binaries:

```
which gnoland
which gnokey
gnoland version
gnokey version
```

The expected `gnoland` binary path is usually:

```
/root/go/bin/gnoland
```

### 5. Prepare Genesis and Initial Data

If an old or broken node data directory exists, make sure the service is stopped first:

```
systemctl stop gnoland 2>/dev/null || true
```

Download the Topaz genesis file:

```
cd /root/gno
rm -rf gnoland-data genesis.json
wget -O genesis.json https://github.com/gnolang/gno/releases/download/chain/topaz/genesis.json
```

Check the genesis hash:

```
shasum -a 256 genesis.json
```

Genesis hash used by current setup references:

```
2dd049f973b82858727440df9aff5722cb0b322fd00890f40f2b0688276898ff  genesis.json
```

Initialize node config and secrets:

```
cd /root/gno
gnoland secrets init
gnoland config init
```

### 6. Configure the Node

Set your moniker and the main node parameters:

```
cd /root/gno

gnoland config set moniker "$MONIKER"
gnoland config set application.prune_strategy syncable
gnoland config set consensus.timeout_commit 3s
gnoland config set consensus.peer_gossip_sleep_duration 10ms
gnoland config set p2p.flush_throttle_timeout 10ms
gnoland config set p2p.pex true
gnoland config set p2p.max_num_outbound_peers 40
gnoland config set mempool.size 10000
gnoland config set telemetry.metrics_enabled false
gnoland config set p2p.laddr "tcp://0.0.0.0:26656"
gnoland config set rpc.laddr "tcp://127.0.0.1:26657"
gnoland config set p2p.external_address "YOUR-SERVER-IP:26656"
gnoland config set p2p.persistent_peers "g19q07ssuafhmg6r7ys7wp7rpc4jxc85cpvdy426@seed-1.topaz.testnets.gno.land:26656,g15k98e65gm8h7fdr3yr4tqn82lvch4a97a3sg3j@seed-2.topaz.testnets.gno.land:26656"
```

Replace `YOUR-SERVER-IP` with your VPS public IP address.

Check the config:

```
grep -n "^\[p2p\]\|^\[rpc\]\|laddr\|external_address\|persistent_peers" /root/gno/gnoland-data/config/config.toml
```

RPC should remain local:

```
laddr = "tcp://127.0.0.1:26657"
```

P2P should listen publicly:

```
laddr = "tcp://0.0.0.0:26656"
```

### 7. Test Manual Startup

Before creating the service, run a short manual test:

```
cd /root/gno
gnoland start \
  --chainid topaz-1 \
  --genesis /root/gno/genesis.json \
  --skip-genesis-sig-verification
```

In another SSH session, check the local RPC:

```
curl -s http://127.0.0.1:26657/status | jq
```

If it works, stop the manually running node with `CTRL + C`.

### 8. Create a Systemd Service

Create the service file:

```
nano /etc/systemd/system/gnoland.service
```

Service file:

```
[Unit]
Description=Gno.land Topaz Node
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=root
Group=root
WorkingDirectory=/root/gno
Environment=GNOROOT=/root/gno
Environment=HOME=/root
ExecStart=/root/go/bin/gnoland start --chainid topaz-1 --genesis /root/gno/genesis.json --skip-genesis-sig-verification
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
StandardOutput=journal
StandardError=journal
SyslogIdentifier=gnoland

[Install]
WantedBy=multi-user.target
```

Enable and start the service:

```
systemctl daemon-reload
systemctl enable gnoland
systemctl start gnoland
```

Check the service status:

```
systemctl status gnoland
```

Follow live logs:

```
journalctl -u gnoland -f --no-hostname -o cat
```

### 9. Check Sync and Node Status

RPC status:

```
curl -s http://127.0.0.1:26657/status | jq
```

Sync status:

```
curl -s http://127.0.0.1:26657/status | jq '.result.sync_info'
```

Latest block height:

```
curl -s http://127.0.0.1:26657/status | jq -r '.result.sync_info.latest_block_height'
```

Peer count:

```
curl -s http://127.0.0.1:26657/net_info | jq '.result.n_peers'
```

Validator set:

```
curl -s http://127.0.0.1:26657/validators | jq
```

### 10. Useful Service Commands

Start the node:

```
systemctl start gnoland
```

Stop the node:

```
systemctl stop gnoland
```

Restart the node:

```
systemctl restart gnoland
```

Check service status:

```
systemctl status gnoland
```

Follow live logs:

```
journalctl -u gnoland -f --no-hostname -o cat
```

Show the last 100 log lines:

```
journalctl -u gnoland -n 100 --no-pager
```

Enable the service on boot:

```
systemctl enable gnoland
```

Disable the service on boot:

```
systemctl disable gnoland
```

### 11. Useful Node Commands

Check the binary:

```
which gnoland
gnoland version
```

Check ports:

```
ss -tulpn | grep -E '26656|26657'
```

Show node ID:

```
gnoland secrets get node_id
```

Show validator public key:

```
cd /root/gno
gnoland secrets get validator_key
```

View node config:

```
cat /root/gno/gnoland-data/config/config.toml
```

Quickly check P2P and RPC settings:

```
grep -n "^\[p2p\]\|^\[rpc\]\|laddr\|external_address\|persistent_peers" /root/gno/gnoland-data/config/config.toml
```

### 12. Log and Disk Maintenance

Check disk usage:

```
df -h
du -h --max-depth=1 /var 2>/dev/null | sort -h
du -h --max-depth=1 /var/log 2>/dev/null | sort -h
```

Find the largest log files:

```
find /var/log -maxdepth 1 -type f -printf '%s %p\n' 2>/dev/null | sort -nr | head -20
```

Check journal usage:

```
journalctl --disk-usage
```

Configure journald limits:

```
nano /etc/systemd/journald.conf
```

Keep these values active:

```
[Journal]
Storage=auto
Compress=yes
SystemMaxUse=500M
RuntimeMaxUse=100M
MaxRetentionSec=3day
```

Apply the changes:

```
systemctl restart systemd-journald
journalctl --vacuum-size=200M
```

### 13. Update the Node

Stop the service before updating:

```
systemctl stop gnoland
```

Update the source code:

```
cd /root/gno
git fetch --all --tags
git checkout chain/topaz
git pull
```

Rebuild the binaries:

```
make install
make -C gno.land install.gnoland
make -C contribs/gnogenesis install
```

Verify the version:

```
gnoland version
```

Start the service:

```
systemctl start gnoland
journalctl -u gnoland -f --no-hostname -o cat
```

### 14. Backup

Back up config and secret files:

```
mkdir -p /root/backups
tar -czf /root/backups/gnoland-config-$(date +%F).tar.gz \
  /root/gno/gnoland-data/config \
  /root/gno/gnoland-data/secrets \
  /root/gno/genesis.json
```

Download the backup to another machine:

```
scp root@SERVER_IP:/root/backups/gnoland-config-YYYY-MM-DD.tar.gz .
```

### 15. Quick Troubleshooting

If the node does not start:

```
systemctl status gnoland
journalctl -u gnoland -n 100 --no-pager
```

If RPC does not respond:

```
curl -s http://127.0.0.1:26657/status | jq
ss -tulpn | grep 26657
```

If there are no peers:

```
curl -s http://127.0.0.1:26657/net_info | jq '.result.n_peers'
grep -n "persistent_peers\|external_address" /root/gno/gnoland-data/config/config.toml
```

If the disk is full:

```
df -h
du -h --max-depth=1 /var/log 2>/dev/null | sort -h
journalctl --vacuum-size=200M
```

After changing the config:

```
systemctl restart gnoland
```

### Sources

* Gno.land official installation docs: <https://docs.gno.land/builders/install/>
* Gno.land getting started: <https://docs.gno.land/builders/getting-started/>
* Gno.land networks: <https://docs.gno.land/resources/gnoland-networks/>
* Gno.land GitHub repository: <https://github.com/gnolang/gno>
* Topaz setup reference: <https://guides.hazennetworksolutions.com/gnoland/>


# Titan Network

<figure><img src="/files/aWIGmsD9Wurf7bOUzepR" alt=""><figcaption></figcaption></figure>

[https://titan-testnet-rpc.noderuner.xyz](https://titan-testnet-rpc.noderuner.xyz/)

[https://titan-testnet-api.noderuner.xyz](https://titan-testnet-rpc.noderuner.xyz/)


# 🔌 Installation

Set up dependencies

```
sudo apt update && sudo apt upgrade -y
sudo apt install curl git wget htop tmux build-essential jq make lz4 gcc unzip -y
```

Go installation

```
cd $HOME
GOVER="1.21.6"
wget -q --show-progress "https://golang.org/dl/go$GOVER.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$GOVER.linux-amd64.tar.gz"
rm "go$GOVER.linux-amd64.tar.gz"
[ ! -f ~/.bash_profile ] && touch ~/.bash_profile
echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> ~/.bash_profile
source ~/.bash_profile
[ ! -d "$HOME/go/bin" ] && mkdir -p "$HOME/go/bin"
go version
```

Configuration

```
git clone https://github.com/Titannet-dao/titan-chain.git
cd titan-chain
go build ./cmd/titand
cp titand /usr/local/bin
```

Initialize Titan Validator

```
titand init Moniker-Name --chain-id titan-test-3
```

Custom Name Setting

```
nano ~/.titan/config/config.toml
```

moniker = ""edit the line

Configuring Genesis Files

```
wget https://raw.githubusercontent.com/Titannet-dao/titan-chain/main/genesis/genesis.json
mv genesis.json ~/.titan/config/genesis.json
```

`config.toml`Open **the Seeds and Peers** file `seeds`and `persistent_peers`edit its fields:

```
nano ~/.titan/config/config.toml
```

```
seeds = "bb075c8cc4b7032d506008b68d4192298a09aeea@47.76.107.159:26656"
```

Configuring Gas Prices and Charges

```
nano ~/.titan/config/app.toml
```

```
minimum-gas-prices = "0.0025uttnt"
```

Creating Systemd Service File

```
sudo nano /etc/systemd/system/titan.service
```

```
[Unit]
Description=Titan Daemon
After=network-online.target

[Service]
User=root
ExecStart=/usr/local/bin/titand start
Restart=always
RestartSec=3
LimitNOFILE=4096

[Install]
WantedBy=multi-user.target

```

Enable and Start the Service

```
sudo systemctl enable titan.service
sudo systemctl start titan.service
```

Status Check

```
sudo systemctl status titan.service
```

Check logs

```
journalctl -fu allorad -o cat
```

Create your account

```
titand keys add <name>
```

**Create validator config file**

```
nano ~/validator.json
```

```
{
 "pubkey":  "<pubkey>",
 "amount": "<amount>uttnt",
 "moniker": "<moniker>",
 "commission-rate": "0.07",
 "commission-max-rate": "1.0",
 "commission-max-change-rate": "0.01",
 "min-self-delegation": "1",
 "identity": "<identity>",
 "website": "<website>",
 "security": "<security>",
 "details": "<details>"
}
```

```
titand tx staking create-validator ~/validator.json --from <account> --fees 500uttnt --ip <ip>
```


# Allora Network

<figure><img src="/files/Hmm0Bm4onb0RbScl01ED" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://allora-testnet-rpc.noderuner.xyz
https://allora-testnet-api.noderuner.xyz
```


# 🔌 Installation

### Install Go and Cosmovisor

Feel free to skip this step if you already have Go and Cosmovisor.

**Install Go**

We will use Go `v1.22.4` as example here. The code below also cleanly removes any previous Go installation.

```
sudo rm -rvf /usr/local/go/
wget https://golang.org/dl/go1.22.4.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.22.4.linux-amd64.tar.gz
rm go1.22.4.linux-amd64.tar.gz
```

**Configure Go**

Unless you want to configure in a non-standard way, then set these in the `~/.profile` file.

```
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
```

**Install Cosmovisor**

We will use Cosmovisor `v1.0.0` as example here.

```
go install github.com/cosmos/cosmos-sdk/cosmovisor/cmd/cosmovisor@v1.0.0
```

### Install Node

Install the current version of node binary.

```
git clone https://github.com/allora-network/allora-chain allora
cd allora
git checkout v0.4.0
make install
```

### Configure Node

**Initialize Node**

Please replace `YOUR_MONIKER` with your own moniker.

```
allorad init YOUR_MONIKER --chain-id allora-testnet-1
```

**Download Genesis**

The genesis file link below is Polkachu's mirror download. The best practice is to find the official genesis download link.

```
wget -O genesis.json https://snapshots.polkachu.com/testnet-genesis/allora/genesis.json --inet4-only
mv genesis.json ~/.allorad/config
```

**Configure Seed**

```
sed -i 's/seeds = ""/seeds = "ade4d8bc8cbe014af6ebdf3cb7b1e9ad36f412c0@testnet-seeds.polkachu.com:26756"/' ~/.allorad/config/config.toml
```

### Launch Node

**Configure Cosmovisor Folder**

Create Cosmovisor folders and load the node binary.

```
# Create Cosmovisor Folders
mkdir -p ~/.allorad/cosmovisor/genesis/bin
mkdir -p ~/.allorad/cosmovisor/upgrades

# Load Node Binary into Cosmovisor Folder
cp ~/go/bin/allorad ~/.allorad/cosmovisor/genesis/bin
```

**Create Service File**

Create a `allora.service` file in the `/etc/systemd/system` folder with the following code snippet. Make sure to replace `USER` with your Linux user name. You need sudo previlege to do this step.

```
[Unit]
Description="allora node"
After=network-online.target

[Service]
User=USER
ExecStart=/home/USER/go/bin/cosmovisor start
Restart=always
RestartSec=3
LimitNOFILE=4096
Environment="DAEMON_NAME=allorad"
Environment="DAEMON_HOME=/home/USER/.allorad"
Environment="DAEMON_ALLOW_DOWNLOAD_BINARIES=false"
Environment="DAEMON_RESTART_AFTER_UPGRADE=true"
Environment="UNSAFE_SKIP_BACKUP=true"

[Install]
WantedBy=multi-user.target
```

**Start Node Service**

```
# Enable service
sudo systemctl enable allora.service

# Start service
sudo service allora start

# Check logs
sudo journalctl -fu allora
```


# Story Protocol

<figure><img src="/files/w9U9uTuvWWv7VAWAmdS5" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://story-testnet-rpc.noderuner.xyz
https://story-testnet-api.noderuner.xyz
```


# Installation

```
sudo apt update && sudo apt upgrade -y
sudo apt install curl git wget htop tmux build-essential jq make lz4 gcc unzip -y
```

```
# install go
cd $HOME
VER="1.22.3"
wget "https://golang.org/dl/go$VER.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$VER.linux-amd64.tar.gz"
rm "go$VER.linux-amd64.tar.gz"
[ ! -f ~/.bash_profile ] && touch ~/.bash_profile
echo "export PATH=$PATH:/usr/local/go/bin:~/go/bin" >> ~/.bash_profile
source $HOME/.bash_profile
[ ! -d ~/go/bin ] && mkdir -p ~/go/bin
```

Edit the Moniker name according to yourself!

```
echo "export MONIKER="MONİKER NAME"" >> $HOME/.bash_profile
echo "export STORY_CHAIN_ID="iliad-0"" >> $HOME/.bash_profile
echo "export STORY_PORT="52"" >> $HOME/.bash_profile
source $HOME/.bash_profile
```

Download the binary file

```
cd $HOME
wget -O geth https://github.com/piplabs/story-geth/releases/download/v0.9.4/geth-linux-amd64
chmod +x $HOME/geth
mv $HOME/geth ~/go/bin/
[ ! -d "$HOME/.story/story" ] && mkdir -p "$HOME/.story/story"
[ ! -d "$HOME/.story/geth" ] && mkdir -p "$HOME/.story/geth"
```

Proceed to the installation process

```
cd $HOME
rm -rf story
git clone https://github.com/piplabs/story
cd story
git checkout v0.11.0
go build -o story ./client 
mv $HOME/story/story $HOME/go/bin/
```

Launch the Story app (Don't forget to edit the Moniker Name according to yourself

```
story init --moniker MONİKER NAME --network iliad
```

Seed And Peers !

```
SEEDS="5a0191a6bd8f17c9d2fa52386ff409f5d796d112@b1.testnet.storyrpc.io:26656,0e2f0d4b5204e5e92a994a1eaa745b9ccb1d747b@b2.testnet.storyrpc.io:26656"
PEERS="74a64d129777b98133776c76872df8671b9050f5@157.173.124.155:26656,2415dfb9dbf3b3ee77824697127aecab87d18598@176.9.54.69:26656,7ff2bc32733d4f191d7b7d7b5ccac28149edf11a@157.173.116.189:26656"
sed -i -e "/^\[p2p\]/,/^\[/{s/^[[:space:]]*seeds *=.*/seeds = \"$SEEDS\"/}" \
       -e "/^\[p2p\]/,/^\[/{s/^[[:space:]]*persistent_peers *=.*/persistent_peers = \"$PEERS\"/}" $HOME/.story/story/config/config.toml
```

Genesis And Addrbook

```
wget -O $HOME/.story/story/config/genesis.json https://noderuner.xyz/testnet/story/genesis.json
wget -O $HOME/.story/story/config/addrbook.json https://noderuner.xyz/testnet/story/addrbook.json
```

Configuring Port Settings

```
sed -i.bak -e "s%:1317%:${STORY_PORT}317%g;
s%:8551%:${STORY_PORT}551%g" $HOME/.story/story/config/story.toml
```

<pre><code>sed -i.bak -e "s%:26658%:${STORY_PORT}658%g;
s%:26657%:${STORY_PORT}657%g;
<strong>s%:26656%:${STORY_PORT}656%g;
</strong>s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${STORY_PORT}656\"%;
s%:26660%:${STORY_PORT}660%g" $HOME/.story/story/config/config.toml
</code></pre>

Enable Prometheus and disable indexing

```
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.story/story/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.story/story/config/config.toml
```

Create a Geth Service File

```
sudo tee /etc/systemd/system/story-geth.service > /dev/null <<EOF
[Unit]
Description=Story Geth daemon
After=network-online.target

[Service]
User=$USER
ExecStart=$HOME/go/bin/geth --iliad --syncmode full --http --http.api eth,net,web3,engine --http.vhosts '*' --http.addr 0.0.0.0 --http.port ${STORY_PORT}545 --authrpc.port ${STORY_PORT}551 --ws --ws.api eth,web3,net,txpool --ws.addr 0.0.0.0 --ws.port ${STORY_PORT}546
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

Create a Story Service File

```
sudo tee /etc/systemd/system/story.service > /dev/null <<EOF
[Unit]
Description=Story Service
After=network.target

[Service]
User=$USER
WorkingDirectory=$HOME/.story/story
ExecStart=$(which story) run

Restart=on-failure
RestartSec=5
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
```

After the above operations, proceed to the snapshot step, and wait for it to sync with the network

Enable and Start Geth, Story

```
sudo systemctl daemon-reload
sudo systemctl enable story story-geth
sudo systemctl restart story story-geth
```

Watch the logs

```
journalctl -u story -u story-geth -f
```

Create validator

```
story validator export
```

Export private key ( don't forget to back up )

```
Export EVM private key
```

```
cat $HOME/.story/story/config/private_key.txt
```

Create validator

```
cd $HOME/.story
story validator create --stake 1000000000000000000
```


# Snapshot

Backup priv\_validator\_state.json

```
cp $HOME/.story/story/data/priv_validator_state.json $HOME/.story/story/priv_validator_state.json.backup
```

You can use the ITRocket service for a snapshot.

```
rm -rf $HOME/.story/story/data
curl https://server-3.itrocket.net/testnet/story/story_2024-10-15_1449048_snap.tar.lz4 | lz4 -dc - | tar -xf - -C $HOME/.story/story
```

Restore priv\_validator\_state.json

```
mv $HOME/.story/story/priv_validator_state.json.backup $HOME/.story/story/data/priv_validator_state.json
```

Delete geth data and unpack Geth snapshot

```
rm -rf $HOME/.story/geth/iliad/geth/chaindata
mkdir -p $HOME/.story/geth/iliad/geth
curl https://server-3.itrocket.net/testnet/story/geth_story_2024-10-15_1449048_snap.tar.lz4 | lz4 -dc - | tar -xf - -C $HOME/.story/geth/iliad/geth
```

Enable and start geth, story

```
sudo systemctl daemon-reload
sudo systemctl enable story story-geth
sudo systemctl restart story story-geth
```

Check logs

```
journalctl -u story -u story-geth -f
```


# Node Delete

```
sudo systemctl stop story story-geth
sudo systemctl disable story story-geth
rm -rf $HOME/.story
sudo rm /etc/systemd/system/story.service /etc/systemd/system/story-geth.service
sudo systemctl daemon-reload
```


# Upgrade

```
# update geth
cd $HOME
wget -O geth https://github.com/piplabs/story-geth/releases/download/v0.9.4/geth-linux-amd64
chmod +x $HOME/geth
sudo mv $HOME/geth $(which geth)
sudo systemctl restart story-geth
sudo systemctl restart story && sudo journalctl -u story -f
```


# Hemi Network

Websocket **Status : 🟢**

```
wss://testnet.rpc.hemi.network/v1/ws/public
```


# 🔌  Installation

Explorer : <https://mempool.space/testnet>

```
apt install git make
```

```
wget https://github.com/hemilabs/heminetwork/releases/download/v0.5.0/heminetwork_v0.5.0_linux_amd64.tar.gz
```

```
tar -xzvf heminetwork_v0.5.0_linux_amd64.tar.gz
```

```
mv heminetwork_v0.5.0_linux_amd64 heminetwork
```

```
chmod +x /root/heminetwork/bfgd
chmod +x /root/heminetwork/bssd
chmod +x /root/heminetwork/btctool
chmod +x /root/heminetwork/extool
chmod +x /root/heminetwork/hemictl
chmod +x /root/heminetwork/keygen
chmod +x /root/heminetwork/popmd
chmod +x /root/heminetwork/tbcd
```

```
cd heminetwork
./keygen -secp256k1 -json -net="testnet" > ~/popm-address.json
```

don't forget to save your private key and btc address

```
nano /root/popm-address.json
```

Let's create a service

don't forget to write a private key inside the service file

```
sudo tee /etc/systemd/system/popmd.service <<EOF
[Unit]
Description=Popmd Service
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/heminetwork
ExecStart=/root/heminetwork/popmd
Environment="POPM_BTC_PRIVKEY=PRİVATE KEY"
Environment="POPM_STATIC_FEE=50"
Environment="POPM_BFG_URL=wss://testnet.rpc.hemi.network/v1/ws/public"
Restart=always

[Install]
WantedBy=multi-user.target
EOF

```

{% embed url="<https://discord.gg/hemixyz>" %}

Get faucet from the Discord channel&#x20;

Let's Get Started

```
sudo systemctl daemon-reload
sudo systemctl enable popmd
sudo systemctl start popmd
```

```
systemctl daemon-reload && systemctl restart popmd && journalctl -u popmd -fo cat
```

to check the logs

```
sudo journalctl -u popmd -fo cat
```


# Warden-Chiado

<figure><img src="/files/LaDnNJNOzYSnI6vfgzoV" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://warden-chiado-rpc.noderuner.xyz
https://warden-chiado-api.noderuner.xyz/
```


# 🔌  Installation

Server preparation

```
apt update && apt upgrade -y
```

```
apt install curl iptables build-essential git wget jq make gcc nano tmux htop nvme-cli pkg-config libssl-dev libleveldb-dev tar clang bsdmainutils ncdu unzip libleveldb-dev -y
```

Install GO

```
ver="1.20.3"
wget "https://golang.org/dl/go$ver.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.linux-amd64.tar.gz"
rm "go$ver.linux-amd64.tar.gz"
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> $HOME/.bash_profile
source $HOME/.bash_profile
go version
```

Node installation

```
git clone https://github.com/warden-protocol/wardenprotocol && cd wardenprotocol

wget https://github.com/warden-protocol/wardenprotocol/releases/download/v0.5.2/wardend_Linux_x86_64.zip
unzip wardend_Linux_x86_64.zip
rm -rf wardend_Linux_x86_64.zip
chmod +x wardend
mv $HOME/wardenprotocol/wardend $HOME/go/bin

wardend version --long | grep -e version -e commit
# version: 0.5.2
# commit: e9ba0b8a2aa05787360270df19480c33429843d4
```

We initialize the node to create the necessary configuration files

```
wardend init MONIKER-NAME --chain-id chiado_10010-1
```

Download Genesis & Addrbook

```
wget -O $HOME/.warden/config/genesis.json "https://noderuner.xyz/testnet/warden/genesis.json"
sha256sum ~/.warden/config/genesis.json
# 8d6bff68b3c709f4d29c1ddae0d4b8394498911efcfdae16350c400c0e54e686

wget -O $HOME/.warden/config/addrbook.json "https://noderuner.xyz/testnet/warden/addrbook.json"
```

Set up node configuration

```
wardend config set client chain-id chiado_10010-1
sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"25000000award\"/;" ~/.warden/config/app.toml
external_address=$(wget -qO- eth0.me)
sed -i.bak -e "s/^external_address *=.*/external_address = \"$external_address:26656\"/" $HOME/.warden/config/config.toml
peers="2d2c7af1c2d28408f437aef3d034087f40b85401@52.51.132.79:26656,fcaffd41eb7e3647fa953607449ff5e371c236b8@195.26.245.67:31656,5461e7642520a1f8427ffaa57f9d39cf345fcd47@54.72.190.0:26656,e1ea15d3c460eb9ace279b0b7665015d3c5d2b9e@135.181.210.171:21406"
sed -i -e "s|^persistent_peers *=.*|persistent_peers = \"$peers\"|" $HOME/.warden/config/config.toml
seeds="8288657cb2ba075f600911685670517d18f54f3b@warden-testnet-seed.itrocket.net:18656"
sed -i.bak -e "s/^seeds =.*/seeds = \"$seeds\"/" $HOME/.warden/config/config.toml
```

Set up puring

```
pruning="custom"
pruning_keep_recent="1000"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.warden/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.warden/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.warden/config/app.toml
```

Set up indexer

```
indexer="null"
sed -i -e "s/^indexer *=.*/indexer = \"$indexer\"/" $HOME/.warden/config/config.toml
```

Enable/Disable Snapshot ( Optional)

```
snapshot_interval=1000
sed -i.bak -e "s/^snapshot-interval *=.*/snapshot-interval = \"$snapshot_interval\"/" ~/.warden/config/app.toml
```

Create servis file

```
tee /etc/systemd/system/wardend.service > /dev/null <<EOF
[Unit]
Description=wardend
After=network-online.target

[Service]
User=$USER
ExecStart=$(which wardend) start
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

```
systemctl daemon-reload
systemctl enable wardend
systemctl restart wardend && journalctl -u wardend -f -o cat
```

Creating a validator

Get your pub key

```
wardend tendermint show-validator
```

Creat validator.json

```
nano $HOME/.warden/validator.json
```

Insert  our config

```
{
  "pubkey": {#pubkey},
  "amount": "1000000000000000000award",
  "moniker": "MONIKER-NAME",
  "identity": "",
  "website": "",
  "security": "",
  "details": "",
  "commission-rate": "0.05",
  "commission-max-rate": "0.5",
  "commission-max-change-rate": "0.5",
  "min-self-delegation": "1"
}
```

Send the transaction

```
wardend tx staking create-validator $HOME/.warden/validator.json \
    --from=<key-name> \
    --chain-id=chiado_10010-1 \
    --fees 250000000000000award -y  --gas auto --gas-adjustment 1.6
```


# Oracle

Downloıad the slinky binary file

```
cd $HOME/wardenprotocol
curl -Ls https://github.com/skip-mev/slinky/releases/download/v1.0.5/slinky-1.0.5-linux-amd64.tar.gz > slinky-1.0.5-linux-amd64.tar.gz
tar -xzf slinky-1.0.5-linux-amd64.tar.gz
mv slinky-1.0.5-linux-amd64/slinky $HOME/go/bin/slinky

slinky version
1.0.5
```

Defning our  GRPC port

```
GRPC_PORT=$(grep 'address = ' "$HOME/.warden/config/app.toml" | awk -F: '{print $NF}' | grep '90"$' | tr -d '"')
echo $GRPC_PORT
#
```

Create a service for slinky

```
tee /etc/systemd/system/warden-slinky.service > /dev/null <<EOF
[Unit]
Description=Slinky for Warden Protocol service
After=network-online.target

[Service]
User=$USER
ExecStart=$(which slinky) --market-map-endpoint="127.0.0.1:$GRPC_PORT"
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

```
systemctl daemon-reload
systemctl enable warden-slinky
systemctl restart warden-slinky && journalctl -u warden-slinky -f -o cat
```


# Auto install

```
source <(curl -s https://raw.githubusercontent.com/mytolga/wardenchiado/refs/heads/main/autoinstall/install.sh)
```


# Zenrock

<figure><img src="/files/0QOrX952cUezlWymqIhw" alt=""><figcaption></figcaption></figure>

RPC : [https://zenrock-testnet-rpc.noderuner.xyz](https://zenrock-testnet-rpc.noderuner.xyz/)

API : [https://zenrock-testnet-api.noderuner.xyz](https://zenrock-testnet-rpc.noderuner.xyz/)


# 🔌  Installation

**Install Go (if not already installed):**

```bash
cd $HOME
VERSION="1.23.1"
wget "https://golang.org/dl/go$VERSION.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$VERSION.linux-amd64.tar.gz"
rm "go$VERSION.linux-amd64.tar.gz"
[ ! -f ~/.bash_profile ] && touch ~/.bash_profile
echo "export PATH=$PATH:/usr/local/go/bin:~/go/bin" >> ~/.bash_profile
source ~/.bash_profile
[ ! -d ~/go/bin ] && mkdir -p ~/go/bin
```

**Define Environment Variables:**

```bash
echo "export WALLET='wallet'" >> $HOME/.bash_profile
echo "export MONIKER='noderuner'" >> $HOME/.bash_profile
echo "export ZENROCK_CHAIN_ID='gardia-2'" >> $HOME/.bash_profile
echo "export ZENROCK_PORT=46657" >> $HOME/.bash_profile  # Set custom base port here
source ~/.bash_profile
```

**Download the Zenrockd Binary:**

```bash
cd $HOME
curl -o zenrockd https://releases.gardia.zenrocklabs.io/zenrockd-latest
chmod +x zenrockd
mv zenrockd ~/go/bin/
```

**Configure and Initialize Node:**

```bash
zenrockd init $MONIKER --chain-id $ZENROCK_CHAIN_ID
zenrockd config set client chain-id $ZENROCK_CHAIN_ID
zenrockd config set client node tcp://localhost:${ZENROCK_PORT}
```

**Download Genesis and Addrbook Files:**

```bash
wget -O $HOME/.zrchain/config/genesis.json https://raw.githubusercontent.com/mytolga/zenrock/refs/heads/main/genesis.json
wget -O $HOME/.zrchain/config/addrbook.json https://raw.githubusercontent.com/mytolga/zenrock/refs/heads/main/addrbook.json
```

**Set Seed and Peer Nodes:**

```bash
SEEDS="0ce55654cba1669707ebba8954413892ce8c0b31@zenrock-testnet-rpc.noderuner.xyz:46656"
PEERS=$(curl -sS https://zenrock-testnet-rpc.noderuner.xyz/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}' | paste -sd, -)
echo $PEERS
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" $HOME/.zrchain/config/config.toml
```

**Update App Ports in `app.toml`:**

```bash
sed -i.bak -e "s%:1317%:${ZENROCK_PORT}17%g;
s%:8080%:${ZENROCK_PORT}80%g;
s%:9090%:${ZENROCK_PORT}90%g;
s%:9091%:${ZENROCK_PORT}91%g;
s%:8545%:${ZENROCK_PORT}45%g;
s%:8546%:${ZENROCK_PORT}46%g;
s%:6065%:${ZENROCK_PORT}65%g" $HOME/.zrchain/config/app.toml
```

**Update Ports in `config.toml`:**

```bash
sed -i.bak -e "s%:26658%:${ZENROCK_PORT}58%g;
s%:26657%:${ZENROCK_PORT}57%g;
s%:6060%:${ZENROCK_PORT}60%g;
s%:26656%:${ZENROCK_PORT}56%g;
s%^external_address = \"\"%external_address = \"$(wget -qO- eth0.me):${ZENROCK_PORT}56\"%;
s%:26660%:${ZENROCK_PORT}60%g" $HOME/.zrchain/config/config.toml
```

**Set Pruning and Gas Prices:**

```bash
sed -i -e "s/^pruning *=.*/pruning = \"custom\"/" $HOME/.zrchain/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"100\"/" $HOME/.zrchain/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"50\"/" $HOME/.zrchain/config/app.toml
sed -i 's|minimum-gas-prices =.*|minimum-gas-prices = "0urock"|g' $HOME/.zrchain/config/app.toml
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.zrchain/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.zrchain/config/config.toml
```

**Create Systemd Service File:**

```bash
sudo tee /etc/systemd/system/zenrockd.service > /dev/null <<EOF
[Unit]
Description=Zenrock Node Service
After=network-online.target
[Service]
User=$USER
WorkingDirectory=$HOME/.zrchain
ExecStart=$(which zenrockd) start --home $HOME/.zrchain
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
```

**Snapshot**&#x20;

```bash
Soon
```

**Enable and Start the Node:**

```bash
sudo systemctl daemon-reload
sudo systemctl enable zenrockd
sudo systemctl restart zenrockd && sudo journalctl -fu zenrockd -o cat
```


# Sidecar

Credit: 0xchicharito

### **Install the Sidecar**

```bash
mkdir -p $HOME/.zrchain/sidecar/bin
mkdir -p $HOME/.zrchain/sidecar/keys
```

### **Install the Binary File**

```bash
wget -O $HOME/.zrchain/sidecar/bin/zenrock-sidecar https://releases.gardia.zenrocklabs.io/validator_sidecar-1.2.3
chmod +x $HOME/.zrchain/sidecar/bin/zenrock-sidecar
```

### **Clone Zenrock Validators**

```bash
cd $HOME
git clone https://github.com/zenrocklabs/zenrock-validators
```

### **Set a Password for Sidecar Wallets**

```bash
read -p "Enter password for the keys: " key_pass
```

For `zsh`, use the command:

```bash
echo -n "Enter password for the keys: "
read key_pass
```

### **Build the BLS Binary**

```bash
cd $HOME/zenrock-validators/utils/keygen/bls/
go mod tidy
go build
```

### **Create a BLS Key**

```bash
bls_output_file=$HOME/.zrchain/sidecar/keys/bls.key.json
$HOME/zenrock-validators/utils/keygen/bls/bls --password $key_pass -output-file $bls_output_file
```

### **Build the ECDSA Binary**

```bash
cd $HOME/zenrock-validators/utils/keygen/ecdsa/
go mod tidy
go build
```

### **Create an ECDSA Key**

```bash
ecdsa_output_file=$HOME/.zrchain/sidecar/keys/ecdsa.key.json
ecdsa_creation=$($HOME/zenrock-validators/utils/keygen/ecdsa/ecdsa --password $key_pass -output-file $ecdsa_output_file)
ecdsa_address=$(echo "$ecdsa_creation" | grep "Public address" | cut -d: -f2)
```

```bash
echo "ECDSA address: $ecdsa_address"
# Public address:  0xf36F077582B1c34D52f6e6964417fa52406827C1
```

**IMPORTANT** - To proceed, you need to fund the generated ECDSA key with Ethereum Holesky test tokens. You can use the faucet: <https://stakely.io/faucet/ethereum-holesky-testnet-eth>.

**IMPORTANT** - To continue, register at <https://app.infura.io> and obtain the following endpoints:

* Mainnet ETH: <https://xxx>
* Holesky ETH: <https://xxx>
* Holesky ETH WebSocket: wss\://xxx&#x20;

### **Set Variables**

```bash
EIGEN_OPERATOR_CONFIG="$HOME/.zrchain/sidecar/eigen_operator_config.yaml"
TESTNET_HOLESKY_ENDPOINT="<HTTPS_TESTNET_HOLESKY_ENDPOINT>"
MAINNET_ENDPOINT="<HTTPS_MAINNET_ENDPOINT>"
OPERATOR_VALIDATOR_ADDRESS_TBD="<ADDR_zenrockVALOPER>"
OPERATOR_ADDRESS_TBU=$ecdsa_address
ETH_RPC_URL="<HTTPS_TESTNET_HOLESKY_ENDPOINT>"
ETH_WS_URL="<WSS_TESTNET_HOLESKY_ENDPOINT>"
ECDSA_KEY_PATH=$ecdsa_output_file
BLS_KEY_PATH=$bls_output_file
```

### **Copy the Original Configuration Files**

```bash
cp $HOME/zenrock-validators/configs/eigen_operator_config.yaml $HOME/.zrchain/sidecar/
cp $HOME/zenrock-validators/configs/config.yaml $HOME/.zrchain/sidecar/
```

### **Update `config.yaml`**

```bash
sed -i "s|EIGEN_OPERATOR_CONFIG|$EIGEN_OPERATOR_CONFIG|g" "$HOME/.zrchain/sidecar/config.yaml"
sed -i "s|TESTNET_HOLESKY_ENDPOINT|$TESTNET_HOLESKY_ENDPOINT|g" "$HOME/.zrchain/sidecar/config.yaml"
sed -i "s|MAINNET_ENDPOINT|$MAINNET_ENDPOINT|g" "$HOME/.zrchain/sidecar/config.yaml"
```

### **Update `eigen_operator_config.yaml`**

```bash
sed -i "s|OPERATOR_VALIDATOR_ADDRESS_TBD|$OPERATOR_VALIDATOR_ADDRESS_TBD|g" "$HOME/.zrchain/sidecar/eigen_operator_config.yaml"
sed -i "s|OPERATOR_ADDRESS_TBU|$OPERATOR_ADDRESS_TBU|g" "$HOME/.zrchain/sidecar/eigen_operator_config.yaml"
sed -i "s|ETH_RPC_URL|$ETH_RPC_URL|g" "$HOME/.zrchain/sidecar/eigen_operator_config.yaml"
sed -i "s|ETH_WS_URL|$ETH_WS_URL|g" "$HOME/.zrchain/sidecar/eigen_operator_config.yaml"
sed -i "s|ECDSA_KEY_PATH|$ECDSA_KEY_PATH|g" "$HOME/.zrchain/sidecar/eigen_operator_config.yaml"
sed -i "s|BLS_KEY_PATH|$BLS_KEY_PATH|g" "$HOME/.zrchain/sidecar/eigen_operator_config.yaml"
```

### **Create a Service File**

```bash
tee /etc/systemd/system/zenrock-sidecar.service > /dev/null <<EOF
[Unit]
Description=Zenrock-sidecar
After=network-online.target

[Service]
User=$USER
ExecStart=$HOME/.zrchain/sidecar/bin/zenrock-sidecar
Restart=on-failure
RestartSec=30
LimitNOFILE=65535
Environment="OPERATOR_BLS_KEY_PASSWORD=$key_pass"
Environment="OPERATOR_ECDSA_KEY_PASSWORD=$key_pass"
Environment="SIDECAR_CONFIG_FILE=$HOME/.zrchain/sidecar/config.yaml"

[Install]
WantedBy=multi-user.target
EOF
```

```bash
systemctl daemon-reload
systemctl enable zenrock-sidecar
systemctl restart zenrock-sidecar && journalctl -u zenrock-sidecar -f -o cat
```


# Pell Network

<figure><img src="/files/Wr7RNiEYJBKZlrnriY52" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://pell-testnet-api.noderuner.xyz
https://pell-testnet-rpc.noderuner.xyz
```


# 🔌  Installation

[🛠️ ](https://docs.lavanet.xyz/access-server-kit)Hardware Requirements

| CPU   | RAM | Storage |
| ----- | --- | ------- |
| 4 CPU | 8GB | 200GB   |

#### 📌**Step 1: Installation packeges and dependencies** <a href="#step-1-installation-packeges-and-dependencies" id="step-1-installation-packeges-and-dependencies"></a>

```
# Install dependencies for building from source
sudo apt update
sudo apt install -y lz4 jq make git gcc build-essential curl chrony unzip gzip snapd tmux bc

# Bash Profile Environment Setup
[ ! -f ~/.bash_profile ] && touch ~/.bash_profile
echo "export PATH=$PATH:/usr/local/go/bin:~/go/bin" >> ~/.bash_profile
source $HOME/.bash_profile
[ ! -d ~/go/bin ] && mkdir -p ~/go/bin

# Install Go
cd $HOME
VER="1.22.0"
wget "https://golang.org/dl/go$VER.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$VER.linux-amd64.tar.gz"
rm "go$VER.linux-amd64.tar.gz"
[ ! -f ~/.bash_profile ] && touch ~/.bash_profile
echo "export PATH=$PATH:/usr/local/go/bin:~/go/bin" >> ~/.bash_profile
source $HOME/.bash_profile
```

#### 📌**Step 2: Set moniker and install node** <a href="#step-2-set-moniker-and-install-node" id="step-2-set-moniker-and-install-node"></a>

Give your validator a name by which you can find yourself in explorer, put it in ""

```
MONIKER=""
```

After that, insert the following node installation command ( apply one by one to avoid meeting with an error )

```
# Clone project repository
cd $HOME
wget -O pellcored https://github.com/0xPellNetwork/network-config/releases/download/v1.2.1/pellcored-v1.2.1-linux-amd64
chmod +x pellcored
mv pellcored ~/go/bin/
WASMVM_VERSION=v2.1.2
export LD_LIBRARY_PATH=~/.pellcored/lib
mkdir -p $LD_LIBRARY_PATH
wget "https://github.com/CosmWasm/wasmvm/releases/download/$WASMVM_VERSION/libwasmvm.$(uname -m).so" -O "$LD_LIBRARY_PATH/libwasmvm.$(uname -m).so"
echo "export LD_LIBRARY_PATH=$HOME/.pellcored/lib:$LD_LIBRARY_PATH" >> $HOME/.bash_profile
source ~/.bash_profile

# Initialize the node
If you encounter an error here, please manually edit the file using
pellcored config keyring-backend os
pellcored config chain-id ignite_186-1
pellcored init "$MONIKER" --chain-id ignite_186-1 

nano /root/.pellcored/config/client.toml
CTRL+X Y Enter

# Download genesis and addrbook files
curl -Ls https://raw.githubusercontent.com/mytolga/pell-testnet/refs/heads/main/genesis.json > $HOME/.pellcored/config/genesis.json
curl -Ls https://raw.githubusercontent.com/mytolga/pell-testnet/refs/heads/main/addrbook.json > $HOME/.pellcored/config/addrbook.json

# Peers
PEERS="1a7b6f07673a96f3a0391705da32ee184730fb7d@91.205.105.37:26656,2b2932bd000204b75d2675d84e0e6e690fcc9b41@31.165.179.107:26656,d003cb808ae91bad032bb94d19c922fe094d8556@pell-testnet-peer.itrocket.net:58656,f2474b5e49e1399ee933cb28776dd9893941457d@135.181.210.46:57656,a2460ce7888ac53f13aa50ba0b8df9a553bd3332@65.109.84.153:57656,2af565efc9036b85167e3c3c01a2b5ad6db0b8e3@43.157.105.179:26656,d52c32a6a8510bdf0d33909008041b96d95c8408@34.87.39.12:26656,81caef1e38e18974813624aea310722ad68a33dd@65.109.27.148:26656,f1049cc2be2902053bcf5ea1a553414d8a978ef6@[2a01:4f8:110:4265::11]:26656,c9a5d341547e06441e30e07db289fc337ec36f79@152.53.87.97:26656,78d89ac4ef91fd92bd97769891711ca58bd7f512@65.108.226.44:47956"
sed -i -e "/^\[p2p\]/,/^\[/{s/^[[:space:]]*persistent_peers *=.*/persistent_peers = \"$PEERS\"/}" $HOME/.pellcored/config/config.toml

# Disable indexer
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.pellcored/config/config.toml

# Change pruning
sed -i -e "s/^pruning *=.*/pruning = \"custom\"/" $HOME/.pellcored/config/app.toml 
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"100\"/" $HOME/.pellcored/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"19\"/" $HOME/.pellcored/config/app.toml

# Download latest chain data snapshot ( credit-itrocket )
cp $HOME/.pellcored/data/priv_validator_state.json $HOME/.pellcored/priv_validator_state.json.backup
rm -rf $HOME/.pellcored/data
curl https://server-5.itrocket.net/testnet/pell/pell_2025-02-27_1169270_snap.tar.lz4 | lz4 -dc - | tar -xf - -C $HOME/.pellcored
mv $HOME/.pellcored/priv_validator_state.json.backup $HOME/.pellcored/data/priv_validator_state.json

# Create a service 
sudo tee /etc/systemd/system/pellcored.service > /dev/null <<EOF
[Unit]
Description=Pell node
After=network-online.target
[Service]
User=$USER
WorkingDirectory=$HOME/.pellcored
ExecStart=$(which pellcored) start --home $HOME/.pellcored --chain-id=ignite_186-1
Environment=LD_LIBRARY_PATH=$HOME/.pellcored/lib/
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF

# Start the service and check the logs
sudo systemctl daemon-reload
sudo systemctl enable pellcored
sudo systemctl restart pellcored && sudo journalctl -u pellcored -f
```

### 📝 Create wallet <a href="#create-wallet" id="create-wallet"></a>

#### 📌**Step 1: Create wallet** <a href="#step-1-create-wallet" id="step-1-create-wallet"></a>

```
pellcored keys add wallet
```

Save all information after entering the command.

#### 📌**Step 2: Request test tokens to your wallet address** <a href="#step-2-request-test-tokens-to-your-wallet-address" id="step-2-request-test-tokens-to-your-wallet-address"></a>

To receive test tokens, you will need to request tokens from the project team.

#### 📌**Step 3:** **Create validator** <a href="#step-3-create-validator" id="step-3-create-validator"></a>

Please arrange the following information according to yourself

```
cd $HOME
# Create validator.json file
echo "{\"pubkey\":{\"@type\":\"/cosmos.crypto.ed25519.PubKey\",\"key\":\"$(pellcored comet show-validator | grep -Po '\"key\":\s*\"\K[^"]*')\"},
    \"amount\": \"1000000apell\",
    \"moniker\": \"$MONIKER\",
    \"identity\": \"\",
    \"website\": \"\",
    \"security\": \"\",
    \"details\": \"\",
    \"commission-rate\": \"0.1\",
    \"commission-max-rate\": \"0.2\",
    \"commission-max-change-rate\": \"0.01\",
    \"min-self-delegation\": \"1\"
}" > validator.json

# Create a validator using the JSON configuration
pellcored tx staking create-validator validator.json \
    --from $WALLET \
    --chain-id ignite_186-1 \
	--gas auto --gas-adjustment 1.5
```

#### 📌**Step 4:** **Delegate to yourself** <a href="#step-3-create-validator" id="step-3-create-validator"></a>

```
pellcored tx staking delegate $(pellcored keys show $WALLET --bech val -a) 1000000apell --from $WALLET --chain-id ignite_186-1 --gas auto --gas-adjustment 1.5 -y 
```

#### Check Log <a href="#delegate-to-another-validator" id="delegate-to-another-validator"></a>

```
sudo journalctl -u pellcored -f
```


# Upgrade

Coming Soon


# Delete

#### **Delete Node** <a href="#step-1-installation-packeges-and-dependencies" id="step-1-installation-packeges-and-dependencies"></a>

```bash
sudo systemctl stop pellcored
sudo systemctl disable pellcored
sudo rm -rf /etc/systemd/system/pellcored.service
sudo rm $(which pellcored)
sudo rm -rf $HOME/.pellcored
sed -i "/PELL_/d" $HOME/.bash_profile
```


# SelfChain

<figure><img src="/files/EIzfX23B3l07DgKt8TfI" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://selfchain-testnet-rpc.noderuner.xyz
https://selfchain-testnet-api.noderuner.xyz
```


# 🔌  Installation

### installation <a href="#id-2-manual-installation" id="id-2-manual-installation"></a>

```
sudo apt update && sudo apt upgrade -y
sudo apt install curl tar wget clang pkg-config libssl-dev jq build-essential bsdmainutils git make ncdu gcc git jq chrony liblz4-tool -y
```

#### GO 1.21.6 <a href="#go-1.21.6" id="go-1.21.6"></a>

```
ver="1.21.6"
wget "https://golang.org/dl/go$ver.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.linux-amd64.tar.gz"
rm "go$ver.linux-amd64.tar.gz"
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> $HOME/.bash_profile
source $HOME/.bash_profile
go version
```

### Build  <a href="#build-21.03.25" id="build-21.03.25"></a>

```
cd $HOME && mkdir -p go/bin/
wget -O selfchaind https://server.noderuner.xyz/selfchain/selfchaind
chmod +x selfchaind
mv selfchaind /root/go/bin/
```

### Initiation <a href="#initiation" id="initiation"></a>

```
selfchaind init Moniker-Name --chain-id=selfchain-testnet
selfchaind config chain-id selfchain-testnet
```

#### Create/recover wallet <a href="#create-recover-wallet" id="create-recover-wallet"></a>

```
selfchaind keys add walletname
           OR
selfchaind keys add walletname --recover
```

#### Download Genesis and Addrbook <a href="#download-genesis-and-addrbook" id="download-genesis-and-addrbook"></a>

```
wget -L -O $HOME/.selfchain/config/genesis.json "https://server.noderuner.xyz/selfchain/genesis.json"
wget -O $HOME/.selfchain/config/addrbook.json "https://server.noderuner.xyz/selfchain/addrbook.json"
```

#### Set up the minimum gas price and Peers/Seeds <a href="#set-up-the-minimum-gas-price-and-peers-seeds-filter-peers-maxpeers" id="set-up-the-minimum-gas-price-and-peers-seeds-filter-peers-maxpeers"></a>

```
sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.0uslf\"/;" ~/.selfchain/config/app.toml
external_address=$(wget -qO- eth0.me) 
sed -i.bak -e "s/^external_address *=.*/external_address = \"$external_address:26656\"/" $HOME/.selfchain/config/config.toml
sed -i 's/max_num_inbound_peers =.*/max_num_inbound_peers = 50/g' $HOME/.selfchain/config/config.toml
sed -i 's/max_num_outbound_peers =.*/max_num_outbound_peers = 50/g' $HOME/.selfchain/config/config.toml
```

**Pruning (optional)**

```
pruning="custom"
pruning_keep_recent="1000"
pruning_keep_every="0"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.selfchain/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.selfchain/config/app.toml
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" $HOME/.selfchain/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.selfchain/config/app.toml
```

**Indexer (optional)**

```
indexer="null" &&
sed -i -e "s/^indexer *=.*/indexer = \"$indexer\"/" $HOME/.selfchain/config/config.toml
```

### Create a service file <a href="#create-a-service-file" id="create-a-service-file"></a>

```
tee /etc/systemd/system/selfchaind.service > /dev/null <<EOF
[Unit]
Description=selfchaind
After=network-online.target

[Service]
User=$USER
ExecStart=$(which selfchaind) start
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

#### Start <a href="#start" id="start"></a>

```
sudo systemctl daemon-reload
sudo systemctl enable selfchaind
sudo systemctl restart selfchaind && sudo journalctl -fu selfchaind -o cat
```

**Create validator**

```
selfchaind tx staking create-validator \
  --amount=1000000uslf \
  --pubkey=$(selfchaind tendermint show-validator) \
  --moniker="Moniker-Name" \
  --details="" \
  --identity="" \
  --website="" \
  --chain-id="selfchain-testnet" \
  --commission-rate="0.10" \
  --commission-max-rate="0.10" \
  --commission-max-change-rate="0.1" \
  --min-self-delegation="1" \
  --from=Yourwallet -y
```


# Upgrade

Soon


# Delete

Delete node

```
systemctl stop selfchaind
systemctl disable selfchaind
rm /etc/systemd/system/selfchaind.service
systemctl daemon-reload
cd $HOME
rm -rf .selfchain
rm -rf $(which selfchaind)
```


# AtomOne Mainnet

<figure><img src="/files/fS7OW8mY28TQqrHpKB9K" alt="" width="563"><figcaption></figcaption></figure>

**Status :** 🟢

```
https://atomone-mainnet-rpc.noderuner.xyz
https://atomone-mainnet-api.noderuner.xyz
http://atomone-mainnet-grpc.noderuner.xyz:443
```


# 🔌  Installation

#### Install dependencies Required <a href="#install-dependencies-required" id="install-dependencies-required"></a>

```plaintext
sudo apt update && sudo apt upgrade -y && sudo apt install curl tar wget clang pkg-config libssl-dev jq build-essential bsdmainutils git make ncdu gcc git jq chrony liblz4-tool -y
```

#### Install go <a href="#install-go" id="install-go"></a>

We are gonna use GO Version 1.21.13 If you already have GO installed you can skip this

```plaintext
ver="1.22.10"
cd $HOME
wget "https://golang.org/dl/go$ver.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.linux-amd64.tar.gz"
rm "go$ver.linux-amd64.tar.gz"
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> ~/.bash_profile
source ~/.bash_profile
go version
```

#### Install binary <a href="#install-binary" id="install-binary"></a>

```plaintext
cd $HOME
git clone https://github.com/atomone-hub/atomone.git
cd atomone
git checkout v2.1.0
make install
```

#### Init `Change MONIKER Name` <a href="#init-change-moniker-with-ur-name" id="init-change-moniker-with-ur-name"></a>

```plaintext
atomoned init <MONIKER> --chain-id atomone-1
atomoned config chain-id atomone-1
atomoned config keyring-backend file
```

#### Download Genesis file and addrbook <a href="#download-genesis-file-and-addrbook" id="download-genesis-file-and-addrbook"></a>

* Genesis

```plaintext
wget -O $HOME/.atomone/config/genesis.json  https://noderuner.xyz/atomone/genesis.json
```

* Addrbook

```plaintext
wget -O $HOME/.atomone/config/addrbook.json https://noderuner.xyz/atomone/addrbook.json
```

#### Configure Seeds and Peers <a href="#configure-seeds-and-peers" id="configure-seeds-and-peers"></a>

```plaintext
peers="$(curl -sS https://atomone-mainnet-rpc.noderuner.xyz:443/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}' | sed -z 's|\n|,|g;s|.$||')"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$peers\"/" $HOME/.atomone/config/config.toml
sed -i -e "s|^minimum-gas-prices *=.*|minimum-gas-prices = \"0uatone\"|" $HOME/.atomone/config/app.toml
```

#### Config pruning <a href="#config-pruning" id="config-pruning"></a>

```plaintext
sed -i \
-e 's|^pruning *=.*|pruning = "custom"|' \
-e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
-e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
-e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
$HOME/.atomone/config/app.toml
```

#### Indexer Off <a href="#indexer-off" id="indexer-off"></a>

```plaintext
sed -i 's|^indexer *=.*|indexer = "null"|' $HOME/.atomone/config/config.toml
```

```
sed -i 's|minimum-gas-prices =.*|minimum-gas-prices = "0.001uatone"|g' $HOME/.atomone/config/app.toml
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.atomone/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.atomone/config/config.toml
```

#### create service file and start node <a href="#create-service-file-and-start-node" id="create-service-file-and-start-node"></a>

```plaintext
sudo tee /etc/systemd/system/atomoned.service > /dev/null <<EOF
[Unit]
Description=atomone
After=network-online.target

[Service]
User=$USER
ExecStart=$(which atomoned) start
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

* Start Node

```plaintext
sudo systemctl daemon-reload
sudo systemctl enable atomoned
sudo systemctl restart atomoned
sudo journalctl -u atomoned -f -o cat
```


# CLI Cheatsheet

Check logs

<pre class="language-bash"><code class="lang-bash"><strong>sudo journalctl -u atomoned -fo cat
</strong></code></pre>

Start service

```bash
sudo systemctl start atomoned
```

Stop service

```bash
sudo systemctl stop atomoned
```

Restart service

```bash
sudo systemctl restart atomoned
```

Check service status

```bash
sudo systemctl status atomoned
```

Reload services

```bash
sudo systemctl daemon-reload
```

Enable Service

```bash
sudo systemctl enable atomoned
```

Disable Service

```bash
sudo systemctl disable atomoned
```

Node info

```bash
atomoned status 2>&1 | jq
```

Add New Wallet

```bash
atomoned keys add WALLET
```

Restore executing wallet

```bash
atomoned keys add WALLET --recover
```

List All Wallets

```bash
atomoned keys list
```

Delete wallet

```bash
atomoned keys delete WALLET
```

Check Balance

```bash
atomoned q bank balances WALLET_ADDRESS 
```

Delegate Yourself

```bash
atomoned tx staking delegate $(atomoned keys show WALLET --bech val -a) 1000000uatone --from WALLET --chain-id atomone-1 --gas auto --gas-adjustment 1.5 --fees 60000uphoton -y 
```

Create New Validator

```bash
atomoned tx staking create-validator \
--amount 1000000uatone \
--from $WALLET \
--commission-rate 0.1 \
--commission-max-rate 0.2 \
--commission-max-change-rate 0.01 \
--min-self-delegation 1 \
--pubkey $(atomoned tendermint show-validator) \
--moniker "Moniker-Name" \
--identity "KeyBase" \
--details "Node Details" \
--chain-id atomone-1 \
--gas auto --gas-adjustment 1.5 --fees 60000uphoton \
-y 
```

Edit Existing Validator

```bash
atomoned tx staking edit-validator \
--commission-rate 0.1 \
--new-moniker "Moniker-Name" \
--identity "KeyBase" \
--details "Node Details" \
--from $WALLET \
--chain-id atomone-1 \
--gas auto --gas-adjustment 1.5 --fees 60000uphoton \
-y 
```

### Delete node <a href="#delete" id="delete"></a>

```bash
sudo systemctl stop atomoned
sudo systemctl disable atomoned
sudo rm -rf /etc/systemd/system/atomoned.service
sudo rm $(which atomoned)
sudo rm -rf $HOME/.atomone
sed -i "/ATOMONE_/d" $HOME/.bash_profile
```


# Upgrade

Upgrade height: 5902000

```bash
cd $HOME/go/bin/
```

Download a new binary and let

```
wget -O atomoned_v3.0.3 https://github.com/atomone-hub/atomone/releases/download/v3.0.3/atomoned-v3.0.3-linux-amd64
```

```
chmod +x atomoned_v3.0.3
```

```
sudo cp $(which atomoned) $(which atomoned).backup
```

Move it over the old binary

```
sudo mv atomoned_v3.0.3 $(which atomoned)
```

Restart the node and follow the logs.

```
sudo systemctl restart atomoned
sudo journalctl -u atomoned -f
```


# Snapshot

Soon


# AtomOne Testnet

<figure><img src="/files/fS7OW8mY28TQqrHpKB9K" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://atomone-testnet-rpc.noderuner.xyz
https://atomone-testnet-api.noderuner.xyz
http://atomone-testnet-grpc.noderuner.xyz:443
```


# 🔌  Installation

#### Install dependencies Required <a href="#install-dependencies-required" id="install-dependencies-required"></a>

```plaintext
sudo apt update && sudo apt upgrade -y && sudo apt install curl tar wget clang pkg-config libssl-dev jq build-essential bsdmainutils git make ncdu gcc git jq chrony liblz4-tool -y
```

#### Install go <a href="#install-go" id="install-go"></a>

We are gonna use GO Version 1.21.13 If you already have GO installed you can skip this

```plaintext
ver="1.22.10"
cd $HOME
wget "https://golang.org/dl/go$ver.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.linux-amd64.tar.gz"
rm "go$ver.linux-amd64.tar.gz"
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> ~/.bash_profile
source ~/.bash_profile
go version
```

#### Install binary <a href="#install-binary" id="install-binary"></a>

```plaintext
cd $HOME
git clone https://github.com/atomone-hub/atomone
cd atomone
git checkout v3.0.1
make install
```

#### Init `Change MONIKER Name` <a href="#init-change-moniker-with-ur-name" id="init-change-moniker-with-ur-name"></a>

```plaintext
atomoned init <MONIKER> --chain-id atomone-1
atomoned config chain-id atomone-testnet-1
atomoned config keyring-backend file
```

Download genesis and addrbook

```bash
wget -O $HOME/.atomone/config/genesis.json https://noderuner.xyz/testnet/atomone/genesis.json
wget -O $HOME/.atomone/config/addrbook.json  https://noderuner.xyz/testnet/atomone/addrbook.json
```

#### Configure Seeds and Peers <a href="#configure-seeds-and-peers" id="configure-seeds-and-peers"></a>

```plaintext
peers="$(curl -sS https://atomone-testnet-rpc.noderuner.xyz:443/net_info | jq -r '.result.peers[] | "\(.node_info.id)@\(.remote_ip):\(.node_info.listen_addr)"' | awk -F ':' '{print $1":"$(NF)}' | sed -z 's|\n|,|g;s|.$||')"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$peers\"/" $HOME/.atomone/config/config.toml
sed -i -e "s|^minimum-gas-prices *=.*|minimum-gas-prices = \"0uatone\"|" $HOME/.atomone/conf
```

#### Config pruning <a href="#config-pruning" id="config-pruning"></a>

```plaintext
sed -i \
-e 's|^pruning *=.*|pruning = "custom"|' \
-e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
-e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
-e 's|^pruning-interval *=.*|pruning-interval = "19"|' \
$HOME/.atomone/config/app.toml
```

#### Indexer Off <a href="#indexer-off" id="indexer-off"></a>

```plaintext
sed -i 's|^indexer *=.*|indexer = "null"|' $HOME/.atomone/config/config.toml
```

Set minimum gas price

```
sed -i 's|minimum-gas-prices =.*|minimum-gas-prices = "0.001uatone"|g' $HOME/.atomone/config/app.toml
sed -i -e "s/prometheus = false/prometheus = true/" $HOME/.atomone/config/config.toml
sed -i -e "s/^indexer *=.*/indexer = \"null\"/" $HOME/.atomone/config/config.toml
```

#### create service file and start node <a href="#create-service-file-and-start-node" id="create-service-file-and-start-node"></a>

```plaintext
sudo tee /etc/systemd/system/atomoned.service > /dev/null <<EOF
[Unit]
Description=Atomone node
After=network-online.target
[Service]
User=$USER
WorkingDirectory=$HOME/.atomone
ExecStart=$(which atomoned) start --home $HOME/.atomone
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF
```

* Start Node

```plaintext
sudo systemctl daemon-reload
sudo systemctl enable atomoned
sudo systemctl restart atomoned 
sudo journalctl -u atomoned -fo cat
```


# 🛠️ CLI Cheatsheet

Check logs

<pre class="language-bash"><code class="lang-bash"><strong>sudo journalctl -u atomoned -fo cat
</strong></code></pre>

Start service

```bash
sudo systemctl start atomoned
```

Stop service

```bash
sudo systemctl stop atomoned
```

Restart service

```bash
sudo systemctl restart atomoned
```

Check service status

```bash
sudo systemctl status atomoned
```

Reload services

```bash
sudo systemctl daemon-reload
```

Enable Service

```bash
sudo systemctl enable atomoned
```

Disable Service

```bash
sudo systemctl disable atomoned
```

Node info

```bash
atomoned status 2>&1 | jq
```

Add New Wallet

```bash
atomoned keys add WALLET
```

Restore executing wallet

```bash
atomoned keys add WALLET --recover
```

List All Wallets

```bash
atomoned keys list
```

Delete wallet

```bash
atomoned keys delete WALLET
```

Check Balance

```bash
atomoned q bank balances WALLET_ADDRESS 
```

Delegate Yourself

```bash
atomoned tx staking delegate $(atomoned keys show WALLET --bech val -a) 1000000uatone --from WALLET --chain-id atomone-1 --gas auto --gas-adjustment 1.5 --fees 60000uphoton -y 
```

Create New Validator

```bash
atomoned tx staking create-validator \
--amount 1000000uphoton \
--from $WALLET \
--commission-rate 0.1 \
--commission-max-rate 0.2 \
--commission-max-change-rate 0.01 \
--min-self-delegation 1 \
--pubkey $(atomoned tendermint show-validator) \
--moniker "MONIKER NAME" \
--identity "" \
--details "DETAILS" \
--chain-id atomone-testnet-1 \
--gas auto --gas-adjustment 1.5 --fees 500uphoton \
-y 

```

Edit Existing Validator

```bash
atomoned tx staking edit-validator \
--commission-rate 0.1 \
--new-moniker "MONIKER NAME" \
--identity "" \
--details "DETAILS" \
--from $WALLET \
--chain-id atomone-testnet-1 \
--gas auto --gas-adjustment 1.5 --fees 500uphoton \
-y 

```

### Delege  <a href="#delete" id="delete"></a>

```
atomoned tx staking delegate $(atomoned keys show $WALLET --bech val -a) 1000000uphoton --from WALLETNAME --chain-id atomone-testnet-1 --gas auto --gas-adjustment 1.5 --fees 500uphoton -y 
```

### Delete node <a href="#delete" id="delete"></a>

```bash
sudo systemctl stop atomoned
sudo systemctl disable atomoned
sudo rm -rf /etc/systemd/system/atomoned.service
sudo rm $(which atomoned)
sudo rm -rf $HOME/.atomone
```


# Upgrade

Soon


# Snapshot

Soon


# Republic Testnet

<figure><img src="/files/1iOpntJV1w6cAClrMjPF" alt=""><figcaption></figcaption></figure>

**Status :** 🟢

```
https://republic-testnet-rpc.noderuner.xyz
https://republic-testnet-api.noderuner.xyz
```


# 🔌  Installation

## Republic Node Installation Guide (Custom Setup)

### 1. Install Required Dependencies

First, update your system and install the necessary packages.

```
sudo apt update && sudo apt upgrade -y
sudo apt install curl tar wget clang pkg-config libssl-dev jq build-essential bsdmainutils git make ncdu gcc chrony liblz4-tool -y
```

## 2. Install Go

This setup uses **Go v1.22.5**.\
If Go is already installed on your server, you may skip this step.

```
GO_VERSION="1.22.5"

wget "https://golang.org/dl/go${GO_VERSION}.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go${GO_VERSION}.linux-amd64.tar.gz"
rm "go${GO_VERSION}.linux-amd64.tar.gz"

echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> ~/.bash_profile
source ~/.bash_profile

go version
```

***

## 3. Install Republic Binary

Download the node binary and move it to your Go binary directory.

```
wget https://github.com/RepublicAI/networks/releases/download/v0.1.0/republicd-linux-amd64 -O republicd
chmod +x republicd
mv republicd $HOME/go/bin/
```

Verify the installation:

```
republicd version --long | grep -e version -e commit
```

***

## 4. Initialize the Node

Replace `<MONIKER>` with your preferred node name.

```
republicd init <MONIKER> --chain-id raitestnet_77701-1
```

***

## 5. Download Genesis and Addrbook

### Genesis File

```
curl -L https://snapshot.vinjan-inc.com/republic/genesis.json > $HOME/.republic/config/genesis.json
```

### Addrbook File

```
curl -L https://snapshot.vinjan-inc.com/republic/addrbook.json > $HOME/.republic/config/addrbook.json
```

***

## 6. Custom Port Configuration

To avoid conflicts with other nodes, configure custom ports.

```
CUSTOM_PORT=211
```

```
sed -i -e "s%:26657%:${CUSTOM_PORT}57%" $HOME/.republic/config/client.toml

sed -i -e "s%:26658%:${CUSTOM_PORT}58%; \
s%:26657%:${CUSTOM_PORT}57%; \
s%:6060%:${CUSTOM_PORT}60%; \
s%:26656%:${CUSTOM_PORT}56%; \
s%:26660%:${CUSTOM_PORT}61%" $HOME/.republic/config/config.toml

sed -i -e "s%:1317%:${CUSTOM_PORT}17%; \
s%:9090%:${CUSTOM_PORT}90%; \
s%:8545%:${CUSTOM_PORT}45%; \
s%:8546%:${CUSTOM_PORT}46%; \
s%:6065%:${CUSTOM_PORT}65%" $HOME/.republic/config/app.toml
```

***

## 7. Configure Peers and Gas Settings

Set the persistent peers to connect to the network faster.

```
PEERS="6313f892ee50ca0b2d6cc6411ac5207dbf2d164b@peers-t.republic.vinjan-inc.com:13356,7fef6e3bb5c254c777449e09e9cf0ee40f4cdee3@195.201.160.23:13356,1fc361b76cb5d3190027e18299a22e3dcb689dd9@54.159.96.158:26656"

sed -i -e "s|^persistent_peers *=.*|persistent_peers = \"$PEERS\"|" $HOME/.republic/config/config.toml
```

Set minimum gas price:

```
sed -i -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"2500000000arai\"/" $HOME/.republic/config/app.toml
```

***

## 8. Configure Pruning (Disk Optimization)

Enable pruning to reduce disk usage.

```
sed -i \
-e 's|^pruning *=.*|pruning = "custom"|' \
-e 's|^pruning-keep-recent *=.*|pruning-keep-recent = "100"|' \
-e 's|^pruning-keep-every *=.*|pruning-keep-every = "0"|' \
-e 's|^pruning-interval *=.*|pruning-interval = "20"|' \
$HOME/.republic/config/app.toml
```

***

## 9. Disable Indexer

Disabling the indexer helps reduce disk usage and improves performance.

```
sed -i 's|^indexer *=.*|indexer = "null"|' $HOME/.republic/config/config.toml
```

***

## 10. Create System Service

Create a **systemd service** so the node runs automatically in the background.

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

[Service]
User=$USER
ExecStart=$(which republicd) start
Restart=always
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF
```

***

## 11. Start the Node

Reload system services and start the node.

```
sudo systemctl daemon-reload
sudo systemctl enable republicd
sudo systemctl restart republicd
```

View logs:

```
sudo journalctl -u republicd -f -o cat
```


# Upgrade


# v0.2.1

#### v0.2.1 <a href="#upgrade-to-v021" id="upgrade-to-v021"></a>

```plaintext
wget https://github.com/RepublicAI/networks/releases/download/v0.2.1/republicd-linux-amd64 -O republicd
chmod +x republicd
```

```plaintext
sudo systemctl stop republicd
mv republicd $HOME/go/bin/
```

```plaintext
sudo systemctl restart republicd
sudo journalctl -u republicd -f -o cat
```


# v.0.3.0

#### v.0.3.0 <a href="#upgrade-to-v030" id="upgrade-to-v030"></a>

```plaintext
wget https://github.com/RepublicAI/networks/releases/download/v0.3.0/republicd-linux-amd64 -O republicd
chmod +x republicd
```

```plaintext
sudo systemctl stop republicd
mv republicd $HOME/go/bin/
```

<br>


# Snapshot

Coming Soon


# CLI Cheatsheet

## Republic Node Command Reference

***

## Check Node Synchronization Status

```
republicd status 2>&1 | jq .sync_info
```

> Be careful with **capitalized parameters** and always specify `--chain-id` when required.

***

## Frequently Used Status Command

```
republicd status 2>&1 | jq .sync_info
```

***

## Wallet Operations

### Create a New Wallet

Replace `<wallet>` with your preferred wallet name.

```
republicd keys add wallet
```

***

### Restore an Existing Wallet from Mnemonic

```
republicd keys add wallet --recover
```

***

### Display Available Wallets

```
republicd keys list
```

***

### Remove a Wallet from the Keyring

```
republicd keys delete wallet
```

***

### Check Wallet Balance

```
republicd q bank balances $(republicd keys show wallet -a)
```

***

## Validator Setup & Management

Please replace the following values with your own information:

`<wallet>` , `MONIKER` , `YOUR_KEYBASE_ID` , `YOUR_DETAILS` , `YOUR_WEBSITE_URL`

***

### Retrieve Validator Public Key

```
republicd comet show-validator
```

***

### Create Validator Configuration File

```
nano $HOME/.republic/validator.json
```

```
{
  "pubkey":  ,
  "amount": "1000000000000000000arai",
  "moniker": "",
  "identity": "",
  "website": "",
  "security": "",
  "details": "",
  "commission-rate": "0.05",
  "commission-max-rate": "0.2",
  "commission-max-change-rate": "0.05",
  "min-self-delegation": "1"
}
```

***

### Submit Validator Creation Transaction

```
republicd tx staking create-validator $HOME/.republic/validator.json \
--from wallet \
--chain-id raitestnet_77701-1 \
--gas-prices=2500000000arai \
--gas-adjustment=1.5 \
--gas=auto
```

***

### Restore Validator from Jailed State

```
republicd tx slashing unjail --from wallet --chain-id raitestnet_77701-1 --gas-prices=2500000000arai --gas-adjustment=1.5 --gas=auto
```

***

### View Validator Slashing Information

```
republicd query slashing signing-info $(republicd comet show-validator)
```

***

## Token & Delegation Operations

***

### Claim All Staking Rewards

```
republicd tx distribution withdraw-all-rewards --from wallet --chain-id raitestnet_77701-1 --gas-prices=2500000000arai --gas-adjustment=1.5 --gas=auto
```

***

### Claim Validator Rewards Including Commission

```
republicd tx distribution withdraw-rewards $(republicd keys show wallet --bech val -a) --commission --from wallet --chain-id raitestnet_77701-1 --gas-prices=2500000000arai --gas-adjustment=1.5 --gas=auto
```

***

### Delegate Tokens to Your Validator

```
republicd tx staking delegate $(republicd keys show wallet --bech val -a) 1000000000000000000arai --from wallet --chain-id raitestnet_77701-1 --gas-prices=2500000000arai --gas-adjustment=1.5 --gas=auto
```

***

### Redelegate Tokens to Another Validator

```
republicd tx staking redelegate $(republicd keys show wallet --bech val -a) <TO_VALOPER_ADDRESS> 1000000000000000000arai --from wallet --chain-id raitestnet_77701-1 --gas-prices=2500000000arai --gas-adjustment=1.5 --gas=auto
```

***

### Undelegate Tokens from Your Validator

```
republicd tx staking unbond $(republicd keys show wallet --bech val -a) 1000000000000000000arai --from wallet --chain-id raitestnet_77701-1 --gas-prices=2500000000arai --gas-adjustment=1.5 --gas=auto
```

***

### Transfer Tokens to Another Wallet

```
republicd tx bank send wallet <TO_WALLET_ADDRESS> 1000000000000000000arai --from wallet --chain-id raitestnet_77701-1 --gas-prices=2500000000arai --gas-adjustment=1.5 --gas=auto
```