Become a Validator

shikharbhatt · August 6, 2025, 4:59am

Watr Validator Setup Guide

This guide provides a step-by-step walkthrough for individuals and institutions interested in becoming validators on the Watr Network. Whether you’re a seasoned node operator or new to blockchain infrastructure, this documentation will help you set up your validator node and join the Watr ecosystem with confidence.

Introduction

The Watr Network is a sovereign Layer 1 blockchain built on the Avalanche L1 architecture. Validators form the backbone of the Watr Network, securing the chain, validating transactions, and participating in governance decisions.

What is a Node?

A node in the Watr network is a computer system that participates in the network by maintaining a copy of the blockchain, processing transactions, and communicating with other nodes. These nodes form the backbone of the Watr network, ensuring data availability and network resilience.

Types of Nodes

Full Node: Maintains a complete copy of the Watr blockchain and helps distribute transaction data across the network. While not directly involved in consensus, these nodes are essential for network health and data accessibility.
Validator Node: A specialized full node that participates in the consensus mechanism, validating transactions and creating new blocks. These nodes are responsible for maintaining the network’s security and transaction integrity.
RPC (Remote Procedure Call) Node: Provides an interface for applications to interact with the Watr blockchain, enabling developers to query data and submit transactions programmatically.

About Validator Nodes

Validator nodes are the core participants in Watr’s consensus mechanism, responsible for maintaining the network’s security and ensuring all transactions are processed correctly. They work together to reach agreement on the state of the blockchain.

Key Functions of Validators:

Transaction Validation: Validators verify that all transactions meet the network’s rules and requirements before including them in blocks.
Block Production: Validators create new blocks containing validated transactions and propose them to the network.
Network Security: Validators participate in the consensus protocol to ensure the network remains secure and resistant to attacks.

Current Network Status

Important: The Watr network is currently operating as a Proof of Authority (PoA) network. This means:

No staking requirements are currently needed to become a validator
Validators are added by the Watr foundation based on provided credentials
A transition to Proof of Stake (PoS) is planned in the coming months

Pre-requisites

This document provides information about the system and networking requirements for running a Watr validator node.

Hardware and Operating Systems

Watr is built on Avalanche architecture, which is an incredibly lightweight protocol, so nodes can run on commodity hardware.

CPU: Equivalent of 8 AWS vCPU
RAM: 8 GiB (16 GiB recommended)
Storage: 1 TiB SSD
OS: Ubuntu 22.04 or MacOS >= 12

Warning: Nodes which choose to use a HDD may get poor and random read/write latencies, therefore reducing performance and reliability. An SSD is strongly suggested.

Networking

To run successfully, your Watr node needs to accept connections from the Internet on the network port 9651. Before you proceed with the installation, you need to determine the networking environment your node will run in. Allow TCP traffic on port 9650 from your IP so you can make API calls to your node and fetch certain information and statistics.

Running the Avalanche Node

Learn how to run an Avalanche node from AvalancheGo source code, which is required for the Watr network.

Install Dependencies

Install gcc
Install go

Build the Node Binary

Set the $GOPATH. You can follow this guide.

Create a directory in your $GOPATH:

mkdir -p $GOPATH/src/github.com/ava-labs

In the $GOPATH, clone AvalancheGo, the consensus engine and node implementation that is the core of the Avalanche Network:

cd $GOPATH/src/github.com/ava-labs
git clone https://github.com/ava-labs/avalanchego.git

From the avalanchego directory, run the build script:

cd $GOPATH/src/github.com/ava-labs/avalanchego
./scripts/build.sh

Start the Node

Note: To be able to make API calls to your node from other machines, include the argument --http-host= when starting the node.

For running a node on the Watr network:

cd $GOPATH/src/github.com/ava-labs/avalanchego
./build/avalanchego

Note: To kill the node, press Ctrl + C.

Bootstrapping

A new node needs to catch up to the latest network state before it can participate in consensus and serve API calls. This process (called bootstrapping) may take several hours for a new node connected to the Watr network.

When a given chain is done bootstrapping, it will print logs like this:

[09-09|17:01:45.295] INFO <C Chain> snowman/transitive.go:392 consensus starting {"lastAcceptedBlock": "2qaFwDJtmCCbMKP4jRpJwH8EFws82Q2yC1HhWgAiy3tGrpGFeb"}
[09-09|17:01:46.199] INFO <P Chain> snowman/transitive.go:392 consensus starting {"lastAcceptedBlock": "2ofmPJuWZbdroCPEMv6aHGvZ45oa8SBp2reEm9gNxvFjnfSGFP"}
[09-09|17:01:51.628] INFO <X Chain> snowman/transitive.go:334 consensus starting {"lenFrontier": 1}

Check Bootstrapping Progress

To check if a given chain is done bootstrapping, in another terminal window call info.isBootstrapped by copying and pasting the following command:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"info.isBootstrapped",
    "params": {
        "chain":"X"
    }
}' -H 'content-type:application/json;' [NODE_IP]:9650/ext/info

If this returns true, the chain is bootstrapped; otherwise, it returns false.

Setting Up Watr L1 Node

Learn how to run a node that tracks the Watr L1 network. This requires building AvalancheGo, adding Virtual Machine binaries as plugins to your local data directory, and running AvalancheGo to track these binaries.

Step 1: Build Avalanche L1 Binaries

After building AvalancheGo successfully, clone Subnet-EVM:

cd $GOPATH/src/github.com/ava-labs
git clone https://github.com/ava-labs/subnet-evm.git

In the Subnet-EVM directory, run the build script, and save it in the plugins folder of your .avalanchego data directory. Name the plugin after the VMID of the Watr L1 network:

cd $GOPATH/src/github.com/ava-labs/subnet-evm
./scripts/build.sh ~/.avalanchego/plugins/[WATR_VMID]

Note: Replace [WATR_VMID] with the actual VMID of the Watr L1 network. Contact the Watr foundation for the correct VMID.

Step 2: Configure Node Parameters

Create a file named config.json and add a track-subnets field that is populated with the SubnetID you wish to track:

cd ~/.avalanchego
echo '{"track-subnets": "[WATR_SUBNET_ID]"}' > config.json

Note: Replace [WATR_SUBNET_ID] with the actual SubnetID of the Watr L1 network. Contact the Watr foundation for the correct SubnetID.

Step 3: Run the Node

Run AvalancheGo with the --config-file flag to start your node and ensure it tracks the Watr L1 network:

cd $GOPATH/src/github.com/ava-labs/avalanchego
./build/avalanchego --config-file ~/.avalanchego/config.json

You should now see terminal filled with logs and information to suggest the node is properly running and has began bootstrapping to the network.

Node Sync and RPC Details

It may take a few hours for the node to fully sync with the Avalanche Primary Network and the Watr L1 network.

When finished bootstrapping, the endpoint will be:

localhost:9650/ext/bc/[BLOCKCHAIN_ID]/rpc

if run locally, or:

[PUBLIC_IP]:9650/ext/bc/[BLOCKCHAIN_ID]/rpc

Note: Replace [BLOCKCHAIN_ID] with the actual Blockchain ID of the Watr L1 network. Contact the Watr foundation for the correct Blockchain ID.

Becoming a Validator

Once your Watr L1 node is up and running, you need to provide the Watr foundation with certain configuration parameters to be added as a validator.

Retrieve Required Parameters

You need to provide the Watr foundation with the following information:

Node ID
BLS Public Key
BLS Proof of Possession

To retrieve this data, run the following command:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"info.getNodeID"
}' -H 'content-type:application/json;' [PUBLIC_IP]:9650/ext/info

This will return a response like:

{
  "jsonrpc": "2.0",
  "result": {
    "nodeID": "[NODE_ID]",
    "nodePOP": {
      "publicKey": "[BLS_PUBLIC_KEY]",
      "proofOfPossession": "[BLS_PROOF_OF_POSSESSION]"
    }
  },
  "id": 1
}

Submit to Watr Foundation

Once you have collected all the required parameters:

Node ID: The identifier for your node
BLS Public Key: Your node’s BLS public key
BLS Proof of Possession: Your node’s BLS signature

Submit these values to the Watr foundation through their designated channel (contact the foundation for the specific submission process).

Future PoS Transition

The Watr network is planning to transition to Proof of Stake (PoS) in the coming months. When this transition occurs:

Staking requirements will be implemented
Validators will need to stake tokens to participate
Additional documentation will be provided for the PoS setup process

Stay updated with the Watr foundation for announcements regarding the PoS transition.

Backup and Restore

Once you have your Watr node up and running, it’s essential to prepare for disaster recovery. Should your machine ever have a catastrophic failure due to hardware or software issues, or even natural disasters, it’s best to be prepared by making a backup of your critical node files.

What Needs to Be Backed Up

For a Watr validator node, you only need to back up the files that are unique to your node and cannot be reconstructed. These files define your NodeID and BLS identity on the network:

Essential Files to Backup

staker.crt - Your node’s certificate file
staker.key - Your node’s private key file
signer.key - Your node’s BLS key file

These files are located in the default installation directory: ~/.avalanchego/staking/

Why These Files Are Critical

NodeID: If multiple nodes share the same NodeID, network communications will be random, which can dramatically impact validator uptime and potentially disqualify you from receiving rewards.
BLS Identity: The signer.key contains your BLS public key and proof of possession. If this file is lost or regenerated, your node will lose its previous identity on the network.

Backup Process

From Local Node

If you’re running the node locally, navigate to the staking directory and copy the files to a secure backup location:

cp ~/.avalanchego/staking/{staker.crt,staker.key,signer.key} /path/to/secure/backup/

From Remote Node Using scp

For remote nodes, use the secure copy command to transfer the files:

scp -r username@PUBLIC_IP:/home/username/.avalanchego/staking ~/watr_backup

Or if using SSH keys:

scp -i /path/to/key.pem -r username@PUBLIC_IP:/home/username/.avalanchego/staking ~/watr_backup

Restore Process

To restore your node from a backup, follow these steps:

Install a new node (this will create new NodeID and BLS keys)
Stop the node:
```
sudo systemctl stop avalanchego
```

Replace the files with your backup:

cp /path/to/backup/{staker.crt,staker.key,signer.key} ~/.avalanchego/staking/

Restart the node:
```
sudo systemctl start avalanchego
```

Verify restoration by checking your NodeID:

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"info.getNodeID"
}' -H 'content-type:application/json;' [PUBLIC_IP]:9650/ext/info

Security Considerations

Keep backups secure: If someone gains access to your staker files, they could recreate your node elsewhere and potentially affect your validator status.
BLS key protection: If someone accesses your signer.key, they could potentially sign transactions on behalf of your node, disrupting operations.
Off-site storage: Store backups on a different computer or secure cloud storage.
Regular backups: Create backups periodically, especially after any configuration changes.

Support and Resources

For additional support or questions about becoming a Watr validator:

Contact the Watr foundation for network-specific parameters (VMID, SubnetID, BlockchainID)
Join the Watr community channels for technical discussions
Monitor the Watr network status and announcements

This documentation will be updated as the Watr network evolves and transitions to Proof of Stake.

Topic	Replies	Views
Welcome to the Watr Community 👋 Announcements	9	July 6, 2025
About the WatrAssets category WatrAssets	0	August 14, 2025
About the WatrMarks category WatrMarks	0	August 14, 2025
About the Developers category Developers	0	August 14, 2025