> For the complete documentation index, see [llms.txt](https://docs.zenon.org/hypercore/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.zenon.org/hypercore/technical/roles/orchestrator/setup-guide-on-pillar.md).

# Setup Guide (On Pillar)

By setting up a Zenon Pillar, you play a pivotal role in enhancing the decentralization, security, and overall robustness of the Zenon ecosystem.

{% hint style="warning" %}
This setup guide is for operators looking to setup the Orchestrator binary on the same server as their Pillar. If you're looking to setup on a remote server (not on the Pillar), then please follow the following: Setup Guide (Remote).
{% endhint %}

### Table of Contents

1. [Prerequisites](#prerequisites)
2. [Opening Required Firewall Ports](#id-2-opening-required-firewall-ports)
3. [Obtaining an Ethereum Node from Alchemy](#id-3-obtaining-an-ethereum-node-from-alchemy)
4. [Server Setup and Configuration](#server-setup-and-configuration)
   * [Accessing the Server](#accessing-the-server)
   * [Updating the System](#updating-the-system)
   * [Installing Required Packages](#installing-required-packages)
5. [Installing the Orchestrator](#id-5-installing-the-orchestrator)
6. [Setting Up Orchestrator as a Service](#id-6-setting-up-orchestrator-as-a-service)
7. [Fusing QSR Tokens](#id-7-fusing-qsr-tokens)
8. [Useful Commands](#id-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](https://www.alchemy.com/) 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:

```bash
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](https://www.alchemy.com/) and create an account or log in.<br>
2. Create a New App:
   1. Navigate to the dashboard and create a new app.
   2. Select the desired network (e.g., Mainnet, Ropsten).<br>
3. Retrieve the WSS Endpoint:
   1. Once the app is created, go to the app’s dashboard.
   2. Locate the WebSocket endpoint URL.<br>
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.<br>
2. **Connect via SSH**:<br>

   ```bash
   ssh username@your_server_ip
   ```

   Replace `username` with your server's username (commonly `root`) and `your_server_ip` with your server's IP address.<br>
3. **Switch to Root User**:<br>

   ```bash
   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:

```bash
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:

```bash
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](https://github.com/HyperCore-Team/orchestrator/releases).

**Download Command**:

```bash
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:

```bash
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/`**:

   ```bash
   cp orchestrator-linux-amd64 /usr/local/bin/
   ```
2. **Run the Orchestrator Binary to Initialize**:

   <pre class="language-bash"><code class="lang-bash"><strong>/usr/local/bin/orchestrator-linux-amd64
   </strong></code></pre>

   * **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:

```bash
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**:

   ```json
   "Bootstrap": "/dns/bootstrap.zenon.community/tcp/55055/p2p/12D3KooWBVQYaz3yuJor8oW7bUqoAGDZDpFBGbGerL3SprHn57pQ"
   ```
5. **Sample `config.json` Structure**:

   ```json
   {
       "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:

```bash
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:

```bash
nano /etc/systemd/system/orchestrator.service
```

#### 2. Add Service Configuration

Copy and paste the following content into the service file:

```ini
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:

```bash
systemctl daemon-reload
```

Enable the service to start on boot:

```bash
systemctl enable orchestrator
```

Start the Orchestrator service:

```bash
systemctl start orchestrator
```

#### 4. Verify the Orchestrator Service Status

Check if the Orchestrator service is running correctly:

```bash
systemctl status orchestrator
```

**Expected Output**:

```yaml
● 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