LogoLogo
  • Entangle
    • Overview
    • Security Audits
  • Universal Interoperability Protocol
    • Overview
    • Architecture
      • Scalability and Network Stability
        • L2 Utility Blockchains
        • Transmitter Groups
      • Security and Consensus Mechanism
      • Finality
      • Execution Latency
      • Compatibility and Interoperability
    • Developer Guides
      • Getting Started
      • Solidity
        • Simple Abstract Messenger Example
        • Deploying Your Custom EVM Protocol
        • Bridging Tokens with UIP
        • Become an EVM Transmitter
      • Solana
        • Simple Abstract Messenger Example
        • Deploying Your Custom Solana Protocol
        • Become a Solana Transmitter
      • Calculate Cross-Chain Transaction Cost
      • Customizable Message Transmission Options
      • How to Debug Sent Messages
      • SDK Setup
      • Revenue Sharing for Transmitters
      • How to Become a Super Transmitter
    • Endpoints
  • Universal Data Feeds
    • Overview
    • Architecture
      • Data Delivery Methods
        • Pull Model
        • Push Model
      • Oracle Contract & User Interaction
    • Developer Guides
      • Custom Data Feeds
      • Fetch Data via Pull Model (PAYG)
        • EVM Smart Contracts
        • Solana Smart Contracts
      • Fetch Data via Pull Model (Subscriptions)
        • EVM Smart Contracts
        • Solana Smart Contracts
      • Fetch Data via Push Model
        • EVM Smart Contracts
        • Solana Smart Contracts
    • User Guides
      • Accessing Feeds
      • Subscribe to a Data Feed
      • Check Subscription
      • Manage Subscription
      • Renew Subscription
    • Data Endpoints
  • Universal Token Standard
    • Overview
    • Architecture
      • Fee Components
    • Developer Guides
      • Manual Deploy
        • Token Deployment Types
        • Create a Custom Token
        • Factory Blueprint Deployment
        • Examples
          • Initial Setup
          • UTS Connector
            • Mint & Burn Connector Scheme
            • Lock & Unlock Connector Scheme
            • Connector Over Native Currency
          • UTS Token
            • Simple Token
            • Token with Messages
      • Bridge SDK
      • Token Verification
      • Fees Calculation & Gas Estimation Logic
      • Estimations
    • User Guides
      • Launch Universal Token
      • Create a Liquidity Pool
      • Expand Existing Token
      • Transfer Liquidity to Connector
      • Bridging
    • Contract Addresses
  • Entangle Interoperable Blockchain
    • Overview
    • Architecture
    • Developer Guides
      • Set up a Validator Node
      • Delegating to Validators
      • Undelegating from Validators
      • Supported Accounts
  • More
    • Media Kit
    • FAQ
    • Report an Issue
    • Become a Partner
Powered by GitBook
On this page
  • Hardware Prerequisites
  • Software Prerequisites
  • Step 1: Setting Up Your Node
  • Step 2: Wallet Generation
  • Step 3: Configuration
  • Step 4: Launching Your Node
  • Step 5: Creating Your Validator Node

Was this helpful?

Export as PDF
  1. Entangle Interoperable Blockchain
  2. Developer Guides

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.

Hardware
Mainnet
Testnet

CPU

4 or more physical CPU cores

2 or more physical CPU cores

RAM

16GB+

8GB+

Storage

500GB+ SSD

250GB+ SSD

Network

100mbps+

10mbps+

OS

Ubuntu 22.04

Ubuntu 22.04 or macOS

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

    make install

    After installation, you can verify the installation by running:

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

    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:

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

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

Step 3: Configuration

  1. 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:

    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:

    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:

    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:

    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.

PreviousDeveloper GuidesNextDelegating to Validators

Last updated 1 month ago

Was this helpful?

Clone the Entangle Blockchain Repository: Start by cloning the and navigating into the project directory:

Update Configuration Files: Download and . You'll need to replace the existing files in your .entangle/config/ directory with these.

Set Persistent Peers: In your .entangle/config/config.toml file, update the field with the provided list of nodes:

official Entangle blockchain repository
genesis.json
config.toml
persistent_peers