Cyber_pain

Contacts

URL

X / Twitter

https://x.com/Cyber__pain

Keybase

https://keybase.io/cyber_pain

Technical features

Project

Status

Fleek

🟢 Active 🟢

GaiaNet

🟢 Active 🟢

Swisstronik

🟢 Active 🟢

Installation Guide Fleek

Preparing the system.


# 1. Update and install dependencies
sudo apt update && sudo apt upgrade -y
sudo apt install build-essential jq curl git wget -y

# 2. Install Go
wget https://go.dev/dl/go1.20.5.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc
go version

# 3. Clone Fleek Network repository
git clone https://github.com/fleekxyz/fleek-network.git
cd fleek-network

# 4. Build Fleek Network binary
make build
sudo cp build/fleekd /usr/local/bin/

# 5. Initialize the node
fleekd init <your_node_name> --chain-id fleek-testnet

# 6. Configure the node
PEERS="<add_peers_here>"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" ~/.fleekd/config/config.toml
sed -i 's/minimum-gas-prices =.*/minimum-gas-prices = "0.01ufleek"/' ~/.fleekd/config/app.toml

# 7. Download the genesis file
curl -o ~/.fleekd/config/genesis.json https://link_to_genesis_file

# 8. Create a service file
sudo tee /etc/systemd/system/fleekd.service > /dev/null <<EOF
[Unit]
Description=Fleek Network Node
After=network-online.target

[Service]
User=$USER
ExecStart=$(which fleekd) start
Restart=on-failure
LimitNOFILE=4096

[Install]
WantedBy=multi-user.target
EOF

# 9. Start and enable the service
sudo systemctl daemon-reload
sudo systemctl enable fleekd
sudo systemctl start fleekd

# 10. Check node synchronization status
fleekd status 2>&1 | jq .SyncInfo

# 11. Create a validator (once synced)
fleekd keys add <wallet_name>

# Fund wallet with testnet tokens, then create validator
fleekd tx staking create-validator \
  --amount=1000000ufleek \
  --from=<wallet_name> \
  --commission-max-change-rate="0.01" \
  --commission-max-rate="0.20" \
  --commission-rate="0.10" \
  --min-self-delegation="1" \
  --pubkey=$(fleekd tendermint show-validator) \
  --moniker=<your_node_name> \
  --chain-id=fleek-testnet \
  --gas=auto \
  --fees=2000ufleek

# 12. Check validator status
fleekd query staking validator $(fleekd keys show <wallet_name> --bech val -a)
```

Installation Guide GaiaNet

Preparing the system.

# 1. Update and install dependencies
sudo apt update && sudo apt upgrade -y
sudo apt install build-essential jq curl git wget -y

# 2. Install Go
wget https://go.dev/dl/go1.20.5.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc
go version

# 3. Clone GaiaNet repository
git clone https://github.com/gaianet/gaia.git
cd gaia

# 4. Build GaiaNet binary
make build
sudo cp build/gaiad /usr/local/bin/

# 5. Initialize the node
gaiad init <your_node_name> --chain-id gaia-testnet

# 6. Configure the node
PEERS="<add_peers_here>"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" ~/.gaiad/config/config.toml
sed -i 's/minimum-gas-prices =.*/minimum-gas-prices = "0.025uatom"/' ~/.gaiad/config/app.toml

# 7. Download the genesis file
curl -o ~/.gaiad/config/genesis.json https://link_to_genesis_file

# 8. Create a service file
sudo tee /etc/systemd/system/gaiad.service > /dev/null <<EOF
[Unit]
Description=GaiaNet Node
After=network-online.target

[Service]
User=$USER
ExecStart=$(which gaiad) start
Restart=on-failure
LimitNOFILE=4096

[Install]
WantedBy=multi-user.target
EOF

# 9. Start and enable the service
sudo systemctl daemon-reload
sudo systemctl enable gaiad
sudo systemctl start gaiad

# 10. Check node synchronization status
gaiad status 2>&1 | jq .SyncInfo

# 11. Create a validator (once synced)
gaiad keys add <wallet_name>

# Fund wallet with testnet tokens, then create validator
gaiad tx staking create-validator \
  --amount=1000000uatom \
  --from=<wallet_name> \
  --commission-max-change-rate="0.01" \
  --commission-max-rate="0.20" \
  --commission-rate="0.10" \
  --min-self-delegation="1" \
  --pubkey=$(gaiad tendermint show-validator) \
  --moniker=<your_node_name> \
  --chain-id=gaia-testnet \
  --gas=auto \
  --fees=2000uatom

# 12. Check validator status
gaiad query staking validator $(gaiad keys show <wallet_name> --bech val -a)

Installation Guide Swisstronik

Preparing the system.

# 1. Update and install dependencies
sudo apt update && sudo apt upgrade -y
sudo apt install build-essential jq curl git wget -y

# 2. Install Go
wget https://go.dev/dl/go1.20.5.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc
go version

# 3. Clone Swisstronik repository
git clone https://github.com/swisstronik/swisstronik.git
cd swisstronik

# 4. Build Swisstronik binary
make build
sudo cp build/swisstronik /usr/local/bin/

# 5. Initialize the node
swisstronik init <your_node_name> --chain-id swisstronik-testnet

# 6. Configure the node
PEERS="<add_peers_here>"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" ~/.swisstronik/config/config.toml
sed -i 's/minimum-gas-prices =.*/minimum-gas-prices = "0.01uswi"/' ~/.swisstronik/config/app.toml

# 7. Download the genesis file
curl -o ~/.swisstronik/config/genesis.json https://link_to_genesis_file

# 8. Create a service file
sudo tee /etc/systemd/system/swisstronik.service > /dev/null <<EOF
[Unit]
Description=Swisstronik Node
After=network-online.target

[Service]
User=$USER
ExecStart=$(which swisstronik) start
Restart=on-failure
LimitNOFILE=4096

[Install]
WantedBy=multi-user.target
EOF

# 9. Start and enable the service
sudo systemctl daemon-reload
sudo systemctl enable swisstronik
sudo systemctl start swisstronik

# 10. Check node synchronization status
swisstronik status 2>&1 | jq .SyncInfo

# 11. Create a validator (once synced)
swisstronik keys add <wallet_name>

# Fund wallet with testnet tokens, then create validator
swisstronik tx staking create-validator \
  --amount=1000000uswi \
  --from=<wallet_name> \
  --commission-max-change-rate="0.01" \
  --commission-max-rate="0.20" \
  --commission-rate="0.10" \
  --min-self-delegation="1" \
  --pubkey=$(swisstronik tendermint show-validator) \
  --moniker=<your_node_name> \
  --chain-id=swisstronik-testnet \
  --gas=auto \
  --fees=2000uswi

# 12. Check validator status
swisstronik query staking validator $(swisstronik keys show <wallet_name> --bech val -a)

This script provides all the necessary steps to set up and run a Swisstronik validator node from scratch. Make sure to replace the placeholders like <your_node_name>, <add_peers_here>, and <wallet_name> with your actual values.

Installation guide PEAQ


### **Prerequisites:**

1. **Hardware Requirements**:
   - **CPU**: Minimum of 2 cores, recommended 4+ cores.
   - **RAM**: Minimum 8 GB, recommended 16 GB or more.
   - **Storage**: SSD with at least 100 GB of free space, recommended 500 GB.
   - **Network**: Stable internet connection with at least 100 Mbps download/upload speed.

2. **Software Requirements**:
   - A Linux-based operating system is preferred (e.g., Ubuntu).
   - **Docker**: Optional but recommended for easier deployment.
   - **Rust** (optional, for building from source).
   - **Node.js** (if you're working with a custom front-end).

3. **Account on Peaq Network**: Make sure you have an account and the necessary PEQ tokens to stake as collateral.

4. **Basic understanding** of blockchain operations (especially validators and staking).

---

### **Steps to Launch a Validator Node on Peaq Network:**

---

#### **Step 1: Install Rust & Dependencies**

If you're planning to build the node software from scratch, you'll need to install Rust and related tools.

```bash
# Update your system
sudo apt update
sudo apt upgrade

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Restart your terminal session after installation
source $HOME/.cargo/env

# Install other dependencies
sudo apt install -y libclang-dev build-essential pkg-config libssl-dev
```

---

#### **Step 2: Clone the Peaq Validator Repository**

Now, clone the official repository from Peaq to get the node software.

```bash
# Clone the repository
git clone https://github.com/peaqnetwork/peaq-node.git

# Navigate to the directory
cd peaq-node
```

---

#### **Step 3: Build the Validator Node**

Once you have the source code, you can compile the node:

```bash
# Build the node (it may take a while)
cargo build --release
```

---

#### **Step 4: Set Up the Validator Node Configuration**

Before you can start the validator, you’ll need to configure it.

1. **Generate a Validator Key**:
   
   You will need a validator key pair for the node to participate in the network.

   ```bash
   ./target/release/peaq-node keygen
   ```

   This will output the necessary key pairs. Save them securely for later use.

2. **Edit Configuration Files**:

   Depending on whether you're setting up a validator or a collator node, you'll need to configure the `.toml` file. Look for the configuration in the `config` directory or edit through command-line flags.

   - Set your **validator identity** and make sure to specify your peer connection details and network bootnodes.

---

#### **Step 5: Set Up a Docker Container (Optional)**

If you prefer using Docker for deploying the validator, you can use the provided Dockerfiles in the repository:

1. **Build Docker Image**:

   ```bash
   docker build -t peaq-validator .
   ```

2. **Run the Validator Node**:

   Once the image is built, run the container with appropriate flags:

   ```bash
   docker run -d --name peaq-validator \
     -v /path/to/your/config:/config \
     peaq-validator --validator --name "YourValidatorName"
   ```

---

#### **Step 6: Sync the Node with Peaq Network**

Start your node, and it will begin syncing with the Peaq Network.

```bash
./target/release/peaq-node --chain=peaq --name=YourValidatorName --validator
```

This command will connect your node to the Peaq blockchain and start the synchronization process. The node will download the chain history and validate transactions.

---

#### **Step 7: Register Your Validator**

Once your node is fully synced, you will need to register it on the Peaq Network as a validator. This typically involves:

1. Staking a certain amount of PEQ tokens.
2. Submitting a registration transaction on the Peaq Network to make your node a valid validator candidate.

You can do this either through the **Polkadot-JS UI** (if available for Peaq) or using the **Substrate CLI** to submit the staking transaction.

---

#### **Step 8: Monitor and Maintain the Node**

After the validator is running, you'll want to monitor its performance:

- **Logs**: View the logs to ensure that the validator is working properly.
  
  ```bash
  tail -f /path/to/your/logfile.log
  ```

- **Metrics**: Use tools like Prometheus or Grafana (if available in the Peaq ecosystem) to monitor your node’s health, staking status, and block production metrics.

---

#### **Step 9: Participate in the Network**

Your node is now running and is a validator on the Peaq Network. Ensure that you:

- Monitor the rewards.
- Keep your node online and in sync with the network.
- Respond to governance proposals or slashing events if applicable.

Last updated 6 months ago