# Running a PoL Watchtower

The PoL Watchtower is a node in the infinity watch that participates in the PoL (Proof-of-Location) protocol and measures the location claims made by a prover. It can also act as a Prover to prove it's own location claim when challenged. 

## Witness Chain AVS mainnet Upgrade notes

{% hint style="success" %}
This note is only for existing Mainnet operators of Witness Chain AVS. If you're new to witness chain watchtower setup, you can skip to [Prerequisites](#prerequisites)

* This upgrade enables the watchtowers to validate location claims made by various participants over internet, using the internet telemetry.
* As a part of the upgrade, **you are no longer required to run any L1 or L2 nodes**, and only run a lightweight watchtower client - significantly reducing the infrastructure provisioning
* As earlier, it is **recommended using dedicated watchtower keys with no funds in the wallet** to minimize the risks. As our chain is completely gasless, you'll **not** require any token for registration or proof submissions.
* You are **encouraged to register and setup multiple watchtowers** (each with it's own unique watchtower key) at every location of your infrastructure operation (read 1 watchtower per region). This will serve 2 purposes in the network:
  * It increases geographical spread of the watchtowers, and hence increasing accuracy and coverage globally for location validation
  * It helps us map out the geographical stake distribution attached to the eigenlayer operator (It's a global stake map for Eigenlayer team to showcase decentralization of their network in a verifiable manner) 
* Avoid using VPNs or other proxies which might add network delays to an external connection to your watchtower node connecting over internet
* The current mainnet contracts will be locked/paused in favour of the new contracts part of this upgrade soon
  {% endhint %}

## Prerequisites

Before you begin, ensure you have the following

* You have opted-in for Witness Chain AVS [(guide here)](/infinity-watch/proof-of-location-mainnet/run-a-watchtower/eigenlayer-operators/witness-chain-avs-opt-in-guide.md)
* **Docker** (version 23.0.0 or above, refer: <https://docs.docker.com/desktop/install/linux-install/>)
* **Instance** comparable to a t2 micro (1 vcpu, 1GB RAM and 5GB harddisk)

## Running your Watchtower client

### <mark style="color:red;">Key Points to consider before proceeding...</mark>

1. We have 2 sets of keys - Operator Key and Watchtower Key.&#x20;
   1. **Operator Key** is your EigenLayer Operator Key that you have been using with various AVSes including our Witness Chain AVS. Continue to use that here too. This key is used for registering the Watchtower Key(s).
   2. **Watchtower Key** - This is the signing key for the PoL Watchtower Client. Create a new Key for the same. **Don't reuse the Operator Key for the Watchtower Key**. It has to be a ECDSA Key.&#x20;
2. You are encouraged to setup as many unique watchtowers as you can support (ideally **1 per region of your infrastructure** operating). All of the should be registered with the same operator key in the process described in this doc.
3. **Ports to be opened if using public IP:**&#x20;

```
Incoming ports to be opened (TCP & UDP ):

11112
22223
33334
33335
33336
44445
44446
44447
55556

Outgoing ports: Allow all
```

### 0. Creating the Watchtower Key

{% hint style="success" %}
Use ECDSA Keypairs
{% endhint %}

1. Create a ECDSA private key using Metamask or other utilities that will be used as Watchtower Key.&#x20;
2. Store the watchtower's private key in the file (Make sure you keep track of the file name and its location, as it would be refered later)

```bash
echo "YOUR_WATCHTOWER_PRIVATE_KEY" > my_watchtower_private.key
```

### Setting up the watchtower

1. Prepare a environment file `watchtower.env` with the following entries as example shown below:

```
latitude=37.01511676489697
longitude=-79.0392271449855
radius=1000
privateKey=<my_super_secret_watchtower_private_key>
walletPublicKey=<my_open_operator_public_address>
keyType=ethereum
saveResultsInDatabase=false
submitResultsToContract=false
rpcUrl=https://rpc.witnesschain.com
projectName=eigenlayer-<my_operator_name>
```

{% hint style="info" %}
**Latitude** and **Longitude** are optional. If not provided, they will be automatically determined based on the approximate location of the IP address. However it's recommended to be set for better accuracy.
{% endhint %}

\
**Explanation:**

* ```

      "latitude": 37.015, // Latitude of the machine running the watchtower client
      "longitude": -79.039, // Longitude of the machine running the watchtower client
      "radius": 1000 // Optional. Accuracy in km

  ```
* `privateKey` is your PoL signing key (Watchtower Key)
* `walletPublicKey` is the wallet addresses where your contributions go (Operator address)
* `havePublicIPv4Address` (and `havePublicIPv6Address`) set them to **true** if you have a public IPv4 (or IPv6)&#x20;
* `havePrivateIPv4Address` (and `havePrivateIPv6Address`) set them to **true** if you want to force the use of private IP
* `saveResultsInDatabase` saves the login, session, and challenge related data in a .sqlite file within the container
* `projectName` is the tagging mechanism to ensure we can identify our operators. It is a required field in the format `eigenlayer-<your operator name>`

{% hint style="info" %}
We collect various telemetry data from your node, such as the logs etc. You can choose to opt-out by setting `TELEMETRY=false` in the `watchtower.env` file
{% endhint %}

2. Once you have the `config.json` ready, the watchtower client can be started with

```sh
docker run -d \
  --network=host \
  --name pol-watchtower \
  --env-file ./watchtower.env \
  witnesschain/infinity-watch:1.0.2
```

\
you can verify that the watchtower is running by looking at the container status

```sh
docker ps 
```

**Explanation**:

1. `docker run -d`: Runs the container in detached mode (in the background).
   * ```
     --network=host
     Uses the host's network stack.
     ```
   * ```
     --name pol-watchtower
     Names the container as 'pol-watchtower'.
     ```
   * ```
     witnesschain/infinity-watch:1.0.2: The name of the Docker image to run.
     ```

## Post Setup

Once the setting up and registration is successful, you can check the logs from the watchtower client ready for challenges. (`docker logs -f pol-watchtower`). Congratulations, you are now a part of our Watchtower family!

## Troubleshooting

As the only prerequisite is docker, make sure you are running atleast version 23.0.0 or above for the commands mentioned in the doc to work. \
\
The days might be rainy or snowy, but we've got umbrellas and sweaters!\
Join our [Discord](https://discord.gg/Y9Eu2U5s) or Telegram—we're happy to help. :D


---

# 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.witnesschain.com/infinity-watch/proof-of-location-mainnet/run-a-watchtower/eigenlayer-operators/running-a-pol-watchtower.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.