In the crypto world, there are several strategies that can be applied to be eligible for an airdrop:

• farming in DeFi, as with Arbitrum or the one coming up on LayerZero;

• staking in the Cosmos ecosystem, particularly $ATOM and $OSMO;

• being a tester on a testnet, specifically by serving as a dApp beta tester or validator node.

Today I talk about the third category, that is, operations in testnet via validator nodes.

What, however, are validator nodes?

Validator nodes in a distributed network based on the Proof-of-Stake consensus algorithm are entities that stake a certain amount of coins and the protocol will randomly assign them the right to validate a block in order to obtain transaction fees and eventual economic incentives.

The probability of being chosen changes from chain to chain, but is usually proportional to the amount of coins held: the more coins there are in stakes, the greater the probability of validating the next block.

However, when a project is also under development, it needs time to be tested and it is not always easy to detect any vulnerabilities. For this reason, many make use of incentivized testnets, i.e., test networks with dummy coins in order to detect any problems or vulnerabilities.

Once the project launches in the mainnet, those who participated in the testnet receive a reward for their work. This has been the case for many successful projects:

• $TIA airdrop, +10’000$

• $MINA airdrop, +80’000$

• $GRT airdrop, +25’000$

• $APT airdrop, +7’500$

Today in this article I tell you about some of the most interesting projects of the moment and which are likely to reward their users with an allocation in airdrop.

Let's start!

Babylon Chain - Bitcoin Staking Protocol

Babylon Chain is a new project in the Cosmos ecosystem, which intends to use BTC as a staking capital to validate Proof-of-Stake chains and generate a yield. The goal of Babylon Chain is to create a stack, which will also be usable by other projects interested in using a shared security protocol.

For more details regarding how Babylon Chain works, I recommend that you refer to their litepaper.

Don’t forget to subscribe on Mirror to stay tuned to all future articles.

Babylon Node Installation - Step-by-Step Guide

To begin the procedure, you need a computer with any Linux distro installed, Ubuntu 20.04 or later will do, an SSD with +200 GB and a fast Internet connection.

For those without resources capable of supporting a validator node at home, you can fall back on VPS (Virtual Private Server) solutions, that is, you can rent a virtual server.

There are several solutions, which I recommend below:

• Contabo, I recommend the Cloud VPS M model, with 6 vCPU Cores, 16 GB RAM, 400 GB SSD SATA3;

• Aeza, I recommend at least the VIEs-3 or PARs-3 model, with 4 vCPU Cores, 8 GB RAM, 120 GB NVMe. This is a Russian VPS service and payment by credit/debit card is not possible from many Western countries, but payments in crypto (BTC, BEP20, ERC20, TRC20, DASH, LTC, XMR...) are possible.

After payment is made, you will receive the IP address to access.

If operating from Windows, download the PuTTy app - SSH and telnet client - and enter the IP address of the VPS. A Linux terminal screen will open for you.

Enter the username (usually root) and password you chose at the time of purchase. If you have done everything correctly, the following screen will appear:

⚠️ Disclaimer ⚠️: Launch every command one by one. Entering more commands together could break the installation process or bring to fatal errors.

Now enter the following commands and execute them:

sudo apt -y update
sudo apt -y upgrade
sudo apt -y install curl git jq lz4 build-essential
sudo apt autoremove

Set the name you want to give to your validator node, in my case outergod:

MONIKER=”outergod”

Be sure to install Golang in the correct way, otherwise you may run into malfunctions. In my case, I installed version 1.21.5, but from their website make sure it is the latest version available

sudo rm -rf /usr/local/go 
curl -Ls https://go.dev/dl/go1.21.5.linux-amd64.tar.gz | sudo tar -xzf - -C /usr/local 
eval $(echo 'export PATH=$PATH:/usr/local/go/bin' | sudo tee /etc/profile.d/golang.sh) 
eval $(echo 'export PATH=$PATH:$HOME/go/bin' | tee -a $HOME/.profile)

go version

Executing go version should bring you back a message similar to the following:

At this point we are ready to install the actual Babylon Chain node. Copy and paste the following commands one at a time:

git clone https://github.com/babylonchain/babylon.git
cd babylon/
git checkout v0.7.2

Refer to their Github to find out what the latest release is, which right now is 0.7.2.

make install
make build
mkdir -p $HOME/.babylond/cosmovisor/genesis/bin 
mv build/babylond $HOME/.babylond/cosmovisor/genesis/bin/ 
rm -rf build 

sudo ln -s $HOME/.babylond/cosmovisor/genesis $HOME/.babylond/cosmovisor/current -f 

sudo ln -s $HOME/.babylond/cosmovisor/current/bin/babylond /usr/local/bin/babylond -f

We now install Cosmovisor and create the service:

go install cosmossdk.io/tools/cosmovisor/cmd/cosmovisor@v1.5.0

Launch the following block all together:

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

[Service]
User=$USER
ExecStart=$(which babylond) start
Restart=on-failure
RestartSec=10
LimitNOFILE=65535
Environment="DAEMON_HOME=$HOME/.babylond"
Environment="DAEMON_NAME=babylond"
Environment="UNSAFE_SKIP_BACKUP=true"
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:$HOME/.babylond/cosmovisor/current/bin"

[Install]
WantedBy=multi-user.target
EOF

Then enable the babylon.service:

sudo systemctl daemon-reload
sudo systemctl enable babylon.service

Let's configure the node and initialize it:

babylond config chain-id bbn-test-2
babylond config keyring-backend test
babylond config node tcp://localhost:16457

babylond init $MONIKER --chain-id bbn-test-2

curl -L https://snapshots-testnet.nodejumper.io/babylon-testnet/genesis.json > $HOME/.babylond/config/genesis.json

curl -L https://snapshots-testnet.nodejumper.io/babylon-testnet/addrbook.json > $HOME/.babylond/config/addrbook.json

sed -i \
  -e 's|^seeds *=.*|seeds = ""|' \
  -e 's|^peers *=.*|peers = "03ce5e1b5be3c9a81517d415f65378943996c864@18.207.168.204:26656,a5fabac19c732bf7d814cf22e7ffc23113dc9606@34.238.169.221:26656,ade4d8bc8cbe014af6ebdf3cb7b1e9ad36f412c0@testnet-seeds.polkachu.com:20656"|' \
  $HOME/.babylond/config/config.toml

sed -i -e "s|^minimum-gas-prices *=.*|minimum-gas-prices = \"0.00001ubbn\"|" $HOME/.babylond/config/app.toml

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/.babylond/config/app.toml

sed -i 's|^network *=.*|network = "mainnet"|g' $HOME/.babylond/config/app.toml

Download the most recent snapshot:

curl "https://snapshots-testnet.nodejumper.io/babylon-testnet/babylon-testnet_latest.tar.lz4" | lz4 -dc - | tar -xf - -C "$HOME/.babylond"

Activate the node and check the logs.

sudo systemctl start babylon.service && sudo journalctl -u babylon.service -f --no-hostname -o cat

If the logs report no fatal errors, the node installation should have been successfully achieved!

Now let's make the node capable of validating blocks.

Becoming a Validator on Babylon Chain - Step-by-Step Guide

Nodes in order to be chain validators require to have funds for two reasons:

• Being able to self-delegate coins;

• Being able to pay tx fees related to BLS signatures. Babylon currently supports only test keyring backends, but in the future other types of encrypted backends provided by the Cosmos SDK will be supported.

This requires creating a new Cosmos wallet, which we can generate by running the following command:

babylond keys add wallet

Save the 24 generated words in a safe offline place, which can be a notebook, and keep the generated public address in an easily accessible place on your PC, which you will need to make the request to the faucet present on the official Babylon Discord group.

Create at this point a BLS key so that you can sign transactions at the end of each epoch. To do this, run the command:

babylond create-bls-key $(babylond keys show wallet -a)

After creating the BLS key, do a restart of the node:

sudo systemctl stop babylon.service
sudo systemctl start babylon.service

Having restarted the node, we need to specify the key name to be used by the validator node for BLS tx signatures contained in $HOME/.babylond/config/app.toml file.

sed -i -e "s|^key-name *=.*|key-name = \"wallet\"|" $HOME/.babylond/config/app.toml

It is recommended to change the configuration, increasing the timeout_commit to 10 seconds between blocks, which is the waiting time required for a validator before committing a block. I report the related code:

sed -i -e "s|^timeout_commit *=.*|timeout_commit = \"10s\"|" $HOME/.babylond/config/config.toml

We are ready to request a faucet on Babylon’s Discord by typing !faucet <public address>. Their faucet can be used once every 24 hours, not hourly!

To actually create the validator, we run the command babylond tx checkpointing create-validator. To give context:

• in --moniker put$MONIKER in case you have initialized the moniker variable as indicated at the beginning of the guide;

• in --identity report the Keybase or uPort ID of your website, in case you have one or are interested in adding that information. If you do not have it, delete the line for identity;

• --details and --website are also optional information that can be added later.

babylond tx checkpointing create-validator \
--amount 1000000ubbn \
--pubkey $(babylond tendermint show-validator) \
--moniker "YOUR_MONIKER_NAME" \
--identity "YOUR_KEYBASE_ID" \
--details "YOUR_DETAILS" \
--website "YOUR_WEBSITE_URL" \
--chain-id bbn-test-2 \
--commission-rate 0.05 \
--commission-max-rate 0.20 \
--commission-max-change-rate 0.01 \
--min-self-delegation 1 \
--from wallet \
--gas-adjustment 1.4 \
--gas auto \
--gas-prices 0.00001ubbn \
-y

To change the validator node parameters, use the following command, reporting the change you are interested in:

babylond tx staking edit-validator --new-moniker "NewName" --from wallet --chain-id bbn-test-2 --fees 100ubbn -y

Congratulations, you have successfully completed the installation of your node!

I now leave you with a set of useful commands for monitoring your validator node.

# Query wallet balance
babylond q bank balances $(babylond keys show wallet -a)

# Query validator details
babylond q staking validator $(babylond keys show wallet --bech val -a)

# Unjail validator
babylond tx slashing unjail --from wallet --chain-id bbn-test-2 --gas-adjustment 1.4 --gas auto --fees 10ubbn -y

# Jail reason
babylond query slashing signing-info $(babylond tendermint show-validator)

The guide you read is for educational purposes. Babylon has not released any information about its tokenomics nor airdrop, so this is an educational content. If you like my work, I suggest you to subscribe and mint the entry in order to support my work.

Here you can find my node validator on the Babylon Chain testnet. You can also support me by delegating your testnet tokens to my node.