> For the complete documentation index, see [llms.txt](https://docs.satlayer.xyz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.satlayer.xyz/bvs-developers-1/hello-world-bvs/running-the-bvs.md).

# 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. 

## 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). 

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

{% 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 %}