# Running the BVS

This guide will walk you through running your own BVS by utilizing our Hello World BVS example.

## Prerequisites and dependencies

The Hello World BVS requires a few components from your system. This guide assumes you are using a common Linux distribution with **systemd** as the init system. If you're using a different setup, we assume you already possess the necessary knowledge to configure your environment appropriately.

* Golang compiler
* Working Redis server (By default, the BVS expects it on `localhost:6379`. However, please feel free to use other addresses and change the configuration accordingly).
* git

#### Installing dependencies on Linux

For [Ubuntu](https://ubuntu.com/) and other [Debian](https://www.debian.org/)-based system run:

```bash
sudo apt-get install redis golang-go
```

For [Arch](https://archlinux.org/) based systems, run:

```bash
sudo pacman -S redis go
```

For [Fedora](https://fedoraproject.org/) and other [RHEL](https://www.redhat.com/) based systems:

```bash
sudo dnf install golang redis
```

After installing Redis, you can start the service using the following command:

```bash
sudo systemctl start redis.service
```

It's advisable to check if Redis has started correctly. You can do this by running the following command:

```bash
sudo systemctl status redis
```

You should see the status as `active (running)`, and it should indicate that it is listening on port **6379**.

```
❯ sudo systemctl status redis
● redis.service - Advanced key-value store
     Loaded: loaded (/usr/lib/systemd/system/redis.service; disabled; preset: disabled)
     Active: active (running) since Fri 2024-10-11 13:34:21 CST; 2s ago
 Invocation: 7a3a9e4dc334453cb75cc98dd240f5ce
   Main PID: 254535 (redis-server)
     Status: "Ready to accept connections"
      Tasks: 6 (limit: 71906)
     Memory: 8.3M (peak: 9.4M)
        CPU: 28ms
     CGroup: /system.slice/redis.service
             └─254535 "/usr/bin/redis-server 127.0.0.1:6379"

Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.330 # Failed to write PID file: Permission denied
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.330 * Running mode=standalone, port=6379.
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.331 * Server initialized
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.331 * Loading RDB produced by version 7.2.5
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.331 * RDB age 839578 seconds
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.331 * RDB memory usage when created 1.11 Mb
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.331 * Done loading RDB, keys loaded: 172, keys expired: 0.
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.331 * DB loaded from disk: 0.000 seconds
Oct 11 13:34:21 martha redis-server[254535]: 254535:M 11 Oct 2024 13:34:21.331 * Ready to accept connections tcp
Oct 11 13:34:21 martha systemd[1]: Started Advanced key-value store.
```

#### Installing dependencies on MacOS

We recommend using [Homebrew](https://brew.sh/) to install dependencies. Please follow [Homebrew's installation instructions](https://docs.brew.sh/Installation) before proceeding. Afterwards, install redis.

```bash
brew install redis
```

After installing Redis, you can start the service using the following command:

```bash
brew services start redis
```

It's advisable to check if Redis has started correctly. You can do this by running the following command:

```bash
brew services info redis
```

You should see the status as both loaded and running

```bash
redis (homebrew.mxcl.redis)
Running: ✔
Loaded: ✔
User: martin
PID: 165415
```

Afterwards, please follow the instructions on the [Golang install page](https://go.dev/doc/install) to install the Go compiler.&#x20;

## Running the Hello World BVS

{% hint style="info" %}
Without deploying your own contract, you will only be able to run the monitor, caller, and the off-chain compute (assuming you have registered as an operator).&#x20;

For instructions on configuring the BVS to use alternative accounts, please refer to the [deploying a BVS](/bvs-developers-1/hello-world-bvs/deploying-a-bvs.md#pointing-off-chain-programs-to-the-new-bvs) section.
{% endhint %}

### Step 1: Clone repository

Clone the repository and `cd` into it.

```bash
git clone https://github.com/satlayer/devnet-hello-world-bvs
cd devnet-hello-world-bvs
```

### Step 2: Prepare your environment

You should firstly edit `go.mod` in `devnet-hello-world-bvs` to your cloned `satlayer-api` lib path:

```
# Modify go.mod to as satlayer-api is not public yet (will be!)
echo "\nreplace github.com/satlayer/satlayer-api v0.3.0 => /path/to/your/clone/of/devnet-satlayer-api" >> go.mod
```

Now, start each component in the **following sequence**.&#x20;

{% hint style="info" %}
Each pre-formatted text block should be interpreted as a new terminal session, starting from the root of the *Hello World BVS* project.
{% endhint %}

Each program folder contains a `env.toml` file, which stores configuration for the off-chain programs. To make the Hello World program run successfully, modify your `env.toml` to point towards your account and use the `os` keyring backend.

```toml
# xxx/env.toml

[owner]
keyringBackend = "os"
keyName = "<your-wallet-name>"
```

### Step 3: Run or Start the Task Monitor&#x20;

First, run the task monitor. In this example BVS, the monitor continuously tracks and updates the status for display. While this service is not technically required for a BVS, it is useful during development.

```bash
cd task
go run main.go monitor
```

This will initiate the monitor, allowing you to see real-time updates and statuses as tasks are processed in your *Hello World BVS*.

### Step 4: Run off-chain process

Next, run the off-chain process. This program listens for tasks to perform the desired computation.

```bash
cd offchain
go run main.go
```

### Step 5: Run Aggregator

Afterwards, you can run the Aggregator, which collects results from the above off-chain process and submits to the blockchain.&#x20;

```bash
cd aggregator
go run main.go
```

{% hint style="info" %}
This Hello World BVS example does not need aggregation due to it's simplicity. We implemented it as a demonstration of what can be done. \
\
In a more advanced BVS, you can implement your own quorum or other availability schemes, along with additional on-chain capabilities. This approach enhances the reliability and robustness of task processing within the BVS framework.
{% endhint %}

### Step 6: Run RewardUploader

Once you have ran the previous sequence, you can run `RewardUploader` which listens for finished results, calculates how future rewards should be spread and uploads it to the blockchain.

```bash
cd uploader
go run main.go
```

### Step 7: Run TaskCaller

At the last sequence, run TaskCaller. In the real world, this would be a BVS client.&#x20;

```bash
cd task
go run main.go caller
```

{% hint style="info" %}
In this Hello World BVS example, it loops and tries to make BVS invocations every few seconds.
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.satlayer.xyz/bvs-developers-1/hello-world-bvs/running-the-bvs.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
