# Set up a Validator Node

Becoming a validator on the EIB involves setting up your node, creating a wallet, configuring your system, and finally launching your validator node. This guide will walk you through these steps in detail to help you get started.

### Hardware Prerequisites

Before proceeding, ensure that your hardware meets the recommended specifications to run a validator node efficiently.

<table><thead><tr><th width="156">Hardware</th><th>Mainnet</th><th>Testnet</th></tr></thead><tbody><tr><td>CPU</td><td>4 or more physical CPU cores</td><td>2 or more physical CPU cores</td></tr><tr><td>RAM</td><td>16GB+</td><td>8GB+</td></tr><tr><td>Storage</td><td>500GB+ SSD</td><td>250GB+ SSD</td></tr><tr><td>Network</td><td>100mbps+</td><td>10mbps+</td></tr><tr><td>OS</td><td>Ubuntu 22.04</td><td>Ubuntu 22.04 or macOS</td></tr></tbody></table>

### Software Prerequisites

Before you begin, make sure your system has the following software installed:

* Git
* Golang (minimum version 1.21)
* Make
* jq
* Python
* golangci-lint
* Solc-JS

### Step 1: Setting Up Your Node

1. **Clone the Entangle Blockchain Repository**: Start by cloning the[ **official Entangle blockchain repository**](https://github.com/Entangle-Protocol/entangle-blockchain) and navigating into the project directory:<br>

   ```solidity
   git clone https://github.com/Entangle-Protocol/entangle-blockchain
   cd entangle-blockchain
   git checkout main
   ```
2. **Build the Project**: Compile the project using the `make` command, which will build the necessary binaries:<br>

   ```solidity
   make install
   ```

   \
   After installation, you can verify the installation by running:

   ```solidity
   entangled --help
   ```
3. **Initialize Your Node**: Create your node by initializing it with a unique moniker and specifying the chain ID:

   ```solidity
   entangled init <moniker> --chain-id entangle_33033-1
   ```

### Step 2: Wallet Generation

1. **Create a New Key**: Generate a new key for your wallet. You'll need to provide a key name and select the keyring backend and algorithm:<br>

   ```solidity
   entangled keys add <key_name> --keyring-backend file --algo eth_secp256k1
   ```
2. **Retrieve Your Address**: Extract your wallet address and store for later use:<br>

   ```solidity
   MY_ADDRESS=$(entangled keys show <key_name> -a --keyring-backend file)
   echo $MY_ADDRESS
   ```

### Step 3: Configuration

1. **Update Configuration Files**: Download [`genesis.json`](https://raw.githubusercontent.com/Entangle-Protocol/entangle-blockchain/main/config/genesis.json) and [`config.toml`](https://raw.githubusercontent.com/Entangle-Protocol/entangle-blockchain/main/config/config.toml). You'll need to replace the existing files in your `.entangle/config/` directory with these.
2. **Set Persistent Peers**: In your `.entangle/config/config.toml` file, update the [`persistent_peers`](https://github.com/Entangle-Protocol/entangle-blockchain/blob/main/config/env_seeds) field with the provided list of nodes:<br>

   ```solidity
   persistent_peers = "node1@ip:port, node2@ip:port"
   ```

### Step 4: Launching Your Node

1. **Start Your Node**: With the configurations set, you can start your node. Ensure to specify the chain ID and set the gas cap for JSON-RPC:<br>

   ```solidity
   entangled start --chain-id entangle_33033-1 --json-rpc.gas-cap 200000000
   ```
2. **Verify Node Synchronization**: Check if your node is fully synced with the network:<br>

   ```solidity
   curl -s 127.0.0.1:26657/status | jq '.result.sync_info.catching_up'
   ```

   \
   A response of `false` indicates successful synchronization.

### Step 5: Creating Your Validator Node

1. **Ensure You Have NTGL Tokens**: To create a validator, you must have a sufficient amount of NTGL tokens for staking and transaction fees.
2. **Create Validator**: Use the following command to create your validator. Replace `<key_name>` with your key name and adjust other parameters as necessary:<br>

   ```solidity
   entangled tx staking create-validator \
   --amount="5000000000000000000aNGL" \
   --pubkey=$(entangled tendermint show-validator) \
   --moniker="validator" \
   --chain-id=entangle_33033-1 \
   --commission-rate="0.10" \
   --commission-max-rate="0.20" \
   --commission-max-change-rate="0.01" \
   --min-self-delegation="1" \
   --gas=500000 \
   --gas-prices="10aNGL" \
   --from=<key_name> \
   --keyring-backend file
   ```
3. **Verify Your Validator Node**: Check if your validator has been successfully added to the validator set:<br>

   ```solidity
   entangled query tendermint-validator-set
   ```

***

By following these steps, you can set up and launch a validator node on the Entangle blockchain. Remember to keep your node online and perform regular maintenance to ensure its smooth operation and contribution to the network's security and efficiency.


---

# 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.entangle.fi/entangle-interoperable-blockchain/developer-guides/set-up-a-validator-node.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.