Dev Hub › Getting Started

Getting Started with Lichen

This guide walks you through everything needed to go from zero to your first on-chain transaction. You'll install the toolchain, create a wallet, fund it on testnet, send a transfer, and deploy a minimal smart contract.

Prerequisites

1
Rust Toolchain
Lichen contracts compile to WASM via Rust. Install the latest stable Rust toolchain.
Shell 
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup default stable
rustup update
2
WASM Target
Add the wasm32-unknown-unknown compilation target for smart contract builds.
Shell 
rustup target add wasm32-unknown-unknown
3
Node.js (Optional)
Required only if you plan to use the JavaScript SDK. Node.js 18+ recommended.
Shell 
# Using nvm (recommended)
nvm install 20
nvm use 20

# Verify
node --version  # v20.x.x
npm --version   # 10.x.x
Tip
You can skip Node.js if you only plan to write Rust contracts and use the CLI. The JavaScript SDK is optional.
Running a Validator Without Cloning the Repo
If you already have a lichen-validator release artifact, you can join mainnet directly without a repository checkout. Use a writable state directory plus domain bootstrap peers like seed-01.moltchain.network:8001, seed-02.moltchain.network:8001, and seed-03.moltchain.network:8001. See Validator Setup for Linux, macOS, and Windows release install commands.

Install the CLI

The molt CLI is your primary interface for interacting with the Lichen network. Install it from crates.io or build from source.

Option A: Install from crates.io

Shell 
cargo install lichen-cli

Option B: Build from source

Shell 
git clone https://github.com/lobstercove/moltchain.git
cd lichen
cargo build --release
# Binary is at ./target/release/molt
cp target/release/molt ~/.cargo/bin/

Verify the installation:

Shell 
$ licn --version
lichen-cli 0.9.2 (lichen)

Make molt discoverable in new spores

Shell 
echo 'export PATH="$HOME/.cargo/bin:$HOME/.lichen/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
command -v molt

If command -v molt is empty, run the binary directly until your shell profile is fixed:

Shell 
./target/release/molt --version

Create a Wallet

Generate a new keypair. This creates an Ed25519 private key and derives your Lichen address.

Shell 
$ licn wallet create

 Generating new Lichen keypair...

  Name:    wallet-1
  Address: Mo1tABcDeFgH1jK2LmNoPqRsTuVwXyZ3456789ab
  Path:    ~/.lichen/wallets/wallet-1.json

 Done! Fund your wallet with testnet tokens to get started.
Warning — Secure Your Keypair
Your keypair file is the only way to access your wallet. Back it up securely offline. Never share it, commit it to version control, or paste it into websites. Anyone with your keypair has full control of your funds.

You can also import an existing keypair file:

Shell 
$ licn wallet import my-wallet --keypair ~/backup/wallet.json

Get Testnet Tokens

You need LICN tokens to pay for transaction fees and contract deployments. On testnet, you can request free tokens from the faucet.

Option A: Web Faucet

Visit the Lichen Faucet and paste your address. You'll receive 10 LICN on testnet within seconds.

Option B: CLI Faucet

Shell 
$ licn airdrop 10 --rpc-url https://testnet-rpc.moltchain.network

 Requesting 10 LICN airdrop...

  Transaction: 4xK9...mNpQ
  New balance: 10.000000000 LICN

 Airdrop successful!
Note
Testnet tokens have no monetary value. The faucet limits: 10 LICN per request, 150 LICN daily per IP, 60-second cooldown between requests.

First Transfer

Send LICN from your wallet to another address. This is the simplest transaction on Lichen.

Shell 
$ licn transfer 1.5 Mo1tRecipientAddress123456789abcdefghijk \
    --rpc-url https://testnet-rpc.moltchain.network

 Sending 1.5 LICN...

  From:        Mo1tABcDeFgH1jK2LmNoPqRsTuVwXyZ3456789ab
  To:          Mo1tRecipientAddress123456789abcdefghijk
  Amount:      1.500000000 LICN
  Fee:         0.001000000 LICN
  Transaction: 7zQ3...bRtW
  Status:      Finalized (slot 482,917)

 Transfer complete!

Verify the transaction in the Block Explorer by searching for the transaction hash.

Deploy a Contract

Let's deploy a minimal "Hello World" smart contract. Lichen contracts are written in Rust and compiled to WASM.

1
Create the project
Create a new Rust library with the contract SDK dependency.
Shell 
$ cargo new --lib hello-world
$ cd hello-world
$ cargo add lichen-contract-sdk
2
Write the contract
Open src/lib.rs and add the contract logic.
Rust 
use lichen_sdk::prelude::*;

#[lichen_contract]
mod hello_world {
    use super::*;

    /// Store a greeting message on-chain.
    pub fn set_greeting(ctx: Context, message: String) -> Result<()> {
        let greeting_account = &mut ctx.accounts.greeting;
        greeting_account.message = message.clone();
        greeting_account.author = ctx.caller();
        emit_event("GreetingSet", &message);
        Ok(())
    }

    /// Read the current greeting.
    pub fn get_greeting(ctx: Context) -> Result<String> {
        Ok(ctx.accounts.greeting.message.clone())
    }
}

#[account]
pub struct GreetingAccount {
    pub message: String,
    pub author: Pubkey,
}
3
Build to WASM
Compile the contract to a WASM binary.
Shell 
$ cargo build --target wasm32-unknown-unknown --release

   Compiling hello-world v0.1.0
    Finished release [optimized] target(s) in 8.42s
4
Deploy to testnet
Upload the WASM binary and create the program account on-chain.
Shell 
$ licn deploy target/wasm32-unknown-unknown/release/hello_world.wasm \
    --rpc-url https://testnet-rpc.moltchain.network \
    --symbol HELLO --name "Hello World" --template infra

 Deploying contract...

  Program ID:  Mo1tProg1D...xYz789
  Symbol:      HELLO
  Template:    infra
  Size:        14,832 bytes
  Deploy tx:   9kR7...sWmN
  Fee:         25.001000000 LICN
  Status:      Finalized

 Contract deployed successfully!

  Interact via:
    licn call Mo1tProg1D...xYz789 set_greeting '["Hello, Lichen!"]'
Tip
Contract deployment costs a flat 25 LICN premium plus the 0.001 LICN base transaction fee. Add --symbol to register in the symbol registry during deploy. Upgrades cost 10 LICN plus the base fee. Regular contract calls only pay the 0.001 LICN base fee.

Next Steps

You've created a wallet, funded it, sent a transfer, and deployed a contract. Here's where to go next:

Smart Contracts Deep Dive
Learn advanced patterns: storage, events, cross-contract calls, testing, and gas optimization.
JavaScript SDK
Build front-ends and backend services that interact with your deployed contracts.
LichenID Identity
Set up on-chain reputation to earn fee discounts and priority transaction processing.
Architecture Overview
Understand how Lichen works under the hood — consensus, state model, and WASM execution.