Skip to content

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.




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.


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

  1. Clone the repository containing the ollod source code:
git clone -b v0.0.1 --single-branch
  1. Change into the cloned repository by running cd ollo
  2. Build & install the binary by running the command make install
  3. You should now have the OLLO binary installed in your $GOPATH/bin directory. You can check this by running which ollod and verifying that the output is $GOPATH/bin/ollod
  4. You can now run the ollod binary. Check the runnable commands by running ollod --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

  1. 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.

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
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
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@,a99fc4e81770ca32d574cac2e8680dccc9b55f74@"/' ~/.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, then enable 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 IDRPC endpointPeer address

Direct HTTP IP links are below

Chain IDRPC endpointPeer address

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=""; \
RPC2=""; \

# 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); \
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  
Description=OLLO Daemon

ExecStart=$(which ollod) start



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  
Description=OLLO Cosmovisor Daemon

ExecStart=$(which cosmovisor) start


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!