# Run API Node

{% hint style="warning" %}
The **Opera client** was previously referred to as the "Opera client powered by Sonic technology", or simply, the "Sonic client".

However, given that the name "Sonic" has now been reserved for [our new, upcoming network](https://docs.soniclabs.com/), any mention of "Sonic" on these pages, GitHub, or pieces of code, refers to the current Opera client.
{% endhint %}

## Types of API Nodes

Before you start your Opera API node, you need to decide which type you want to deploy based on your use case. There are two possible modes of operation:

* **Pruned API Node**\
  **S**maller database footprint utilizing around 700 GB of storage initially. It can respond to state-related RPC/socket requests, allows you to interact with the network state, trace smart contract execution, and submit signed transactions to the network. The state history is limited to the block from which the state DB is created, usually using a validator-type genesis file. If you try to query an older state, an error will be given.
* **Archive API Node**\
  **L**arger database size using approximately 5.5 TB of storage initially. It can respond to all state-related RPC/socket requests for the whole blockchain history, allows you to interact with the network state at any block, trace smart contract execution, and submit signed transactions to the network. It's usually created from an archive genesis file.

## Steps to Run API Node

1. [Set up an Appropriate Server Instance](#id-1.-set-up-an-appropriate-server-instance)
2. [Install Required Development Tools](#id-2.-install-required-development-tools)
3. [Build the Opera Node Software](#id-3.-build-the-opera-node-software)
4. [Prime the Opera Database](#id-4.-prime-the-opera-database)
5. [Synchronize With the Network](#id-5.-synchronize-with-the-network)

## 1. Set up an Appropriate Server Instance

A dedicated hardware (also called bare metal) will provide the best possible performance and speed. If you want to integrate your node into a broader infrastructure of your project, you may want to consider a cloud service provider too. We recommend choosing one of the big cloud providers, e.g. Google GCP or Amazon AWS.

### Node Hardware Specification

A minimal configuration for the Opera API node is a computation node with at least **4 vCPUs** and **32 GB of RAM**. You will also need either at least **1.2 TB** or **7 TB** of **local NVMe storage** space for the Opera database.

The proper size depends on your selected API node type. Remotely connected storage systems, e.g. Amazon EBS, usually don't provide the required latency and random access performance required to run an API node. The Google GCP **N2D** instances with local SSD drives, or Amazon AWS **i3en.xlarge** with the instance storage, match the minimal requirements. 

The number of **vCPUs** and **RAM** available to the Opera node dictates the final performance and responsiveness of the API interface. Please scale the size of your server specification for the expected amount of RPC requests. We recommend instances with **8 vCPUs** and **64 GB of RAM** for smaller projects with less traffic, or **16 vCPUs** and **128 GB of RAM** for public API endpoints.

More RAM is needed to run "debug" API functionality in an RPC API node. For such a scenario, we recommend 128 GB.

Another option is to deploy several smaller nodes and load balance the incoming traffic between them. The deployment setup details suitable for your specific case may vary. We recommend using Ubuntu LTS Server (64-bit) or a similar Linux distribution.

### Required Storage Capacity

* **1.2 TB** of local **NVMe/SSD** storage is sufficient to start a pruned API node using a validator genesis file.
* **7 TB** of local **NVMe/SSD** storage is needed to provision a full archive API node.

[Obtain the latest genesis file](https://download.fantom.network).

### **Network Settings**

The Opera node requires both TCP and UDP network traffic to be allowed on port 5050 by default. A custom port can be used with `--port <port>` flag when running your node.&#x20;

The RPC/socket interface of the node can be opened for incoming HTTP traffic on port 80, but Opera does not support SSL/TLS encryption. You will need to add a proxy server between the public HTTP interface and the Opera node to be able to secure your connections with an SSL/TLS certificate.

Your cloud provider may offer a load-balanced application proxy solution, which includes certificate management. If you want to deploy such infrastructure yourself, you may want to check the [HAProxy](https://www.haproxy.org) or [Nginx](https://nginx.org) community projects.

## 2. Install Required Development Tools

You need the essential building tools and [Go](https://go.dev)[ compiler](https://go.dev/) version 1.21 or newer to build the Opera client and bundled tools.

First, install the required **build tools**:

```bash
sudo apt-get install -y build-essential git
```

Install the latest **Go compiler** from binary distribution:

<pre class="language-bash"><code class="lang-bash">sudo rm -rf /usr/local/go
wget https://go.dev/dl/go1.22.4.linux-amd64.tar.gz
<strong>sudo tar -xzf go1.22.4.linux-amd64.tar.gz -C /usr/local/
</strong>rm -f go1.22.4.linux-amd64.tar.gz
</code></pre>

Setup Go language export paths:

```bash
sudo tee /etc/profile.d/golang.sh > /dev/null <<EOT
export GOROOT=/usr/local/go
export GOPATH=\$HOME/go
export PATH=\$PATH:\$GOROOT/bin:\$GOPATH/bin

EOT

source /etc/profile.d/golang.sh
```

## 3. Build the Opera Node Software

Building the Opera binary requires the essential software development tools and the [Go](https://go.dev/dl/) language version 1.21 or newer to be available. The previous section contains basic steps to deploy the required applications on the recommended Linux distribution. Please refer to your operating system manuals to install the development tools needed for this step.

Please check the [latest release](https://github.com/Fantom-foundation/Sonic) of the Opera node and adjust your commands accordingly.

```bash
git clone https://github.com/Fantom-foundation/Sonic.git
cd Sonic
git fetch --tags && git checkout -b v1.2.1-c tags/v1.2.1-c
make all
```

You can confirm the Opera release by executing the `version` subcommand on the created binary.

```bash
build/sonicd version
```

Optionally, you may want to copy the  Opera node app and the tooling into the system-wide `bin` folder to make it available without explicitly specifying the binary path.

```bash
sudo mv build/sonic* /usr/local/bin/
```

## 4. Prime the Opera Database

You need a valid state database to be able to participate in the network. The fastest and easiest way is to use a genesis file. Please check the [official repository](https://files.fantom.network), where new signed genesis files are published, and pick the latest one suitable for your [selected node type](#types-of-api-nodes-available). You will need approximately **50 GB** of storage for a pruned genesis file and **350 GB** of storage space for the full archive genesis download.

Obtain the latest genesis file and the corresponding checksum:

```bash
wget https://files.fantom.network/mainnet-285300-archive.g
wget https://files.fantom.network/mainnet-285300-archive.g.md5
```

Check your download using the MD5 checksum file:

```bash
$ md5sum --check mainnet-285300-archive.g.md5
mainnet-285300-archive.g: OK
```

Use the  Opera tooling to prime the state database using the downloaded genesis file. Refer to [these steps](#calculate-cache-size-and-memory-consumption-soft-limit-values) to determine the amount of cache and memory consumption soft limit for your node. The `--datadir` flag should point to your **local NVMe storage** mount path.

```bash
GOMEMLIMIT=58GiB sonictool \
    --datadir ~/.sonic \
    --cache 25600 \
    genesis mainnet-285300-archive.g
```

The Opera tool creates a primed state database from the genesis file. The last step is a validation procedure. It confirms that the expected state was built successfully reaching the expected root hash. You can refer to the [official repository](https://files.fantom.network) to verify that the state hash is indeed correct.

```
StateDB imported successfully, stateRoot matches module=gossip-store
  index=81990246 root="f60cd4…38652f"
```

### Calculate Cache Size and Memory Consumption Soft Limit Values

The Opera node utilizes a large amount of RAM to achieve great speed and responsiveness. It should be the only user-space application consuming your system resources.

```bash
$ grep MemTotal /proc/meminfo
MemTotal:       65641928 kB
```

* Approximately **40%** of the available RAM should be used as the `--cache` for both the `sonictool` and `sonicd` applications. The final value is denominated in MiB. **For example**: 64,000 MiB RAM \* 40% = 25,600 MiB.
* Approximately **90%** of the available RAM should be used as the application memory consumption limit. This limit is controlled by the`GOMEMLIMIT` environment variable. The final value includes abbreviated units. We recommend using `GiB` for simplicity. **For example:** 64 GiB RAM \* 90% ≈ 58 GiB.

## 5. Synchronize With the Network

Your node database has been primed to a certain epoch in the past using a genesis file and the Opera tool. Now you need to get the node up to the current state.

To do it, your node needs to be started in the read-only mode and establish a connection with the network.Please make sure your [firewall is configured correctly](#network-settings) to allow such communication. The amount of memory dedicated to the node cache and the memory consumption limit are [outlined above](#calculate-cache-size-and-memory-consumption-soft-limit-values).

The RPC and/or socket interfaces are turned off by default. You need to specify which one you want to start and what range of services you want it to offer. You can find the default configuration in the example below. Please adjust the port, namespace, and domain-related options based on your specific needs.

The **HTTP API** offers the Web3 interface for the request-response type of interaction with the Opera chain. The **WS API** supports a sustained network connection with the ability to subscribe to certain network events, e.g. new blocks being created or contracts being interacted with.

```bash
GOMEMLIMIT=58GiB sonicd \
    --datadir ~/.sonic \
    --cache 25600 \
    --http \
    --http.addr=0.0.0.0 \
    --http.port=8080 \
    --http.corsdomain="*" \
    --http.vhosts="*" \
    --http.api=eth,web3,net,ftm,txpool,abft,dag \
    --ws \
    --ws.addr=0.0.0.0 \
    --ws.port=8081 \
    --ws.origins="*" \
    --ws.api=eth,web3,net,ftm,txpool,abft,dag
```

The Opera node should start and connect with the network, advancing the state by creating and processing new blocks. Please notice the **age** part of the log message, which tells you how far in the past these blocks are. The age should not exceed a couple of seconds once the node is fully synchronized.

<figure><img src="https://content.gitbook.com/content/C1Rz4BtJ7j1vSRciJe62/blobs/ODo0aEQXhV1VtKcKANHY/image.png" alt=""><figcaption></figcaption></figure>