> For the complete documentation index, see [llms.txt](https://docs.lycanchain.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.lycanchain.com/staking-and-rewards/alpha-becoming-a-validator-on-lycan-chain.md).

# Alpha (Becoming a Validator on Lycan Chain)

### Prerequisites

* **Hardware:** A dedicated machine or cloud server with **≥4 CPU threads**, **≥16 GB RAM**, and a **fast SSD** (NVMe preferred) is strongly recommended. (These specs help the blockchain sync quickly.)
* **Operating System:** Ubuntu 20.04 LTS (or equivalent recent Linux) is recommended. Ensure you have a non-root user with `sudo` privileges. If using a cloud provider (e.g. AWS), choose an instance type matching the hardware above.
* **Wallet:** Install and configure a Lycan-compatible wallet (MetaMask is recommended). You will use this wallet to hold LYC tokens, pay gas, and interact with the staking dashboard. Make sure your wallet is set up for Lycan Chain (you can import network settings via Chainlist as per the Lycan docs).
* **Network:** A stable internet connection with a public IP or DNS is needed. You will need to allow incoming **TCP port 30303** (P2P) and **8545/8551** (RPC/Engine API) once the node is running. (You can restrict access by firewall as appropriate, but these must be reachable by the network and staking app.)
* **LYC Tokens:** You must acquire **at least 100,000 LYC** in your wallet to stake. (Always double-check you have the required amount before proceeding.)

### Step 1: Acquire LYC Tokens

* **Connect a Wallet:** Open MetaMask (or another wallet) and ensure it’s configured for the Lycan Chain network. You will need some base cryptocurrency (e.g. ETH) in that wallet to swap for LYC and to pay gas fees.
* **Swap on Official Portal:** Go to the official Lycan token swap portal at [**https://growth.lycanchain.com**](https://growth.lycanchain.com). Connect your wallet, then select the cryptocurrency (such as ETH) you want to exchange. Enter an amount to swap for LYC, making sure the output is **≥100,000 LYC**. Review the swap details carefully and confirm the transaction.
* **Verify Balance:** After the swap, check your wallet’s balance to ensure you received the LYC. You should now have at least 100,000 LYC available. If not, troubleshoot the transaction or try again. Keep extra LYC above the minimum to cover any fees or future needs.

### Step 2: Set Up Your Validator Node

1. **Prepare the Server:** Provision a machine (physical or virtual) meeting the hardware requirements (4+ cores, 16+ GB RAM, SSD). If using Ubuntu 20.04 LTS, update the system and install necessary tools. For example, run:

   ```bash
   sudo apt-get -y update && sudo apt-get -y upgrade
   sudo apt-get -y install build-essential software-properties-common jq unzip
   ```

   These commands install compilers and utilities needed by Nethermind. You can also install tools like `curl` or `wget` if not already present.
2. **Download Nethermind:** Nethermind is the Ethereum client used by Lycan. Download the version specified by Lycan (as of writing, v1.26.0 64-bit) and unzip it:

   ```bash
   curl -SfL https://github.com/NethermindEth/nethermind/releases/download/1.26.0/nethermind-1.26.0-0068729c-linux-x64.zip -o nethermind.zip
   unzip -q nethermind.zip
   ```

   This obtains the Nethermind binary and extracts it.
3. **Get Lycan Config Files:** Clone the official Lycan Chain repository from GitHub:

   ```bash
   git clone https://github.com/Lycan-Chain/lycan_archive.git
   cp -r lycan_archive/* nethermind-1.26.0-0068729c-linux-x64/
   cd nethermind-1.26.0-0068729c-linux-x64/
   ```

   This places the Lycan config and chain data in the Nethermind directory.
4. **Import a Blockchain Snapshot (Optional but Recommended):** To sync faster, download the latest pre-synced Lycan Chain database and extract it. For example:

   ```bash
   curl -LO https://archive-backups.lycanchain.com/backup-2025-05-28.tar.gz
   tar -xzf backup-2025-05-28.tar.gz
   ```

   This extracts the database (folders like `db`, `chaindata`) into your Nethermind directory. Using this snapshot lets you catch up from a recent state without syncing from genesis.
5. **Run Nethermind:** Start the Nethermind client with the Lycan configuration:

   ```bash
   ./nethermind --config configs/lycan.cfg
   ```

   This launches the node on Lycan Chain. The client will begin syncing blocks (or verify the imported snapshot). Leave this process running; you can also set it up as a Linux service for auto-restart.

   To create a service, save the following content to `/etc/systemd/system/nethermind.service` (replace `<WORKING_DIR>` with the full path to your Nethermind directory):

   ```ini
   [Unit]
   Description=Nethermind Service
   After=network.target

   [Service]
   Type=simple
   WorkingDirectory=<WORKING_DIR>
   ExecStart=<WORKING_DIR>/nethermind --config=<WORKING_DIR>/configs/lycan.cfg
   Restart=on-failure
   RestartSec=20
   LimitNOFILE=4096
   StandardOutput=null
   StandardError=null
   LogRateLimitIntervalSec=30s
   LogRateLimitBurst=1000

   [Install]
   WantedBy=multi-user.target
   ```

   Then reload and start the service:

   ```bash
   sudo systemctl daemon-reload
   sudo systemctl enable nethermind
   sudo systemctl start nethermind
   ```

   This ensures your node auto-starts on reboot.
6. **Open Required Ports:** Ensure the following TCP ports are open and forwarded to your node:
   * **30303** – Ethereum P2P port (peer discovery/connect).
   * **8545** – JSON-RPC port (used by wallets/apps to query the node).
   * **8551** – Engine API port (used for consensus clients; may be needed depending on Lycan’s version). The staking dashboard will connect to your node via RPC (8545) to retrieve your node’s “mining address,” so make sure at least port 8545 is reachable (e.g. by configuring your firewall or using an nginx proxy).
7. **Wait for Full Sync:** Monitor the node’s logs to ensure it fully synchronizes with the network. You can watch the logs with:

   ```bash
   journalctl -u nethermind -f
   ```

   or check the `stdout` of Nethermind. Once the node reports it’s caught up to the latest block, it’s ready. This step is crucial: **the node must be fully synced before you register as a validator**.
8. **Security Lockdown:** Once your node is configured and synced, secure the server. Disable or firewall off SSH (port 22) to prevent unauthorized access; if remote access is needed, use a VPN, bastion host, or allow only your IP. (You may change the SSH port or use key-only login.) This hardens your node’s security.

### Step 3: Stake and Register as a Validator

1. **Open the Staking Dashboard:** In your browser, go to [**https://staking.lycanchain.com**](https://staking.lycanchain.com). Connect your MetaMask wallet to this site. Ensure the wallet has the 100,000+ LYC you prepared.
2. **Become a Validator:** Click **“Become a Validator”** on the dashboard. A form will appear. Fill in the details:
   * **Node Name:** Enter a unique name for your validator (e.g. “Alice’s Node” or “Bob’s Node”).
   * **Description:** (Optional) Write a short note about your node (location, hardware, etc.). This is only for you and the community to identify the node.
   * **RPC URL:** Enter the full endpoint for your node’s JSON-RPC API, e.g. `http://YOUR_SERVER_IP:8545`. Make sure this URL is correct and publicly reachable. Once entered, the form will automatically fetch your node’s *mining address* (validator address) from this RPC.
3. **Verify the Address:** Check that the fetched address shown in the form is the one you expect (it should be the address your node will use to sign blocks). If it’s incorrect, do **not** proceed—recheck your RPC URL and node status. A correct address ensures you will earn rewards under the right account.
4. **Stake Your LYC:** Enter your staking amount (must be **≥100,000 LYC**). Review the total you are staking, then submit the form. MetaMask will prompt you to approve a transaction on the Lycan network. Confirm the transaction and pay the gas fee.
5. **Confirm On-Chain:** After submission, wait for the transaction to be included in a block. You can watch the status in MetaMask or a Lycan block explorer. Once it’s confirmed, your LYC is locked in the staking contract and you officially become a validator. The dashboard should now list your node as an active validator.

Congratulations – your node is now part of the Lycan Chain validator set. Your validator will begin signing blocks in turn and earning rewards.

### Ongoing Operation and Tips

* **Keep the Node Running:** Ensure the Nethermind process (or systemd service) stays online 24/7. If the server reboots or Nethermind stops, restart it promptly.
* **Monitor Performance:** Check the logs regularly (`journalctl -u nethermind` or logs in the installation folder). Look for any syncing errors or warnings.
* **System Updates:** Periodically update the Ubuntu OS and Nethermind software (when new versions are released), but plan maintenance carefully. It’s best to stop the node, update, then restart to avoid inconsistencies.
* **Stay In Sync:** Since Lycan has \~3-second blocks, even short offline periods can make you miss block rewards. (On Ethereum-based networks this incurs *inactivity penalties*, so minimizing downtime is crucial.)
* **Security:** Continue to restrict SSH and RPC access. Use strong keys for any SSH access, and consider setting up firewall rules so only known IPs can reach port 8545 if possible.
* **Check Governance:** As a validator, you may also participate in Lycan’s DAO governance. Keep an eye on community channels for any proposals or network upgrades that may require action.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.lycanchain.com/staking-and-rewards/alpha-becoming-a-validator-on-lycan-chain.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.