1. Prepare Your Environment

• System Requirements: Ensure your server meets the basic requirements. It's recommended to use a Linux-based system (preferably Ubuntu).
• Install Dependencies: Start by installing necessary packages:

sudo apt-get update
sudo apt-get install build-essential clang pkg-config libssl-dev gcc-multilib protobuf-compiler

2. Install Rust

• Rust Installation: Fleek Network is built using Rust, so you need to install Rust:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
rustup update

3. Clone the Fleek Network Repository

• Clone the Source Code: Download the latest version of the Fleek Network node software from GitHub:

git clone -b testnet-alpha-1 https://github.com/fleek-network/lightning.git ~/fleek-network/lightning
cd ~/fleek-network/lightning

4. Build the Node

• Compile the Node: Navigate to the project directory and build the node using Rust’s package manager:

cargo clean
cargo update
cargo +stable install --locked --path core/cli --features services

Link the Executable: To make the node command globally accessible, create a symbolic link:

sudo ln -s "$HOME/.cargo/bin/lightning-node" /usr/local/bin/lgtn

5. Configure and Run the Node

• Node Configuration: Before starting the node, you might need to configure it using the lightning.toml file. The default configuration should suffice for most cases, but adjustments can be made based on your setup.
• Start the Node: Run the node using the following command:

lgtn run

Opt-In to Network Participation: To participate in the network, you must opt-in:

lgtn opt in

6. Monitor and Maintain the Node

• Systemd Service: It's advisable to manage your node using systemd to ensure it restarts automatically in case of failure:

[Unit]
Description=Fleek Network Node
After=network.target

[Service]
Type=simple
User=your_username
ExecStart=/usr/local/bin/lgtn run
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

After saving the service file, enable and start the service:

sudo systemctl enable fleek-node
sudo systemctl start fleek-node

7. Keep the Node Updated

• Regular Updates: Since Fleek Network is in active development, frequently pull the latest changes from the GitHub repository and rebuild the node to ensure you're running the latest version:

git pull origin testnet-alpha-1
cargo clean
cargo update
cargo +stable install --locked --path core/cli --features services

In this guide, I will try to describe in detail the process of installing and configuring the bot for the following situations: missed blocks, changes in voting power, getting jailed, losing synchronization, and critical server disk space usage.

In this guide, I will use a universal solution for monitoring multiple nodes simultaneously, so I will install the bot on a separate server. If you need to monitor only one node, all actions can be performed on the server with that node, and you can use the notes in the purple frames.

• Server preparation
• Installation of Panic!
• Setting up the Telegram bot
• Setting up Redis
• Connecting a node to monitoring
• Start Panic!
• Adding nodes for monitoring
• Changing settings

Content

Panic! doesn't use many resources, so it can be installed on the simplest server, such as Hetzner - CPX11.

Update your packages

sudo apt update && sudo apt upgrade -y

Check if Python3 is installed on your server. In most distributions, Python is pre-installed

python3 --version

Install PIP Package Manager and Redis Database Server

sudo apt-get install python3-pip redis-server -y

Install Pipenv Packaging Tool

sudo pip3 install pipenv
sudo systemctl enable redis-server.service

Content

Create a new user for using Panic!

adduser panic --disabled-login

Create a folder and change access permissions

mkdir /opt/panic
chown -R panic:panic /opt/panic
su panic

Navigate to the folder and clone the repository

cd /opt/panic/
git clone https://github.com/SimplyVC/panic_cosmos.git
cd panic_cosmos
git checkout master

Update the packages and start the Panic! setup

pipenv update
pipenv run python run_setup.py

Enter a unique identifier for notifications. For example, your moniker

Content

Setting up Telegram notifications by pressing Y

Next, we need to enter the API token. To obtain it, follow these steps:

Now that we have the bot, API token, and chat ID, let's return to the terminal and continue setting up Panic!

Next, Panic! will ask if other notifications are needed (email, phone calls, or periodic alerts). Since we are setting up only the Telegram bot, respond with "n" to all three requests.

Setting up commands for the Telegram bot.

Content

To configure Redis, we will use the default values:

• Redis host IP: localhost
• Redis host port: 6379
• Redis password: none
• Press Y and then Enter three times.

Test Redis functionality by pressing Y.

Content

Navigate to the server with the node you want to connect to the bot and make changes to the configuration file. For example, I'll use the Haqq node. For connecting to other nodes, use your path to the configuration file

(usually - $HOME/.project_name/config/config.toml).

nano ~/.haqqd/config/config.toml

In the "TCP or UNIX socket address for the RPC server to listen on" block, change the value of "laddr".

laddr = "tcp://0.0.0.0:26657"

Save with: Ctrl + X > Y > Enter

laddr = "tcp://127.0.0.1:26657"

Reload node

sudo systemctl restart haqq

Make these changes to the configuration files of all nodes you want to monitor.

Return to the Panic! server!

Enter the node's name and RPC URL in the format http://NODE_IP:26657, confirm that the node is a validator. Additionally, you can add other nodes right away, but we will do that later.

Also, skip setting up GitHub updates. We will do this a bit later..

Content

Creating a service file

printf "[Unit]
Description=P.A.N.I.C.
After=network.target
StartLimitIntervalSec=0

[Service]
Type=simple
Restart=always
User=panic
TimeoutStopSec=90s
WorkingDirectory=/opt/panic/panic_cosmos
ExecStart=/usr/local/bin/pipenv run python /opt/panic/panic_cosmos/run_alerter.py

[Install]
WantedBy=multi-user.target" > /etc/systemd/system/panic.service

Start the service and check the logs

sudo systemctl daemon-reload
sudo systemctl enable panic
sudo systemctl start panic
sudo journalctl -u panic -f

Content

On the server with the node you want to connect to the bot, make changes to the configuration file.

nano ~/.<node_name>/config/config.toml
#or another path to config.toml

In the "TCP or UNIX socket address for the RPC server to listen on" block, change the value of laddr

laddr = "tcp://0.0.0.0:26657"

Save with: Ctrl + X > Y > Enter

Reload node

sudo systemctl restart haqq

Return to the Panic! server. Edit the file user_config_nodes.ini

nano /opt/panic/panic_cosmos/config/user_config_nodes.ini

Copy all existing lines and paste them below. Modify the number, name, and URL. Save the changes.

Reload Panic! bot

sudo systemctl restart panic
sudo journalctl -u panic -f

Check to ensure that the second node appears in the logs.

Repeat the procedure for all remaining nodes you are maintaining.

For additional verification, you can briefly stop the node (exercise caution here; only proceed if you are sure you can reconnect afterward or if you won't get jailed).

The bot will react as follows:

Content

To change the settings of the bot (API token, Redis password, etc.) and to enable email notifications, edit the file user_config_main.ini.

nano /opt/panic/panic_cosmos/config/user_config_main.ini

To configure notifications for changes in GitHub repositories, edit the file user_config_repos.ini.

nano /opt/panic/panic_cosmos/config/user_config_repos.in

Note: In order to become an active validator, you need to have more ua0gi tokens bonded than the last validator ordered by the tokens bonded (or the validator set to not be full) as well as have at least 1000000ua0gi bonded.

Installation

Use our installation script, specify a name for your node and wait for the installation to complete.

Copy

wget -q -O 0g.sh https://api.nodes.guru/0g.sh && sudo chmod +x 0g.sh && ./0g.sh && source $HOME/.bash_profile

Create a wallet, don’t forget to save the mnemonic:

Copy

0gchaind keys add wallet --eth

If you already have a wallet, you can recover with:

Copy

0gchaind keys add wallet --recover --eth

If you want to get the public address which starts with 0x, you could first run the following command to get your key’s private key. Then import the returned private key to a wallet (Metamask for example) to get the public address.

Copy

0gchaind keys unsafe-export-eth-key wallet

Request tokens at the faucet. After full synchronization, check the balance, if everything is okay, proceed to create a validator.

Copy

0gchaind q bank balances $(0gchaind keys show wallet -a)

You can also check your balance in our explorer.

Create a validator:

Copy

0gchaind tx staking create-validator \  --amount=1000000ua0gi \  --pubkey=$(0gchaind tendermint show-validator) \  --moniker="$VALIDATOR" \  --chain-id="zgtendermint_16600-2" \  --commission-rate="0.10" \  --commission-max-rate="0.20" \  --commission-max-change-rate="0.01" \  --min-self-delegation="1" \  --gas=auto \  --gas-adjustment=1 \  --from=wallet -y

Additional

View logs

Copy

sudo journalctl -u 0g -f

Restart node:

Copy

sudo systemctl restart 0g

Check node status:

Copy

curl localhost:26657/status

Find out if the node is synchronized, if the result is false – it means the node is synchronized

Copy

curl -s localhost:26657/status | jq .result.sync_info.catching_up

Find out your valoper address:

Copy

0gchaind keys show wallet --bech val -a

Delegate tokens (to increase your stake delegate to your valoper address):

Copy

0gchaind tx staking delegate YOUR_VALOPER_ADDRESS 1000000ua0gi --from wallet --chain-id zgtendermint_16600-2 --gas="500000" --gas-prices="50ua0gi"

Remove node:

Copy

sudo systemctl stop 0gsudo systemctl disable 0gsudo rm -rf $(which 0gchaind) $HOME/.0gchain

That's it! Congrats!

• Basic Commands
• Useful utilities
• Packages
• Programming languages
• Running programs using screen

Content

sudo apt-get install git 
# command installs the git package with administrator privileges.

cd /usr/bin #navigate to the subdirectory /bin in the /usr directory.

cd #go to HOME catalogue

cp addrbook.json /home/config 
# Creates a copy of addrbook.json from the current directory in the directory /home/config.

mv addrbook.json /home/config
# moves addrbook.json from the current directory to the directory /home/config.

mv old_name.txt new_name.txt
# renames the file old_name.txt to new_name.txt.  

mkdir Backup
# creates a subdirectory Backup in the current directory

rm addrbook.json
#deleting a file that is not write-protected

rm -f addrbook.json
#deleting a file that is write-protected

rm -r config
#deleting a directory that is not write-protected.

rm -rf config 
#deleting a directory that is write-protected

top

df
#report on the used disk space in kilobytes
df -m
#report on the used disk space in megabytes

sudo journalctl -u evmosd -f |grep block
#command to search for lines containing the word "block" in the logs of the Evmos node

grep peers config.toml
#command to search for lines containing the word "peers" in the file addrbook.json.   

wget https://golang.org/dl/go1.17.5.linux-amd64.tar.gz
# command to download GO

tar -xzf go1.17.5.linux-amd64.tar.gz
#extracting an archive into the current directory 
tar -C /usr/local -xzf go1.17.5.linux-amd64.tar.gz
#extracting an archive into the directory /usr/local

chmod u+x file.sh #allow execution for the owner

chmod +x file.sh #allow execution for everyone

chmod ug+w file.sh #allow write permission for the owner and group

chmod ugo+rwx file.sh #allow all permissions for everyone

echo Nick >> nickname.txt
# appends the text "Nick" to the file nickname.txt
echo "export NICKNAME="Nick"" >> ~/.bash_profile
# adds a variable to the system environment

Content

Content

sudo apt install make

Content

This section provides commands for installing various programming languages commonly used by developers of crypto projects, necessary for the proper installation and operation of nodes.

wget https://go.dev/dl/go1.18.4.linux-amd64.tar.gz; \
rm -rv /usr/local/go; \
tar -C /usr/local -xzf go1.18.4.linux-amd64.tar.gz && \
rm -v go1.18.4.linux-amd64.tar.gz && \
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> ~/.bash_profile && \
source ~/.bash_profile && \
go version

RUST

Rust is a multi-paradigm compiled general-purpose programming language that combines functional and procedural programming paradigms with an object system based on traits.

# installing necessary packages
sudo apt install curl build-essential gcc make -y
# downloading the Rust installation script
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Select option 1) to continue installation (default).

# activate the Rust environment for the current shell
source ~/.profile
source ~/.cargo/env
# install nightly
rustup toolchain install nightly
rustup default nightly

Content

If you need to run a program in the background, you can use screen. Screen is a utility that allows you to run applications in the background. This utility is useful because you can start any process and disconnect from the SSH session, and the process will continue to run.

Installation of screen:

sudo apt-get install screen 

To create a new session (terminal), you use the -S flag.

screen -S <programm_name> 

To detach and return to the main terminal use the key combination Ctrl+A+D

To attach to an existing session use the -x flag

screen -x <programm_name>

You can view the list of running terminals with the command

screen -ls

To stop and remove a terminal, use the combination Ctrl + D