Step 1: Clone the Light Node Repository

git clone https://github.com/Layer-Edge/light-node.git
cd light-node

Comment: First, clone the repository containing the node's source code. Then navigate to the light-node directory to proceed with the setup.

Step 2: Install Required Dependencies

Ensure the following dependencies are installed:

1. Go: Version 1.18 or higher

   Comment: Go is used to build and run the node. Check the version using the command go version.

2. Rust: Version 1.81.0 or higher

   Comment: Rust is required for working with the Risc0 Toolchain. Check the version using the command rustc --version.

3. Risc0 Toolchain: If not installed, run:

   curl -L https://risczero.com/install | bash && rzup install
   

   Comment: This utility is used for working with Zero-Knowledge Proofs (ZK Proofs).

4. LayerEdge gRPC Endpoint: Ensure you have access to a LayerEdge node for communication via gRPC.

Step 3: Configure Environment Variables

Create a .env file in the root directory of the project and add the following variables:

GRPC_URL=34.31.74.109:9090
CONTRACT_ADDR=cosmos1ufs3tlq4umljk0qfe8k5ya0x6hpavn897u2cnf9k0en9jr7qarqqt56709
ZK_PROVER_URL=http://127.0.0.1:3001
# Alternatively:
ZK_PROVER_URL=https://layeredge.mintair.xyz/
API_REQUEST_TIMEOUT=100
POINTS_API=https://light-node.layeredge.io
PRIVATE_KEY='cli-node-private-key'

Comment:

• GRPC_URL: The address of the LayerEdge gRPC server.

• CONTRACT_ADDR: The smart contract address in the Cosmos network.

• ZK_PROVER_URL: The URL of the service for generating ZK proofs.

• API_REQUEST_TIMEOUT: API request timeout.

• POINTS_API: URL for retrieving points data.

• PRIVATE_KEY: Your CLI node's private key.

Important: Ensure that ZK_PROVER_URL matches the address where the Merkle service is running.

Step 4: Start the Merkle Service

Before running the Light Node, start the Merkle service:

cd risc0-merkle-service
cargo build && cargo run

Comment: This service handles Merkle trees. Wait for the service to fully initialize before proceeding to the next step.

Step 5: Build and Run the LayerEdge Light Node

In a new terminal, navigate to the root directory of the project and execute:

go build
./light-node

Comment:

• The go build command compiles the node executable.

• ./light-node starts the node. Ensure it is successfully connected to the Merkle service.

Connecting CLI Node to LayerEdge Dashboard

1. Fetch Points via CLI

Use the following URL to fetch points:

https://light-node.layeredge.io/api/cli-node/points/{walletAddress}

Comment: Replace {walletAddress} with your CLI wallet address.

2. Connect to the Dashboard

1. Navigate to dashboard.layeredge.io.

2. Connect your wallet.

3. Link your CLI node's public key to the wallet.

Important:

• One CLI wallet can only be linked to one dashboard wallet.

• Linking is mandatory, even if the CLI and dashboard wallets are identical.

Dashboard Monitoring Features

The dashboard provides the following features:

• Node status (Active/Inactive).

• Points tracking and detailed analytics.

• Logs and performance monitoring.

Logging and Monitoring

The node provides logs for:

• Merkle tree discovery.

• ZK proof generation and verification.

• Data submission status.

• Performance optimizations (e.g., tree sleep state).

Comment: Use the logs to diagnose issues.

Security Best Practices

1. Store keys, mnemonics, and AUTHKEY offline.

2. Configure a firewall and secure SSH connections.

3. Regularly update the node from official LayerEdge sources.

Troubleshooting Common Issues

1. Issue: gRPC connection is inactive.Solution: Verify gRPC settings (GRPC_URL).

2. Issue: Risc0 Prover service is not running.Solution: Restart the service and check the logs.

3. Issue: Incorrect wallet or signature configurations.Solution: Double-check the wallet address and environment variables.

Comment: For more precise diagnostics, use the node logs.

PS. HELP

Yes, you need to specify the Cosmos wallet address and private key for the Light Node to function correctly. Let's break this down in detail:

1. Cosmos Wallet Address

• Why is it needed?

  • The wallet address is used for:

    • Identifying your node in the network.

    • Linking your CLI node to the Dashboard for status and points tracking.

    • Receiving rewards (if provided by the project).

• Where to get the wallet address?

  • If you already have a Cosmos wallet (e.g., created via keplr, cosmos-sdk, or another tool), use its address.

  • If you don’t have a wallet, you can create one using the following command:

    echo "your_mnemonic_phrase" | cosmos-cashd keys add <wallet_name> --recover
    

    Comment: Replace your_mnemonic_phrase with your mnemonic phrase if you have one.

  • After creating the wallet, you will receive an address in the format cosmos1....

2. Private Key

• Why is it needed?

  • The private key is used to sign transactions and interact with the network. Without it, your node won't be able to perform operations such as sending data, confirming transactions, or generating ZK proofs.

• Where to get the private key?

  • If you created the wallet via keplr or another tool, you can export the private key from that application.

  • If you created the wallet via the command line (e.g., cosmos-cashd), you can retrieve the private key using:

    cosmos-cashd keys export <wallet_name>
    

    Comment: This command will output an encrypted private key. Decrypt it if necessary.

• How to add the private key to .env?

  • In the .env file, locate the line:

    PRIVATE_KEY='cli-node-private-key'
    

    • Replace cli-node-private-key with your actual private key.

3. Important Notes

• Security:

  • Never share your private key with anyone.

  • Store it in a secure location (e.g., offline).

  • If you are using a .env file, ensure it is protected from unauthorized access.

• Linking with Dashboard:

  • After launching the node, you can link it to the Dashboard using your wallet’s public address (cosmos1...).

  • The private key is not required for the Dashboard but is essential for the node to operate.

4. Example .env Configuration

Suppose you have:

• Wallet address: cosmos1abcde...

• Private key: my_private_key_123...

Your .env file will look like this:

GRPC_URL=34.31.74.109:9090
CONTRACT_ADDR=cosmos1ufs3tlq4umljk0qfe8k5ya0x6hpavn897u2cnf9k0en9jr7qarqqt56709
ZK_PROVER_URL=http://127.0.0.1:3001
API_REQUEST_TIMEOUT=100
POINTS_API=https://light-node.layeredge.io
PRIVATE_KEY='my_private_key_123...'

5. What to Do Next?

1. Ensure that you have correctly specified the wallet address and private key.

2. Start the Merkle service:

   cd risc0-merkle-service
   cargo build && cargo run
   

3. Start the node:

   go build
   ./light-node
   

4. Check the logs to ensure the node is running correctly.

Now you are ready to launch and configure your LayerEdge node!

📂About: Monad is a new proof-of-stake (PoS) Ethereum Virtual Machine (EVM) compatible Layer 1 blockchain designed to improve the overall Ethereum ecosystem; and decentralized computation platform.

💰Fund Raised: $224M 🆓Mode: Free 💻Activity: Testnet activity

⬇️ Guid

🛜 Add Monad Testnet: https://chainlist.org/?search=10143&testnets=true

🚰 Faucet Links

1. https://faucet.morkie.xyz/monad

2. https://owlto.finance/Faucet/Monad [ *Minimum1k points requires + 1 time claim]

3. https://www.gas.zip/faucet/monad [ *20+ txn n gas.zip + 0.033+ Eth balance]

4. https://monad-faucet.vercel.app/ [ *Hold 0.01 Eth on Eth mainnet]

5. https://stake.apr.io/faucet

6. https://www.phantom.com/chains/monad#module-faucet

7. https://thirdweb.com/monad-testnet

🔗 Monad Testnet — https://testnet.monad.xyz/

🚰 Claim faucet

🔽 Scroll down & Buy NFTs

↘️ Explore the ecosystem — https://www.monad.xyz/ecosystem

⬇️ Here are some active Monad Dapps to Intract ⬇️

AICraft: ➡️ Go to: https://aicraft.fun/

✅ Join Whitelist ✅ Enter Monad Address

Ambient: ➡️ Go to : https://monad.ambient.finance/

✅ Swap ✅ Use Trade Feature ✅ Add Liquidity Pool ✅ Done

Apriori: ➡️ Go to: https://stake.apr.io/

✅ Claim Faucet ✅ Stake ✅ Withdraw ✅ Done

** Bean:** ➡️ Go to: https://perp.bean.exchange/#/trade

✅ Trade Perps ✅ Swap MON > USDC ✅ Trade ✅ Add Liquidity ✅ Collect Bean

** Caddy:** ➡️ Go to: https://alpha.caddy.finance/

✅ Claim Faucet ✅ Do perpetuals options ✅ Done

Curvance: ➡️ Go to: https://monad.curvance.com/monad

✅ Claim all faucet ✅ Deposit > Lend > Borrow > Claim Reward ✅ Repay ✅ Done

Izumi: ➡️ Go to: https://alpha.izumi.finance/trade/swap

✅ Switch Network ✅ Swap ✅ Add Liquidity ✅ Done

Kintsu: ➡️ Go to: https://kintsu.xyz/staking

✅ Stake MON ✅ Done

** Magma:** ➡️ Go to: https://www.magmastaking.xyz/

✅ Staking MON ✅ Done

Monorail: ➡️ Go to: https://monorail.xyz/

✅ Swap MON > Tokens ✅ Swap Every Week ✅ Done

Fantasy: ➡️ Go to: https://monad.fantasy.top/

✅ Claim NFT ✅ Play ✅ Done

Synnax: ➡️ Go to: https://monad.synnax.fi/#/my-positions

✅ Add Colateral ✅ Mint syUSD ✅ Done

Opals: ➡️ Go to: https://opals.io/create/project

✅ Create NFTs ✅ Done

Nostra: ➡️ Go to: https://monad.nostra.finance/lend-borrow

✅ Lend ✅ Borrow ✅ Swap

Narwhal: ➡️ Go to: https://testnet.narwhal.finance/

✅ Trading Futures ✅ Done

NadFun: ➡️ Go to: https://testnet.nad.fun/

✅ Create Memecoin ✅ Done

🖼️NFT Platform ➡️ Nfts2me: http://nfts2me.com/app/monad-testnet/

LayerEdge is a pioneering decentralized network that enhances Bitcoin's capabilities by integrating zero-knowledge (ZK) proofs and BitVM technology. This integration allows for trust-minimized settlements and verifications directly on the Bitcoin blockchain, enabling various protocols and applications to leverage Bitcoin's robust security with minimal resource consumption.

Key Features:

• Modular Architecture: LayerEdge's flexible infrastructure supports seamless integration with diverse protocols and technology stacks. This design empowers developers to utilize Bitcoin's Layer 1 security without overburdening the network.

• Proof Aggregation: By consolidating multiple zero-knowledge proofs into a single, compact proof, LayerEdge reduces the load on the Bitcoin network. This approach makes Bitcoin's security more accessible and practical for a wide range of protocols.

• Leaf-Level Verifiability: Each protocol can independently verify its specific zero-knowledge proofs from the aggregated proof posted on the Bitcoin network. This ensures the integrity of individual computations while leveraging Bitcoin's Layer 1 security.

Innovative Components:

• SP1 zkVM: A high-performance, open-source zero-knowledge virtual machine capable of verifying the execution of arbitrary Rust programs or any language compiled through LLVM.

• Bitfinity: Provides an Ethereum-like development experience with Layer 2 speed and scalability on Bitcoin. Solidity developers can easily transition by simply changing the RPC endpoint.

Mission:

LayerEdge aims to unlock Bitcoin as a foundational layer for all blockchains, rollups, and applications, fostering a modular and secure blockchain ecosystem.

By addressing current scalability challenges and offering innovative solutions, LayerEdge is set to play a crucial role in the evolution of blockchain technology.

https://t.co/I83ScduZ9O

The Nubit project, secured by Bitcoin and backed by Polychain, offers revolutionary opportunities for innovation in the Bitcoin ecosystem. Nubit is a scalable and cost-effective data availability layer designed to expand Bitcoin’s capabilities and enhance the efficiency of applications such as Ordinals, Layer 2s, and price oracles.

What is Nubit?

Nubit is a data availability layer that enables the Bitcoin community to scale its data volumes while maintaining low costs. The key components of Nubit include validators, full storage nodes, and light clients.

Key Components of Nubit:

• Validators: These nodes operate using the NubitBFT consensus algorithm and are responsible for proposing blocks and verifying their integrity. Validators play a crucial role in maintaining the network’s integrity and security.

• Full Storage Nodes: These nodes receive block data from validators and store it reliably. They are responsible for ensuring data availability, which is critical in mitigating risks such as data withholding or tampering.

• Light Clients: These nodes receive block headers broadcasted by validators and can initiate requests to full nodes to verify data availability.

Why Do We Need Nubit?

The surge in demand for Bitcoin inscriptions has led to a significant increase in the volume of data stored on the Bitcoin blockchain. This highlights the need for a solution to Bitcoin's inherent data throughput limitations. Nubit addresses this need by providing a scalable and reliable data storage solution, aligning with Bitcoin's principles of trust minimization.

Data Availability Layer

In blockchain, data availability ensures that data uploaded by users is reliably stored and can be verified by other network participants. The Data Availability Sampling (DAS) technique allows network participants to verify block data availability without downloading the entire block, greatly enhancing scalability and decentralization.

Consensus

Nubit aims to fully inherit Bitcoin’s security, including economic security, temper resistance, and censorship resistance.

Bitcoin Staking

The Bitcoin staking approach allows Bitcoin holders to participate in Proof of Stake (PoS) blockchains directly, without third-party services. This method offers strong economic security and allows for quick release of staked assets, improving liquidity.

Bitcoin Anchoring

Bitcoin anchoring reduces the unbonding period for staked assets, mitigating attack risks and speeding up withdrawals. This security measure records block hashes and validator votes on the Bitcoin blockchain, providing an additional layer of data protection.

SNARK-based Signature Aggregation

To achieve high censorship resistance, Nubit uses an efficient CometBFT-based consensus, supported by SNARK for signature aggregation. This reduces communication and verification costs in systems with many validators, significantly improving performance and reducing expenses.

Conclusion

The Nubit project is a significant advancement in the Bitcoin ecosystem, offering a scalable and secure solution for data availability. Through innovative technologies like the consensus mechanism based on Bitcoin staking and Bitcoin anchoring, as well as SNARK-based signature aggregation, Nubit ensures high reliability and efficiency. This expands possibilities for developers and users, fostering further growth and development within the Bitcoin community.

https://docs.nubit.org/nubit-da/introduction

Motivations and Challenges:

The Move whitepaper outlines the motivations behind the language's design, particularly in the context of public blockchain systems like Diem (formerly Libra). Unlike traditional closed systems, blockchain systems require openness, where all participants have equal access to view the state of the blockchain and submit transactions. This presents challenges such as preventing invalid transactions and ensuring asset scarcity and access control.

Key Issues with Existing Languages:

The Move engineering team identified three key issues with existing blockchain languages, including Bitcoin Script and the Ethereum Virtual Machine. These issues include indirect encoding of assets, inextensible scarcity, and inflexible access control. Move was developed to address these shortcomings and provide a more robust and versatile programming language for blockchain development.

Move's Solutions:

Move language represents a significant departure from traditional blockchain languages by introducing concepts such as first-class resources to address asset scarcity and access control issues. Unlike Bitcoin and Ethereum, where assets are represented as integers, Move represents assets like Diem as resources, making it easier and less error-prone to write programs based on crypto assets. Additionally, Move aims to make asset scarcity and access control more extensible and customizable, allowing for the creation of new assets with scarce qualities and customizable access levels.

Conclusion:

The Move language has emerged as a powerful tool for addressing key challenges in blockchain programming. By providing solutions to issues such as indirect asset encoding, inextensible scarcity, and inflexible access control, Move is reshaping the landscape of blockchain development and paving the way for a more inclusive and versatile blockchain ecosystem.