1. System Requirements

   • OS: Ubuntu 20.04 or later (recommended for compatibility).

   • CPU: 4+ cores.

   • RAM: 16 GB or more.

   • Storage: 500 GB SSD or more.

   • Network: Reliable connection with at least 1 Gbps bandwidth.

2. Dependencies

   • curl

   • git

   • docker and docker-compose

   • jq (JSON processor)

   • make

   • go (Golang, version 1.19+)

3. Fractal Identity

   • Ensure you have registered with Fractal and obtained the necessary credentials.

Step 1: Install Dependencies

Update and Upgrade Your System

sudo apt update && sudo apt upgrade -y

Install Required Packages

sudo apt install -y curl git jq make gcc build-essential

Install Docker and Docker Compose

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
sudo usermod -aG docker $USER

# Install Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Install Go

wget https://golang.org/dl/go1.19.10.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.19.10.linux-amd64.tar.gz
echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.bashrc
source ~/.bashrc

Step 2: Clone the Fractal Repository

Navigate to your desired directory and clone the Fractal repository:

git clone https://github.com/fractalprotocol/fractal-node.git
cd fractal-node

Step 3: Build the Node

Initialize Submodules

git submodule update --init --recursive

Build the Node

make build

The resulting binary should be located in the build directory.

Step 4: Configure the Node

Generate Configuration Files

./build/fractal-node init <your-validator-name> --chain-id fractal-mainnet

Replace <your-validator-name> with your desired name.

Edit the Configuration

Navigate to the configuration folder:

cd ~/.fractal/config

Open the config.toml file and update the following:

• Peers and Seeds

  persistent_peers = "<peer-list>"
  seeds = "<seed-list>"
  

• Minimum Gas Prices

  minimum-gas-prices = "0.001ufractal"
  

• Prometheus Enable metrics for monitoring:

  prometheus = true
  

Step 5: Start the Node

Run the Node

./build/fractal-node start

Use Docker (Optional)

If you prefer Docker:

docker-compose up -d

Step 6: Create and Fund a Validator

Create a Wallet

./build/fractal-node keys add <wallet-name>

Fund the Wallet

Transfer some tokens to your wallet address from an exchange or faucet.

Create the Validator

./build/fractal-node tx staking create-validator \
  --amount=1000000ufractal \
  --pubkey=$(./build/fractal-node tendermint show-validator) \
  --moniker="<your-validator-name>" \
  --chain-id=fractal-mainnet \
  --commission-rate="0.10" \
  --commission-max-rate="0.20" \
  --commission-max-change-rate="0.01" \
  --min-self-delegation="1" \
  --from=<wallet-name> \
  --fees=2000ufractal

Step 7: Monitor and Maintain

Check Node Logs

journalctl -u fractal-node -f

Monitor Metrics

If Prometheus is enabled, access metrics at http://<node-ip>:26660.

Upgrade Node

Keep your node updated:

git pull origin main
make build

Before starting, make sure you have the following:

1. A Linux server (Ubuntu 20.04/22.04) with at least:

   • 4 CPUs

   • 8 GB RAM

   • 200 GB SSD storage

   • A static public IP address

2. Basic command-line knowledge.

3. Docker and Docker Compose installed on your server.

4. BounceBit Wallet to receive rewards.

5. A stable internet connection for uninterrupted uptime.

Step 1: Install Required Tools

Start by updating your server and installing necessary tools:

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

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# Install Docker Compose
sudo apt install docker-compose -y

Log out and log back in to apply Docker permissions.

Step 2: Clone the BounceBit Repository

Next, download the BounceBit node repository:

# Clone the BounceBit repository
git clone https://github.com/bouncebit/bouncebit-node.git
cd bouncebit-node

Step 3: Configure the Node

Edit the configuration file to set up your node. Replace <YOUR_WALLET_ADDRESS> with your actual BounceBit wallet address:

nano config/config.toml

Update the following fields:

[validator]
address = "<YOUR_WALLET_ADDRESS>"  # Replace with your BounceBit wallet address

Save the file (CTRL + O, then CTRL + X).

Step 4: Run the Node

To start the node, use the provided Docker Compose configuration:

# Start the BounceBit node
docker-compose up -d

This will download and run the necessary Docker containers. Check the logs to verify that the node is running:

docker-compose logs -f

Step 5: Sync the Blockchain

The node will need to sync the BounceBit blockchain. This process can take a few hours depending on your server's performance and network speed. Monitor the logs to track the progress:

docker logs -f bouncebit-node

Once you see a message like Node is fully synced, your node is ready.

Step 6: Register as a Validator

To participate as a validator:

1. Obtain the public key of your node:

   docker exec bouncebit-node ./bouncebit-cli get-validator-key
   

2. Submit your public key to the BounceBit staking portal:

   • Visit BounceBit Staking Dashboard.

   • Register your validator using the public key and your wallet address.

3. Delegate some BounceBit tokens (BBT) to your validator to activate it.

Step 7: Monitor Your Validator

Ensure your node remains online and performant. Use these commands:

• Check Node Status:

  docker exec bouncebit-node ./bouncebit-cli status
  

• Restart Node (if needed):

  docker-compose restart
  

• Update Node Software: Pull the latest updates from the repository and restart:

  git pull
  docker-compose down
  docker-compose up -d
  

Troubleshooting

• Check Logs:

  docker-compose logs -f
  

• Disk Space Issues: Ensure you have at least 200 GB free storage. Clean up unused Docker containers and images:

  docker system prune -a
  

Step 8: Secure Your Node

1. Enable a Firewall:

   sudo ufw allow ssh
   sudo ufw allow 26656/tcp  # Replace with BounceBit’s P2P port
   sudo ufw enable
   

2. Set Up Automatic Restarts: Configure Docker to restart the node on failure:

   docker update --restart unless-stopped bouncebit-node
   

Symbiotic: A Framework for Scalable Shared Security

At its core, Symbiotic provides a set of building blocks that allow various parties to enter into secure agreements without intermediaries. These "primitives" form the foundation for the ecosystem:

1. Collateral: The assets, which can exist on almost any blockchain, providing the economic foundation.

2. Vaults: These entities manage staking, connecting collateral to various networks.

3. Operators: The infrastructure experts who keep the networks running.

4. Networks: Service providers that seek decentralization and enhanced security.

5. Resolvers: The entities responsible for managing slashing and arbitration processes.

Symbiotic allows these actors to interact in ways that maximize security and efficiency, while still enabling networks to retain control over their infrastructure. By enhancing capital efficiency, Symbiotic makes it possible for assets to be utilized across multiple networks, driving decentralization at scale.

Enter the Curators: Managing and Optimizing Shared Security

While the above roles are integral to the Symbiotic framework, the true power of the system lies in its flexibility. This flexibility has given rise to new entities—curators—who take on a pivotal role in optimizing interactions between collateral, vaults, operators, networks, and resolvers.

Curators manage and provide transparency in the network, ensuring that the interactions between different components are both efficient and secure. Here's a look at the different forms curators can take in the Symbiotic ecosystem:

1. Liquid Restaking Tokens (LRTs): These curators specialize in asset management. By acquiring large stakes and creating scoring frameworks, they help networks maintain economic security while incentivizing restakers.

2. Operators: In addition to running infrastructure, operators can act as curators by offering best practices for redundancy and uptime. Their knowledge of both economic and technical factors helps ensure resilient networks.

3. Risk Managers and Research Entities: Focused on assessing risks, these curators guide networks and restakers by offering informed insights, ensuring that decisions are made with a comprehensive understanding of potential risks.

4. Liquid Staking Tokens (LSTs): With extensive experience in managing operator sets and integrating assets into DeFi, LST curators help Symbiotic networks choose operators that meet specific needs.

5. DAOs and Governance Systems: Decentralized governance mechanisms can also play the role of curators, dynamically managing collateral and security profiles in a transparent and decentralized way.

The Future of Curation in Symbiotic

As the Symbiotic ecosystem grows, so too will the role of curators. We can expect to see specialized curation platforms emerge, offering advanced tools for risk management and cross-chain security arrangements. Artificial intelligence and machine learning could play a major role in optimizing these curation processes, allowing real-time adjustments and predictive risk assessments.

We might also witness the rise of decentralized curation DAOs, where communities collectively manage large pools of assets, leveraging their expertise to maximize security and efficiency. This community-driven approach could revolutionize the way networks are managed, making the process more democratic and accessible.

Why Curators Matter

Curators are key to making Symbiotic’s shared security more accessible and scalable. By optimizing the system and offering transparent processes, they enhance risk management and ensure that networks can scale without compromising on security. Curators democratize access to blockchain security, enabling previously complex processes to be applied across entire industries.

As the Symbiotic ecosystem continues to grow, curators will drive innovation, building new products and services that accelerate the adoption of shared security. Their role in shaping the future of decentralized ecosystems is just beginning, and the possibilities are vast.

If you're interested in becoming a curator or simply want to learn more about Symbiotic's approach to shared security, the community is always open. Whether you’re a network operator, risk manager, or just an enthusiast, there’s a place for you in this emerging ecosystem.

Glitch Enjoers is a dedicated team of validators who have actively contributed to the 0G project by setting up nodes, participating in rigorous testing, and ensuring the stability and security of the network. This article highlights their involvement, showcasing specific examples of their work, including code snippets and configurations.

Setting Up 0G Nodes

The Glitch Enjoers team has meticulously followed the official guidelines to set up and maintain 0G nodes, ensuring optimal performance and security.

Step-by-Step Node Setup

Here’s a detailed example of how the team sets up a 0G node:

# Clone the 0G repository
git clone https://github.com/0GNetwork/0G.git
cd 0G

# Install dependencies and build the project
make install

# Initialize the node with a custom name
ogd init "GlitchEnjoersNode"

# Download the genesis file to join the network
wget -O $HOME/.ogd/config/genesis.json "https://raw.githubusercontent.com/0GNetwork/0G/main/genesis.json"

# Configure persistent peers for better connectivity
PEERS="node1@10.0.0.1:26656,node2@10.0.0.2:26656"
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" $HOME/.ogd/config/config.toml

# Start the node
ogd start

This setup ensures that the node is initialized correctly and connected to the network efficiently.

Using Docker for Node Deployment

To streamline the deployment process, the team uses Docker. Below is the Dockerfile used by Glitch Enjoers:

FROM golang:1.18-alpine

RUN apk add --no-cache git

WORKDIR /app

# Clone and build the application
RUN git clone https://github.com/0GNetwork/0G.git . && \
    go build -o ogd ./cmd/ogd

EXPOSE 26656 26657

CMD ["./ogd", "start"]

This Dockerfile ensures that the node runs in a consistent and isolated environment, making it easier to manage and deploy across different systems.

Participation in Testing

The Glitch Enjoers team has been actively involved in testing the 0G network, helping to identify and fix bugs, and ensuring the stability and security of the platform.

Automated Testing Setup

The team has implemented automated testing frameworks to ensure that every code change is thoroughly tested. Here’s an example of their CI/CD pipeline setup using GitHub Actions:

name: CI

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Set up Go
      uses: actions/setup-go@v2
      with:
        go-version: 1.18

    - name: Install dependencies
      run: make install

    - name: Run tests
      run: make test

This configuration ensures that all tests are run automatically on every code push, helping to catch bugs early and maintain high code quality.

Performance Testing

To ensure the network can handle high loads, the team conducts regular performance tests. Here’s an example script used for stress testing the network:

#!/bin/bash

for i in {1..1000}
do
  ogd tx send $(ogd keys show user1 -a) $(ogd keys show user2 -a) 10token --chain-id 0gnet --keyring-backend test -y
done

This script simulates a large number of transactions to test the network’s performance under load.

Community Engagement

In addition to their technical contributions, Glitch Enjoers actively engages with the community by providing support, writing documentation, and sharing their knowledge.

Documentation Contributions

The team has contributed to the official documentation, making it easier for new developers and node operators to get started. They have written detailed guides and how-to articles that cover various aspects of the 0G network.

Conclusion

The Glitch Enjoers team plays a crucial role in the 0G project by setting up and maintaining nodes, participating in extensive testing, and contributing to the community. Their efforts ensure the network's reliability, performance, and security, making them a valuable part of the 0G ecosystem.

Usefull links

Twitter Glitch Enjoers | Gitbook | Keybase | Twitter 0G

Glitch Enjoyers is to deliver unmatched node validation services that bolster the security and reliability of blockchain networks. Recognizing that each blockchain project comes with its own set of challenges and requirements, we customize our services to guarantee optimal performance and security.

Why Choose Glitch Enjoyers?

Choosing Glitch Enjoyers means partnering with a team committed to your project's success. Here’s what sets us apart:

• Expertise: Our extensive experience in blockchain technology and cryptography allows us to handle even the most complex validation tasks with precision.

• Reliability: We are dedicated to providing consistent, high-quality services that our clients can depend on.

• Security: We prioritize the security of your network, implementing the latest measures to protect against threats.

• Transparency: We believe in open communication and transparency, keeping our clients informed every step of the way.

Usefull links

https://glitch-enjoyers.gitbook.io/glitch-enjoyers.-blockchain-validators/usefull-links

https://keybase.io/glitch_enjoyers

https://x.com/Glitch_Enjoyers