Running an OLLO node
This guide will go through the process of setting up a node on the OLLO network, currently on version v0.0.1
, with chain ID ollo-testnet-1
. OLLO Station network currently utilizes the Cosmos SDK version v0.46.3
. We will be working over time to provide tools and and scripts that will automate this process to make it as easy as possible for would-be nodes & validators.
Prerequisites
Hardware
Note: Running a validator is an intensive process that may potentially use a lot of computational resources, even on an early testnet like OLLO's. Please ensure the hardware you intend to run your validator on has sufficient resources as described below.
- We recommend that your validator runs on a machine having at least 8GB of RAM and 2 CPU cores available.
- You can run a validator on a cloud server or on your local machine. If you are running a validator on a cloud server, we recommend that you use a cloud provider with a good reputation and high uptime, to avoid potential issues with jailing or slashing. Reputable cloud providers include (not exhaustively) Google Cloud Platform, Amazon Web Services, or Digital Ocean.
- We recommend you run your validator on a machine with at least 100GB of storage space, and much more if you plan to run without pruning or otherwise keep an archival node.
Software
Note: We highly recommend using a Linux-based operating system for your validator. If you are using Windows or MacOS, you may need to use a virtual machine to run your validator for compatibility.
Ensure that you have the following installed on your machine:
If running in a headless environment, we recommend a terminal-based text editor for easy modification of configuration files. A few examples are:
Building the OLLO binary
- Clone the repository containing the
ollod
source code:
git clone https://github.com/OLLO-Station/ollo -b v0.0.1 --single-branch
- Change into the cloned repository by running
cd ollo
- Build & install the binary by running the command
make install
- You should now have the OLLO binary installed in your
$GOPATH/bin
directory. You can check this by runningwhich ollod
and verifying that the output is$GOPATH/bin/ollod
- You can now run the
ollod
binary. Check the runnable commands by runningollod --help
Initializing the Node
Initialize your ollod
config directory with the appropriate testnet chain ID and a moniker (name) of your choice:
ollod init --chain-id "ollo-testnet-1" "<MONIKER>"
This will create a new directory at ~/.ollo
with the directory structure:
. # ~/.ollo root directory
|- data # Contains the databases used by the node.
|- config/ # Contains configuration files
|- app.toml # Application-related configuration file.
|- config.toml # Tendermint-related configuration file.
|- genesis.json # The genesis file.
|- node_key.json # Private key to use for node authentication in the p2p protocol.
|- priv_validator_key.json # Private key to use as a validator in the consensus protocol.
Initializing Your Keyring
- Add a new key to your validator keyring.
- If you have a funded OLLO wallet address, you can add the address to your keyring by passing your mnemonic with the
--recover
flag:
ollod keys add "<KEYNAME>" --recover --keyring-backend "os"
- After running the above comand, you will be prompted in-terminal to enter your mnemonic. After entering your mnemonic, your key will be available in your keyring.
- If you do not have a funded OLLO wallet address, you can generate a new key by running the following command:
ollod keys add "<KEYNAME>" --keyring-backend "os"
- Write down and securely store your generated mnemonic somewhere safe. Your new key will be in your keyring, secured by your chosen
--keyring-backend
value. To learn more about possible keyring backends, please consult the Cosmos SDK documentation.
- If you have a funded OLLO wallet address, you can add the address to your keyring by passing your mnemonic with the
You can check for the existence and details of your keyring by running the command:
ollod keys list
- Note that if no keys show up after running the above, you may need to pass the
--keyring-backend "os"
option as below:
ollod keys list --keyring-backend "os"
Note: Depending on your --keyring-backend
value, you may need to input a password to access your keyring.
Funding your address
If you intend to run a validator node, you will need OLLO Testnet tokens (denom: utollo
) to account for self-delegation and gas fees associated with broadcasting the create-validator
and edit-validator
transactions to the network. If your OLLO address is not funded, you can request testnet tokens from the OLLO testnet faucet in the OLLO Discord Server
Note: You must be verified in the OLLO Discord Server to receive testnet tokens from the discord faucet.
Configuring your node
After initializing your OLLO Testnet node, you will have a new OLLO home directory under your home directory, containing configuration and database files, located at ~/.ollo/
.
This directory has two main subdirectories, ~/.ollo/config
and ~/.ollo/data
.
* The ~/.ollo/config
directory contains configuration files which specify how your node should run, among other application parameters. It also contains the genesis file ~/.ollo/config/genesis.json
which you will pull from the official OLLO repository, and is necessary for starting your node and joining the network.
* The ~/.ollo/data
contains the node's blockchain data and application state.
Pulling Genesis
Next, pull the genesis.json
for the ollo-testnet-1
network from the OLLO Networks repository:
# Pull the genesis.json file for ollo-testnet-1 from the OLLO-Station/networks repository
wget https://raw.githubusercontent.com/OLLO-Station/networks/master/ollo-testnet-1/genesis.json
mv genesis.json ~/.ollo/config/genesis.json
Optionally, pull the default address book file from the same repository to bootstrap your node with existing peers on the network.
Alternatively, you can look over the public peers list to add persistent peers.
# Pull the addrbook.json file for ollo-testnet-1 from the OLLO-Station/networks repository
wget https://raw.githubusercontent.com/OLLO-Station/networks/master/ollo-testnet-1/addrbook.json
mv addrbook.json ~/.ollo/config/addrbook.json
Changing the Default Configuration
- Navigate to the OLLO config directory:
cd ~/.ollo/config
- Run the following commands to setup necessary services and configuration settings:
# to enable the REST api server
sed -i '/\[api\]/,+3 s/enable = false/enable = true/' ~/.ollo/config/app.toml
sed -i '/\[api\]/,+3 s/swagger = false/swagger = true/' ~/.ollo/config/app.toml
# to add persistent peers
sed -i 's/persistent_peers = ""/persistent_peers = "7864a2e4b42e5af76a83a8b644b9172fa1e40fa5@52.8.174.235:26656,a99fc4e81770ca32d574cac2e8680dccc9b55f74@18.144.61.148:26656"/' ~/.ollo/config/config.toml
Note: If the above persistent peers do not work for you, it is likely due to their network peer-to-peer connections are at capacity, in which case we'd advise looking at the peer list or acquiring peers addresses from others in the community, namely in the OLLO Discord.
Syncing Chain Data
You have a few options to sync your node to the OLLO network.
Syncing via Fast Sync
Fast sync is enabled by default as a means of syncing a node to the current height. In fast sync, chain blocks are downloaded in parallel, starting at genesis, and then verified, at speeds hundreds of times faster than normal consensus. No additional configuration is necessary to perform fast sync with a new node; you are configured to sync via fast sync upon first running your node.
Syncing via State Sync
State sync allows for a new node to quickly sync up to the current height of the network, by syncing from a height within ~1000 blocks of the current chain height, instead of from the ground up. Instead of downloading blocks & verifying them, state sync will look for snapshots at a trusted height, providing faster sync speeds and lower storage usage. It requires a few more parameters to be set correctly in order to properly sync, however. We'll set these below.
- To enable state sync, you first need to edit your node's
~/.ollo/config/config.toml
file and enable statesync by first finding the[statesync]
heading, thenenable
field. You can do this automatically as follows:
# To enable state sync
sed -i '/\[statesync\]/,+3 s/enable = false/enable = true/' ~/.ollo/config/config.toml
Next, you'll need to specify RPC endpoints for state sync to gather information from. Three public RPC node endpoints are provided by the OLLO Station8 validators.
Chain ID | RPC endpoint | Peer address |
---|---|---|
ollo-testnet-1 | https://node.ollo.zone | a99fc4e81770ca32d574cac2e8680dccc9b55f74@18.144.61.148:26656 |
ollo-testnet-1 | https://rpc.ollo.zone | 70ba32724461c7ed4ec8d6ddc8b5e0b1cfb9e237@54.219.57.63:26656 |
ollo-testnet-1 | 7864a2e4b42e5af76a83a8b644b9172fa1e40fa5@52.8.174.235:26656 |
Direct HTTP IP links are below
Chain ID | RPC endpoint | Peer address |
---|---|---|
ollo-testnet-1 | http://18.144.61.148:26657 | a99fc4e81770ca32d574cac2e8680dccc9b55f74@18.144.61.148:26656 |
ollo-testnet-1 | http://54.219.57.63:26657 | 70ba32724461c7ed4ec8d6ddc8b5e0b1cfb9e237@54.219.57.63:26656 |
ollo-testnet-1 | http://52.8.174.235:26657 | 7864a2e4b42e5af76a83a8b644b9172fa1e40fa5@52.8.174.235:26656 |
Next, we'll replace the empty state sync parameters under the [statesync]
heading using the sed
command. Copy and paste the below into your terminal to do so:
# First, set the RPC server addresses you wish to connect to
RPC1="https://18.144.61.148:26657"; \
RPC2="http://52.8.174.235:26657"; \
# Next we'll set the block height at which state sync should begin syncing
# from, plus the corresponding height and hash of the block
LATEST_HEIGHT=$(curl -s $RPC1/block | jq -r .result.block.header.height); \
BLOCK_HEIGHT=$((LATEST_HEIGHT - 1000)); \
TRUST_HASH=$(curl -s "$RPC1/block?height=$BLOCK_HEIGHT" | jq -r .result.block_id.hash); \
# Finally, we'll perform a sed command to replace values in ~/.ollo/config/config.toml
# with the rpc server addresses, and block information
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true|" ~/.ollo/config/config.toml ; \
sed -i.bak -E "s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC1,$RPC2\"|" ~/.ollo/config/config.toml;\
sed -i.bak -E "s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$BLOCK_HEIGHT|" ~/.ollo/config/config.toml; \
sed -i.bak -E "s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" ~/.ollo/config/config.toml
You should now be configured to state sync to the network. If you're having trouble, alternative state sync instructions are provided on the OLLO Explorer
Creating a Service File
It is highly advised that you run your OLLO node under a service wrapper. Running OLLO underneath a service wrapper allows for certain reliability-enhancing features, essential for Validators, such as auto-restarts.
Systemd Service
On most Linux-based systems, the default packaged process manager is systemd
. To run OLLO as a service under systemd
, run the following:
sudo tee /etc/systemd/system/ollo.service > /dev/null <<EOF
[Unit]
Description=OLLO Daemon
After=network-online.target
[Service]
User=$USER
ExecStart=$(which ollod) start
Restart=always
RestartSec=3
LimitNOFILE=8192
[Install]
WantedBy=multi-user.target
EOF
Cosmovisor
Cosmovisor is a process manager developed to relieve node operators of having to manually intervene every time there is an upgrade. Cosmovisor monitors the governance module for upgrade proposals; it will take care of downloading the new binary, stopping the old one, switching to the new one, and restarting.
For more information on how to run a node via Cosmovisor, check out the docs.
After you have gone through the Cosmovisor setup process for the OLLO binary, outlined in the link above, to create a service file for OLLO running under Cosmovisor, run the following:
sudo tee /etc/systemd/system/ollo.service > /dev/null <<EOF
[Unit]
Description=OLLO Cosmovisor Daemon
After=network-online.target
[Service]
User=$USER
ExecStart=$(which cosmovisor) start
Restart=always
RestartSec=3
LimitNOFILE=8192
[Install]
WantedBy=multi-user.target
Environment="DAEMON_HOME=$HOME/.ollo"
Environment="DAEMON_NAME=ollod"
Environment="DAEMON_ALLOW_DOWNLOAD_BINARIES=true"
Environment="DAEMON_RESTART_AFTER_UPGRADE=true"
EOF
Running the service
Run the following to properly enable the service:
sudo systemctl daemon-reload
sudo systemctl enable ollo
Then you are ready to start the service you defined above.
# Start the service
sudo systemctl start ollo
# Check log output
journalctl -fu ollo -o cat
The system status can also be checked with the command systemctl status ollo
.
You can restart the service by running sudo systemctl restart ollo
, and stop the service by running sudo systemctl stop ollo
. Finally, you can check the running service's status with the command sudo systemctl status ollo
, and if necessary, can disable/enable the service by running sudo systemctl disable ollo
and sudo systemctl enable ollo
respectively.
Syncing via Downloaded Chain Data
Note: We will be configuring a source location where the most recent automatically uploaded snapshots of the chain state will be posted. Stay tuned!