# Introduction Introduction Lycan Chain is a community-owned, Ethereum Virtual Machine (EVM)-based network operated by a diverse set of validators distributed globally. It leverages Parity's Authority Round (AuRa) proof-of-authority (PoA) consensus model, ensuring efficient and secure block validation. In this model, blocks are appended through a collaborative process involving selected validators. Lycan Chain will implement a DAO governance mechanism, enabling anyone to participate in decision-making processes concerning the network's development and future. Creating dApps and integrating with Lycan Chain products is similar to working with any other EVM-based blockchain. More details can be found in the [protocol specification](/chain-specifications). Validators in Lycan Chain are chosen through the POSDAO (Proof of Stake Decentralized Autonomous Organization) delegated Proof of Stake (DPOS) process. They take turns signing blocks in a round-robin fashion. Once a block is signed, it is broadcast to all validators. The block is added to the chain if the majority validate its legitimacy. This ensures a new block is appended every 3 seconds, maintaining network efficiency even if no transactions occur within that period. The POSDAO framework's pluggable consensus feature allows for future integration of different or additional consensus mechanisms. [Learn more in the Whitepaper](https://lycan-chain.gitbook.io/lycan-chain-whitepaper) View the current Lycan validator pools in the [Staking Application](https://staking.lycanchain.com). # Chain Specifications General Information | Property | | | ----------- | -------------------------------------------------------------- | | Block Size | 30M gas units | | Block Speed | 3 seconds | | Gas price | check [gas price](https://explorer.lycanchain.com/gas-tracker) | # Lycan Mainnet Lycan Mainnet Configuration | Config | Value | | ---------------------- | ---------------------------- | | Name | Lycan Mainnet | | RPC URL | | | Chain ID ( in Decimal) | 721 | | Chain ID ( in Hex) | 0x2D1 | | Symbol | LYC | # Lycan Betanet Lycan Betanet Configuration | Config | Value | | ---------------------- | --------------------------------- | | Name | Lycan Betanet | | RPC URL | | | Chain ID ( in Decimal) | 4321 | | Chain ID ( in Hex) | 0x10E1 | | Symbol | bLYC | # Developers Integration # Wallets A Quick Overview Wallets are digital tools that allow users to store, manage, and interact with their cryptocurrency assets. They store private and public keys, enabling secure transactions and interaction with blockchain networks. These wallets come in various forms, including hardware wallets (like Ledger), software wallets (like MetaMask), and paper wallets. Each type offers different levels of security and convenience. For Lycan Chain, blockchain wallets help users manage their LYC tokens and interact with decentralized applications (dApps) on the network. They provide a secure way to participate in staking, governance, and other network activities, ensuring that users can safely and efficiently engage with the Lycan ecosystem. # Ledger Ledger is a hardware wallet that keeps your private keys safe offline. This means your keys are protected from online threats. Even when you make transactions, the wallet confirms them offline. Learn more and get your Ledger device on the [Ledger Website](https://www.ledger.com). #### Connecting with Lycan Chain There isn't a specific Lycan app. Use the Ethereum app to connect with Lycan through MetaMask. Make sure your Ledger firmware is updated and you've set up Ledger Live. **Enabling Blind Signing** To interact with contracts (like transferring funds or swapping tokens), you need to enable blind signing. If you've updated your device recently, you may need to do this again. 1. Connect and unlock your Ledger device. 2. Open the Ethereum (ETH) app. 3. Go to "Settings" by pressing the right button. Press both buttons to select it. Your Ledger will show "Blind Signing." 4. Press both buttons to turn on blind signing. It will show "Enabled." 5. Try your transaction again. For more help, check the Ledger [support docs](https://support.ledger.com/hc/en-us/articles/4405481324433-Enable-blind-signing-in-the-Ethereum-ETH-app?docs=true). #### # MetaMask MetaMask is a web browser extension and mobile app that helps you manage your Lycan private keys. It acts as a wallet for Lycan and other tokens, allowing you to interact with decentralized applications (dapps). ### 1. Download[​](https://docs.gnosischain.com/tools/wallets/metamask/#1-download) \ The official MetaMask download page will detect your browser and provide the correct link to the extension store. It supports Chrome, Firefox, Opera, Edge, and Brave. MetaMask is also available for Android and iOS. ### 2. Configure[​](https://docs.gnosischain.com/tools/wallets/metamask/#2-configure) \ After installation, MetaMask needs to be set up to work with Lycan. See the instructions below: {% tabs %} {% tab title="Manual Setup" %}

Add Network

Lycan chain details in MetaMask

{% endtab %} {% tab title="Chainlist Link" %} Use this [ChainList Link](https://shanejonas.github.io/metamask-link/deep?method=wallet_addEthereumChain\¶ms\[0]\[chainId]=0x2D1\¶ms\[0]\[chainName]=Lycan\¶ms\[0]\[rpcUrls]\[0]=https://rpc.lycanchain.com/\¶ms\[0]\[nativeCurrency]\[name]=Lycan\¶ms\[0]\[nativeCurrency]\[symbol]=LYC\¶ms\[0]\[nativeCurrency]\[decimals]=18\¶ms\[0]\[blockExplorerUrls]\[0]=https://explorer.lycanchain.com) to automatically configure Lycan in MetaMask. {% endtab %} {% tab title="MetaMask DeepLink" %} Use this [MetaMask DeepLink](https://shanejonas.github.io/metamask-link/deep?method=wallet_addEthereumChain\¶ms\[0]\[chainId]=0x2D1\¶ms\[0]\[chainName]=Lycan\¶ms\[0]\[rpcUrls]\[0]=https://rpc.lycanchain.com/\¶ms\[0]\[nativeCurrency]\[name]=Lycan\¶ms\[0]\[nativeCurrency]\[symbol]=LYC\¶ms\[0]\[nativeCurrency]\[decimals]=18\¶ms\[0]\[blockExplorerUrls]\[0]=https://explorer.lycanchain.com) to automatically configure Lycan in MetaMask. {% endtab %} {% endtabs %} # Smart Contracts # Develop & Deploy # Hardhat Hardhat is a development environment used for compiling, deploying, testing, and debugging smart contracts. Check out Hardhat for [installation details](https://hardhat.org/hardhat-runner/docs/getting-started#installation) and [an overview](https://hardhat.org/hardhat-runner/docs/getting-started#overview). ### Hardhat Configuration for Lycan[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#config-hardhat-for-gnosis) Update the configuration file with the changes shown below for Lycan Chain, providing examples for both JavaScript and TypeScript. {% tabs %} {% tab title="JavaScript" %} ```javascript require("@nomiclabs/hardhat-waffle"); const fs = require("fs"); const mnemonic = fs.readFileSync(".secret").toString().trim(); let accounts = { mnemonic: mnemonic }; module.exports = { defaultNetwork: "lycan", solidity: "0.8.4", networks: { lycan: { url: "https://rpc.lycanchain.com", accounts: accounts, }, }, }; ``` {% endtab %} {% tab title="TypeScript" %} ```typescript import { HardhatUserConfig } from "hardhat/config"; import "@nomiclabs/hardhat-waffle"; import * as fs from "fs"; const mnemonic: string = fs.readFileSync(".secret").toString().trim(); let accounts = { mnemonic: mnemonic }; const config: HardhatUserConfig = { defaultNetwork: "lycan", solidity: "0.8.4", networks: { lycan: { url: "https://rpc.lycanchain.com", accounts: accounts, }, }, }; export default config; ``` {% endtab %} {% endtabs %} ### Compile your contract[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#compile-your-contract) ```properties npx hardhat compile ``` ### Deploy your contract[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#deploy-your-contract) {% tabs %} {% tab title="Javascript" %} ```properties npx hardhat run scripts/deploy.js --network lycan ``` {% endtab %} {% tab title="Typescript" %} ```properties npx hardhat run scripts/deploy.ts --network lycan ``` {% endtab %} {% endtabs %} View your deployed contract on any of the [explorers](https://explorer.lycanchain.com/). # Truffle Truffle is a world class development environment, testing framework and asset pipeline for blockchains using the Ethereum Virtual Machine (EVM), aiming to make life as a developer easier. Check out Truffle for [installation details](https://archive.trufflesuite.com/docs/truffle/quickstart/#install-truffle) and [an overview](https://archive.trufflesuite.com/docs/truffle/quickstart/). ### Truffle Configuration for Lycan[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#config-hardhat-for-gnosis) Update the configuration file with the changes shown below for Lycan Chain, providing examples for JavaScript. {% tabs %} {% tab title="JavaScript" %} ```javascript const HDWalletProvider = require('@truffle/hdwallet-provider'); const fs = require('fs'); const mnemonic = fs.readFileSync(".secret").toString().trim(); module.exports = { networks: { lycan: { provider: () => new HDWalletProvider(mnemonic, "https://rpc.lycanchain.com"), network_id: '*', // Lycan Chain's network id gas: 4500000, // Gas limit gasPrice: 10000000000 // 10 Gwei }, }, compilers: { solc: { version: "0.8.4", // Fetch exact version from solc-bin (default: truffle's version) } }, // Set default mocha options here, use special reporters etc. mocha: { // timeout: 100000 } }; ``` {% endtab %} {% endtabs %} Make sure you have the `HDWalletProvider` package installed by running: ```properties npm install @truffle/hdwallet-provider ``` ### Compile your contract[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#compile-your-contract) ```properties truffle compile ``` ### Deploy your contract[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#compile-your-contract) ```properties truffle migrate ``` View your deployed contract on any of the [explorers](https://explorer.lycanchain.com/). # Foundry Foundry manages your dependencies, compiles your project, runs tests, deploys, and lets you interact with the chain from the command-line and via Solidity scripts. Check out Foundry for [installation details](https://book.getfoundry.sh/getting-started/installation) and [an overview](https://book.getfoundry.sh/). Foundry consists of: * [Forge](https://book.getfoundry.sh/forge/): Forge tests, builds, and deploys your smart contracts. * [Cast](https://book.getfoundry.sh/cast/): Cast is Foundry’s command-line tool for performing Ethereum RPC calls. * [Anvil](https://github.com/foundry-rs/foundry/blob/master/anvil): Anvil is a local testnet node shipped with Foundry. * [Chisel](https://book.getfoundry.sh/chisel/): Chisel is an advanced Solidity REPL shipped with Foundry ### Compile your contract[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#compile-your-contract) ```properties forge build ``` ### Deploy your contract[​](https://docs.gnosischain.com/developers/dev-environment/hardhat#compile-your-contract) ```properties forge create --rpc-url https://rpc.lycanchain.com --private-key src/.sol: ``` View your deployed contract on any of the [explorers](https://explorer.lycanchain.com/). # Remix IDE Remix IDE is a powerful tool for developing, deploying, and managing smart contracts on various blockchain networks. In this guide, we will go through the steps to deploy a smart contract on the Lycan **Prerequisites** 1. **Remix IDE**: You can access Remix IDE through your browser at remix.ethereum.org. 2. **MetaMask**: A browser extension wallet for managing your accounts and transactions. Make sure it is connected to the Lycan Chain. ### **Step-by-Step Guide** **Step 1: Open Remix IDE** 1. Navigate to Remix IDE in your web browser. 2. Create a new file in the `contracts` directory. Name it `MyContract.sol`. **Step 2: Write Your Smart Contract** Write your smart contract in Solidity. Here is a simple example of a Solidity contract: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract MyContract { string public message; constructor(string memory _message) { message = _message; } function setMessage(string memory _message) public { message = _message; } } ``` **Step 3: Compile Your Contract** 1. Click on the `Solidity Compiler` tab on the left sidebar. 2. Select the appropriate compiler version (matching your Solidity code). 3. Click on the `Compile MyContract.sol` button. **Step 4: Configure MetaMask for Lycan Chain** 1. Open MetaMask and click on the network dropdown. 2. Select `Custom RPC` and enter the following details: * **Network Name**: Lycan Mainnet * **New RPC URL**: `https://rpc.lycanchain.com` * **Chain ID**: `721` * **Symbol**: `LYC` 3. Save and switch to the Lycan Mainnet network. **Step 5: Deploy Your Contract** 1. Go back to Remix IDE and click on the `Deploy & Run Transactions` tab. 2. In the `Environment` dropdown, select `Injected Web3`. This will connect Remix to MetaMask. 3. Ensure that the `Contract` dropdown is set to `MyContract`. 4. Click on the `Deploy` button. MetaMask will prompt you to confirm the transaction. 5. Confirm the transaction in MetaMask. **Step 6: Interact with Your Deployed Contract** 1. Once the contract is deployed, it will appear in the `Deployed Contracts` section in Remix. 2. You can interact with your contract functions directly from Remix by expanding the deployed contract interface. #### Conclusion By following these steps, you can easily deploy and manage your smart contracts on the Lycan Chain using Remix IDE. This setup ensures a smooth development experience and leverages the power of both Remix IDE and Lycan Chain. # Cookbook Cookbook helps blockchain developers by aggregating and organizing smart contracts, making it easy and fast to search for, open and work with contract code in your preferred development environment. Check out [Cookbook](https://docs.cookbook.dev/) for [an overview](https://docs.cookbook.dev/). **Why Use Cookbook with Lycan Chain?** Cookbook is an excellent tool for developers working on blockchain projects, offering: * **Ease of Use**: Simplified interfaces for complex blockchain interactions. * **Comprehensive Resources**: Access to templates, guides, and tools tailored for different blockchain networks. * **Community Support**: A vibrant community of developers and experts. By integrating Lycan Chain with Cookbook, you can streamline your development process, from smart contract creation to deployment and management. **Getting Started** 1. **Sign Up and Set Up**: * If you haven’t already, sign up for an account on [Cookbook.dev](https://www.cookbook.dev). * Set up your profile and connect your development environment to Cookbook. 2. **Creating a New Project**: * Navigate to the projects section and click on “Create New Project.” * Select “Lycan Chain” as your blockchain network. * ```

Lycan Blockchain in Cookbook

``` 3. **Utilizing Templates**: * Cookbook offers a variety of templates for different use cases such as token creation, decentralized exchanges, and more. * Choose a template that fits your project requirements. For instance, if you’re creating a new token, select the token template and customize it according to your needs. 4. **Smart Contract Development**: * Use Cookbook’s integrated development environment (IDE) to write and test your smart contracts. * Leverage the extensive libraries and pre-built modules available within Cookbook to expedite your development process. 5. **Deployment**: * Once your smart contracts are ready, use Cookbook’s deployment tools to deploy them on the Lycan Chain. * Cookbook provides detailed logs and transaction tracking to ensure smooth deployment. 6. **Management and Monitoring**: * After deployment, manage your contracts and monitor their performance using Cookbook’s dashboards. * Utilize analytics and reporting tools to gain insights into your contract’s operations. **Advanced Features** * **Custom Consensus Development**: * For projects requiring custom consensus mechanisms, Cookbook supports the integration and testing of these systems on Lycan Chain. * **Smart Contract Audits**: * Ensure the security and reliability of your smart contracts with Cookbook’s audit tools. Schedule audits and implement recommendations to fortify your contracts. * **Chain Recovery and Upgrades**: * Cookbook offers tools for chain recovery and implementing upgrades, ensuring your Lycan Chain projects remain robust and up-to-date. **Community and Support** * Join the Cookbook community forums to discuss your Lycan Chain projects, seek advice, and collaborate with other developers. * Access the extensive documentation and tutorials provided by Cookbook to enhance your understanding and capabilities in blockchain development. **Conclusion** Integrating Lycan Chain with Cookbook enhances your development experience by providing powerful tools, templates, and community support. Whether you’re a beginner or an experienced developer, Cookbook streamlines the process of building, deploying, and managing your dApps on Lycan Chain. Dive into the Cookbook platform today and take your Lycan Chain projects to the next level! # Interaction # Wagmi Wagmi is a popular React Hooks library for Ethereum and compatible blockchain networks, enabling developers to create seamless and responsive decentralized applications (dApps). Viem is an underlying **Setting Up Wagmi and Viem** To start using Wagmi and Viem with Lycan Chain, you'll need to install the necessary packages. You can do this via npm: ```bash npm install wagmi viem ``` **Initializing with Lycan Chain** Once you have the packages installed, you can import Lycan Chain from Viem or Wagmi and configure your application to connect to the Lycan Chain network. ```javascript import { createClient, WagmiConfig } from 'wagmi'; import { lycan } from 'viem/chains'; // or import { lycan } from 'wagmi/chains' const client = createClient({ autoConnect: true, chains: [lycan] }); function App() { return ( {/* Your app components */} ); } export default App; ``` This code initializes the Wagmi client with Lycan Chain as the selected network, using the RPC URL for Lycan Chain. # Ethers.js Ethers.js is a popular JavaScript library that enables developers to interact and compatible with Lycan Chain. Check out ethers.js for [installation details](https://docs.ethers.org/v6/getting-started/) and [an overview](https://docs.ethers.org/v6/). **Initializing Ethers.js with Lycan Chain** Once you have Ethers.js installed, you need to set up an Ethers.js provider and connect it to the Lycan Chain network. Here’s how you can do it: ```javascript const { ethers } = require('ethers'); // Connect to the Lycan Chain RPC URL const provider = new ethers.providers.JsonRpcProvider('https://rpc.lycanchain.com'); ``` This code initializes Ethers.js and connects it to the Lycan Chain using the provided RPC URL. #### Interacting with Smart Contracts **Initializing a Contract** To interact with a smart contract on Lycan Chain, you'll need the contract's ABI (Application Binary Interface) and its deployed address. Here’s an example of how to initialize a contract: ```javascript // ABI of the smart contract const contractABI = [ // ABI details here ]; // Address of the deployed contract const contractAddress = '0xYourContractAddressHere'; // Create a contract instance const myContract = new ethers.Contract(contractAddress, contractABI, provider); ``` Using Ethers.js with Lycan Chain provides a robust and efficient way to develop decentralized applications. By following the steps outlined above, you can easily set up Ethers.js, initialize contracts, and interact with the Lycan Chain network. Explore the powerful features of Ethers.js and harness the potential of Lycan Chain for your dApp development. # Web3.js Web3.js is a robust and flexible collection of TypeScript and JavaScript libraries that allows developers to interact with Lycan nodes over HTTP, IPC or WebSocket connections. Check out web3js for [installation details](https://docs.web3js.org/guides/getting_started/quickstart#installation) and [an overview](https://docs.web3js.org/). **Initializing Web3.js with Lycan Chain** Once you have Web3.js installed, you need to set up a Web3 instance and connect it to the Lycan Chain network. Here’s how you can do it: ```javascript const Web3 = require('web3'); // Connect to the Lycan Chain RPC URL const web3 = new Web3('https://rpc.lycanchain.com'); // Set default chain parameters web3.eth.defaultCommon = { customChain: { name: 'Lycan', chainId: 721, networkId: 721 } }; ``` This code initializes Web3.js and connects it to the Lycan Chain using the provided RPC URL. The `defaultCommon` parameter is configured to specify the custom chain details for Lycan Chain. #### Interacting with Smart Contracts **Initializing a Contract** To interact with a smart contract on Lycan Chain, you'll need the contract's ABI (Application Binary Interface) and its deployed address. Here’s an example of how to initialize a contract: ```javascript // ABI of the smart contract const contractABI = [ // ABI details here ]; // Address of the deployed contract const contractAddress = '0xYourContractAddressHere'; // Create a contract instance const myContract = new web3.eth.Contract(contractABI, contractAddress); ``` #### Advanced Configuration **Custom Chain Configuration** By setting `web3.eth.defaultCommon`, you ensure that Web3.js is aware of the custom chain parameters for Lycan Chain. This is crucial for correctly signing transactions and interacting with the network. ```javascript web3.eth.defaultCommon = { customChain: { name: 'Lycan', chainId: 721, networkId: 721 } }; ``` This configuration tells Web3.js to use the specified chain ID and network ID for all interactions, ensuring compatibility with Lycan Chain. # Faucet Get Betanet LYC Tokens Easily The Lycan Betanet is used strictly for experimental and development purposes. Please note: * Contracts deployed on the Betanet may be wiped during updates or resets. * Funds in your Betanet wallet are not permanent and can be lost without notice. * Do not use Betanet for real transactions or store any valuable assets, as the network is subject to change at any time. * Proceed with caution and only for testing purposes. **Note: You can withdraw once in every 24 hours.** For more information on Faucet. Please visit the below webpage. # Layer 2 SDK Coming soon. # Toolkit # APIS Coming soon. # Web sockets Coming soon. # Libraries Coming soon. # Staking and Rewards # Alpha (Becoming a Validator on Lycan Chain) To become a validator on Lycan Chain, follow the detailed steps below. This guide walks you through acquiring LYC tokens, setting up a validator node, and submitting your staking information. ### 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 `` with the full path to your Nethermind directory): ```ini [Unit] Description=Nethermind Service After=network.target [Service] Type=simple WorkingDirectory= ExecStart=/nethermind --config=/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. # Beta (Becoming a Delegator on Lycan Chain) Coming soon. # Getting Rewards The reward distribution system for Lycan Chain ensures that both validators and delegators are incentivized for their contributions to the network. This structure is designed to provide fairness and t **Reward Calculation and Distribution at the End of Epoch** 1. **Annual Inflation Rate**: Rewards are generated based on an annual inflation rate of 2.5%, applied to the total staked amount in the network. 2. **Block Rewards**: The total block rewards for each staking epoch are distributed among all active validator pools. A staking epoch is a predefined period during which validators participate in consensus. **Detailed Reward Distribution** **Step-by-Step Reward Calculation** 1. **Determine Total Rewards for Epoch**: * Calculate the total stake amount in the network. * Apply the annual inflation rate to determine the new tokens to be distributed as rewards. * Example: \ \ $$\text{newCoinsPerEpoch} = \text{totalStakeAmount} \times \left( \frac{\text{annualInflationRate}}{\text{numberOfEpochsPerYear}} \right)$$\ \ Here, `numberOfEpochsPerYear` depends on the length of each staking epoch. 2. **Calculate Pool Rewards**: * Divide the total rewards equally among all active validator pools. * Example:\ \ $$\text{poolReward} = \frac{\text{newCoinsPerEpoch}}{\text{numberOfActiveValidatorPools}}$$ **Distribution Within Pools** 1. **No Delegators**: * If a validator has no delegators, they receive 100% of the pool rewards. 2. **Delegators' Stake ≤ 70%**: * When the combined stake of delegators is less than or equal to 70% of the pool, the rewards are distributed proportionally: * **Validator Reward**:
$$validatorReward=poolReward×( validatorStake / ​ totalPoolStake )$$ * **Delegator Reward**:
$$delegatorReward=poolReward×( delegatorStake / ​ totalPoolStake )$$ 3. Delegators' Stake > 70%: * When the combined stake of delegators is less than or equal to 70% of the pool, the rewards are distributed proportionally: * **Validator Reward**:
$$validatorReward=poolReward×0.30$$ * **Delegator Reward**:
$$delegatorReward=poolReward×0.70×( delegatorStake / ​ totalPoolStake )$$ **Example Scenarios** 1. **Single Validator**: * **Stake**: Validator - 1,000 coins * **Reward Distribution**: Validator - 100% 2. **One Delegator**: * **Stake**: Validator - 1,000 coins, Delegator - 250 coins * **Reward Distribution**: Validator - 80%, Delegator - 20% 3. **Multiple Delegators** (≤70% Stake): * **Stake**: Validator - 1,000 coins, Delegators - 2,000 coins * **Reward Distribution**: Validator - 33.33%, Delegators - 66.67% 4. **Multiple Delegators** (>70% Stake): * **Stake**: Validator - 1,000 coins, Delegators - 3,000 coins * **Reward Distribution**: Validator - 30%, Delegators - 70% **Claiming Rewards** Participants can claim their rewards by invoking the `claimReward` function, specifying the staking address of the pool. This function transfers the participant's portion of the reward from the reward contract balance to their personal balance. **Additional Reward Components** * **Transaction Fees**: Collected by validators for transactions processed in their blocks. * **Bridge Fees**: Collected when assets are transferred between chains and distributed among validators and delegators according to their stakes. #### Summary The reward distribution system on Lycan Chain is designed to be fair and incentivizing for both validators and delegators. By ensuring proportional and capped rewards, the system promotes active participation and network security. The detailed calculations and examples provided help clarify how rewards are calculated and distributed among participants. # Multi Chain Bridge Multi Chain Bridge is a powerful tool designed to facilitate seamless cross-chain transfers between different blockchain networks. {% hint style="info" %} Currently, it supports transferring BEP20 USDT from Binance Smart Chain to LYC20 USDT on Lycan Chain and vice versa. Future updates will extend support to more tokens and coins, enhancing the bridge’s functionality {% endhint %} #### Features * **Cross-Chain Transfers**: Seamlessly transfer USDT between Binance Smart Chain (BEP20) and Lycan Chain (LYC20). * **User-Friendly Interface**: Easy-to-use interface to facilitate smooth and straightforward transactions. * **Secure Transactions**: High-security measures to ensure safe and reliable transfers. * **Future-Proof**: Designed to support additional tokens and coins in future updates. #### Getting Started **Accessing the Bridge** To access the Multi Chain Bridge, navigate to . **Prerequisites** Before you begin using the bridge, ensure you have: * A BEP20-compatible wallet (e.g., MetaMask) with USDT on Binance Smart Chain. * A LYC20-compatible wallet with USDT on Lycan Chain. * Sufficient funds to cover transaction fees on both networks. #### How to Use the Multi Chain Bridge **Transferring USDT from Binance Smart Chain to Lycan Chain** 1. **Connect Your Wallet**: Open the Multi Chain Bridge and connect your BEP20-compatible wallet. 2. **Select Transfer Direction**: Choose "Binance Smart Chain to Lycan Chain". 3. **Enter Transfer Details**: * Specify the amount of USDT you want to transfer. * Provide your LYC20 USDT receiving address on Lycan Chain. 4. **Approve the Transaction**: Approve the USDT transfer from your BEP20 wallet. 5. **Initiate the Transfer**: Confirm and initiate the transfer on the bridge interface. 6. **Switch to Lycan Chain**: After sending the tokens, switch your wallet to Lycan Chain. 7. **Claim Your Tokens**: Claim your LYC20 USDT on Lycan Chain. For first-time claimers, you will receive a bonus of 0.1 LYC, but only for the first use of the wallet. **Transferring USDT from Lycan Chain to Binance Smart Chain** 1. **Connect Your Wallet**: Open the Multi Chain Bridge and connect your LYC20-compatible wallet. 2. **Select Transfer Direction**: Choose "Lycan Chain to Binance Smart Chain". 3. **Enter Transfer Details**: * Specify the amount of USDT you want to transfer. * Provide your BEP20 USDT receiving address on Binance Smart Chain. 4. **Approve the Transaction**: Approve the USDT transfer from your LYC20 wallet. 5. **Initiate the Transfer**: Confirm and initiate the transfer on the bridge interface. 6. **Switch to Binance Smart Chain**: After sending the tokens, switch your wallet to Binance Smart Chain. 7. **Claim Your Tokens**: Claim your BEP20 USDT on Binance Smart Chain. #### Future Enhancements The Multi Chain Bridge is designed to evolve with the needs of the blockchain community. Future updates will include: * **Support for More Tokens and Coins**: Expanding the range of assets that can be transferred using the bridge. * **Enhanced User Experience**: Continuous improvements to the interface and user interaction. * **Increased Security Measures**: Ongoing security enhancements to ensure the safety of all transactions. #### Support For any issues, questions, or feedback, please visit our support page or contact our support team at . #### Conclusion The Multi Chain Bridge offers a reliable and efficient way to transfer USDT between Binance Smart Chain and Lycan Chain. With planned updates to support more tokens and coins, it is set to become an essential tool for cross-chain transactions. Start using the bridge today at and experience seamless cross-chain transfers. For more detailed guides and updates, keep an eye on our documentation. Happy bridging! # Grants Coming soon. # LNS Lycan Name Service (LNS) Coming soon.