Setup Guide (On Pillar)

Table of Contents

1. Prerequisites

2. Opening Required Firewall Ports

3. Obtaining an Ethereum Node from Alchemy

4. Server Setup and Configuration

   • Accessing the Server

   • Updating the System

   • Installing Required Packages

5. Installing the Orchestrator

6. Setting Up Orchestrator as a Service

7. Fusing QSR Tokens

8. Useful Commands

1) Prerequisites

Before proceeding, ensure you have the following:

• Basic Knowledge: Familiarity with command-line interfaces and server management.

• Access Credentials: SSH access to your chosen server with sudo privileges.

• BNB and Ethereum Nodes: Access to a BNB and Ethereum node provider like Alchemy to obtain WebSocket (WSS) endpoints.

• Producer Passphrase: The passphrase for your Producer Key File, retrievable via the znn-controller.

• QSR Tokens: At least 120 QSR tokens fused to the Pillar Producer Address.

2) Opening Required Firewall Ports

To facilitate communication and health checks, ensure the following ports are open on your server’s firewall:

1. Port 55055 (TCP): Open for gossip communication between nodes.

2. Port 55000 (TCP): Open for API health checks.

Steps to Open Ports:

Assuming you’re using ufw (Uncomplicated Firewall) on Ubuntu:

sudo ufw allow 55055/tcp
sudo ufw allow 55000/tcp
sudo ufw reload

Note: If you’re using a different firewall management tool, adjust the commands accordingly.

3) Obtaining a Binance Smart Chain and Ethereum Node from Alchemy

To interact with the Binance Smart Chain and Ethereum network, you need access to a Binance Smart Chain and Ethereum node. Alchemy provides reliable node services.

Steps to Obtain the WSS Endpoint

1. Sign Up/Login to Alchemy:

   1. Visit Alchemy and create an account or log in.

2. Create a New App:

   1. Navigate to the dashboard and create a new app.

   2. Select the desired network (e.g., Mainnet, Ropsten).

3. Retrieve the WSS Endpoint:

   1. Once the app is created, go to the app’s dashboard.

   2. Locate the WebSocket endpoint URL.

4. Example Endpoint:

wss://eth-mainnet.alchemyapi.io/v2/your-api-key

4) Server Setup and Configuration

Accessing the Server

1. Obtain SSH Credentials: After setting up your server with your chosen provider, retrieve the SSH IP address, username, and password/key.

2. Connect via SSH:

   Copy

   ssh username@your_server_ip

   Replace username with your server's username (commonly root) and your_server_ip with your server's IP address.

3. Switch to Root User:

   Copy

   sudo -i

   This command grants you root privileges for the installation process.

Updating the System

Ensure your server's package lists and installed packages are up to date by running the command individually:

apt update
apt upgrade -y

• apt update: Updates the package index.

• apt upgrade -y: Upgrades all installed packages to their latest versions.

Installing Required Packages

Install unzip and other necessary utilities:

apt install -y unzip wget

• unzip: Required for extracting the Zenon controller ZIP file.

• wget: Facilitates downloading files from the internet.

5) Installing the Orchestrator

This section covers downloading the Orchestrator binary, setting up the configuration file, and preparing the orchestrator for deployment.

1. Download the Orchestrator Binary

First, download the latest Orchestrator binary. Ensure you're using the most recent release by checking the OrchestratorGitHub Releases.

Download Command:

wget https://github.com/HyperCore-Team/orchestrator/releases/download/v0.0.9a-alphanet/orchestrator-linux-amd64.zip

Note: Replace the URL with the latest release if a newer version is available.

2. Extract the Orchestrator Binary

Unzip the downloaded file:

unzip orchestrator-linux-amd64.zip

3. Setup the Config.json File

Move the Binary and Create the Configuration Directory

1. Copy the Binary to /usr/local/bin/:

   Copy

   cp orchestrator-linux-amd64 /usr/local/bin/

2. Run the Orchestrator Binary to Initialize:

   Copy

   /usr/local/bin/orchestrator-linux-amd64

   • Expected Outcome: The process will fail initially but will create a working directory at /root/.orchestrator/.

4. Configure the Config.json File

Edit the config.json file to suit your environment:

nano /root/.orchestrator/config.json

Configuration Steps:

1. Update WebSocket URLs:

   • BNB: Replace with your Alchemy BNB WSS endpoint.

   • Ethereum: Replace with your Alchemy Ethereum WSS endpoint.

2. Provide Producer Key File Passphrase:

   • Retrieve by running the znn-controller and selecting the 2) Status option.

3. Maintain Unique EvmAddress:

   • Do not change or remove the EvmAddress once created.

4. Add Bootstrap Address:

   Copy

   "Bootstrap": "/dns/bootstrap.zenon.community/tcp/55055/p2p/12D3KooWBVQYaz3yuJor8oW7bUqoAGDZDpFBGbGerL3SprHn57pQ"

5. Sample config.json Structure:

   Copy

   {
       "DataPath": "/root/.orchestrator",
       "EventsPath": "",
       "QueuesPath": "",
       "GlobalState": 0,
       "EvmAddress": "",
       "Networks": {
           "BNB Chain": {  <= UPDATE THIS
               "Urls": [
                   "ws://127.0.0.1:8545" <= UPDATE THIS
               ],
               "FilterQuerySize": 1500
           },
           "Ethereum": {
               "Urls": [
                   "wss://eth-mainnet.alchemyapi.io/v2/your-api-key"  <= UPDATE THIS
               ],
               "FilterQuerySize": 2000
           },
           "Zenon": {
               "Urls": [
                   "ws://127.0.0.1:35998"
               ],
               "FilterQuerySize": 0
           }
       },
       "TssConfig": {
           "Port": 55055,
           "PublicKey": "",
           "DecompressedPublicKey": "",
           "LocalPubKeys": null,
           "Bootstrap": "/dns/bootstrap.zenon.community/tcp/55055/p2p/12D3KooWBVQYaz3yuJor8oW7bUqoAGDZDpFBGbGerL3SprHn57pQ",
           "PubKeyWhitelist": {},
           "BaseDir": "/root/.orchestrator/tss",
           "BaseConfig": {
               "PartyTimeout": 60000000000,
               "KeyGenTimeout": 900000000000,
               "KeySignTimeout": 60000000000,
               "KeyRegroupTimeout": 60,
               "PreParamTimeout": 600000000000,
               "EnableMonitor": false
           }
       },
       "ProducerKeyFileName": "producer",
       "ProducerKeyFilePassphrase": "YOUR_PASSPHRASE",  <= UPDATE THIS
       "ProducerIndex": 0
   }

5. Copy the Producer File

Assuming you are running the Orchestrator on the pillar, copy the producer file to the Orchestrator's data path:

cp /root/.znn/wallet/producer /root/.orchestrator/producer

Note: Ensure the path to the producer file is correct. Adjust the command if your producer file is located elsewhere.

6) Setting Up Orchestrator as a Service

To ensure that the Orchestrator runs continuously and starts on boot, set it up as a systemd service.

1. Create a systemd Service File

Open a new service file for the Orchestrator:

nano /etc/systemd/system/orchestrator.service

2. Add Service Configuration

Copy and paste the following content into the service file:

iniCopy code[Unit]
Description=Orchestrator Service
After=network.target
StartLimitIntervalSec=300s
StartLimitBurst=10

[Service]
User=root
Group=root
ExecStart=/usr/local/bin/orchestrator-linux-amd64
ExecStop=/usr/bin/pkill -9 orchestrator-linux-amd64
Restart=on-failure
RestartSec=60
TimeoutStopSec=10s
TimeoutStartSec=10s
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=orchestrator

[Install]
WantedBy=multi-user.target

3. Activate and Start the Orchestrator Service

Reload systemd to recognize the new service:

systemctl daemon-reload

Enable the service to start on boot:

systemctl enable orchestrator

Start the Orchestrator service:

systemctl start orchestrator

4. Verify the Orchestrator Service Status

Check if the Orchestrator service is running correctly:

systemctl status orchestrator

Expected Output:

● orchestrator.service - Orchestrator Service
   Loaded: loaded (/etc/systemd/system/orchestrator.service; enabled; vendor preset: enabled)
   Active: active (running) since Thu 2024-04-27 10:00:00 UTC; 5s ago
 Main PID: 12345 (orchestrator-)
    Tasks: 10 (limit: 4704)
   CGroup: /system.slice/orchestrator.service
           └─12345 /usr/local/bin/orchestrator-linux-amd64

Note: The Active: active (running) status indicates that the service is running correctly.

7) Fusing QSR Tokens

To fully deploy your Orchestrator with the Zenon Network, ensure that you have fused at least 120 QSR tokens to the Pillar Producer Address.

Steps to Fuse QSR Tokens

1. Access Your Pillar Producer Address:

   • Use your Syrius wallet or another compatible wallet to access your producer address.

2. Fuse QSR Tokens:

   • Follow the wallet's instructions to fuse QSR tokens.

   • Ensure you have at least 120 QSR fused to meet the network's requirements.

8) Useful Commands