Smart Contract Development Guide

[package]
name = "my-contract"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
lichen-sdk = { package = "lichen-contract-sdk", path = "../../sdk" }

#![no_std]
#![cfg_attr(target_arch = "wasm32", no_main)]

extern crate alloc;
use alloc::vec::Vec;

use lichen_sdk::{
    storage, contract, event, log,
    Address, ContractResult, ContractError,
};

/// Initialize the contract. Called once after deployment.
#[no_mangle]
pub extern "C" fn initialize(admin_ptr: *const u8) -> u32 {
    let admin = unsafe { core::slice::from_raw_parts(admin_ptr, 32) };
    storage::set(b"admin", admin);
    log::info("Contract initialized");
    0 // success
}

/// Example: store a value.
#[no_mangle]
pub extern "C" fn set_value() -> u32 {
    let args = contract::args();
    if args.len() < 8 {
        return 1; // invalid input
    }
    storage::set(b"value", &args[..8]);
    event::emit(r#"{"name":"ValueSet","data":"..."}"#);
    0
}

/// Example: read a value.
#[no_mangle]
pub extern "C" fn get_value() -> u32 {
    match storage::get(b"value") {
        Some(data) => {
            contract::set_return(&data);
            0
        }
        None => 1,
    }
}

use lichen_sdk::{storage, u64_to_bytes, bytes_to_u64, Address};

// Store a counter
fn increment_counter() {
    let current = storage::get(b"counter")
        .map(|d| bytes_to_u64(&d))
        .unwrap_or(0);
    storage::set(b"counter", &u64_to_bytes(current + 1));
}

// Store per-account data with composite key
fn set_balance(account: Address, amount: u64) {
    let mut key = b"balance:".to_vec();
    key.extend_from_slice(account.to_bytes());
    storage::set(&key, &u64_to_bytes(amount));
}

lichen --rpc-url https://testnet-rpc.lichen.network --output json symbol lookup LICHENSWAP

# Replace <LICHENSWAP_ADDRESS> with the program from the lookup result.
lichen --rpc-url https://testnet-rpc.lichen.network --output json \
  call <LICHENSWAP_ADDRESS> get_quote --args '[1000000000, true]'

curl -X POST https://testnet-rpc.lichen.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getLichenSwapStats","params":[]}'

lichen --rpc-url https://testnet-rpc.lichen.network --output json symbol lookup LEND

# Replace <LEND_ADDRESS> with the program from the lookup result.
lichen --rpc-url https://testnet-rpc.lichen.network --output json \
    call <LEND_ADDRESS> get_protocol_stats

lichen --rpc-url https://testnet-rpc.lichen.network --output json \
    call <LEND_ADDRESS> get_interest_rate

curl -X POST https://testnet-rpc.lichen.network \
    -H "Content-Type: application/json" \
    -d '{"jsonrpc":"2.0","id":1,"method":"getThallLendStats","params":[]}'

lichen --rpc-url https://testnet-rpc.lichen.network --output json symbol lookup SPOREVAULT

# Replace <SPOREVAULT_ADDRESS> with the program from the lookup result.
lichen --rpc-url https://testnet-rpc.lichen.network --output json \
    call <SPOREVAULT_ADDRESS> get_vault_stats

lichen --rpc-url https://testnet-rpc.lichen.network --output json \
    call <SPOREVAULT_ADDRESS> get_strategy_info --args '[0]'

curl -X POST https://testnet-rpc.lichen.network \
    -H "Content-Type: application/json" \
    -d '{"jsonrpc":"2.0","id":1,"method":"getSporeVaultStats","params":[]}'

lichen --rpc-url https://testnet-rpc.lichen.network --output json symbol lookup BOUNTY

# Replace <BOUNTY_ADDRESS> with the program from the lookup result.
lichen --rpc-url https://testnet-rpc.lichen.network --output json \
    call <BOUNTY_ADDRESS> get_bounty_count

lichen --rpc-url https://testnet-rpc.lichen.network --output json \
    call <BOUNTY_ADDRESS> get_platform_stats

curl -X POST https://testnet-rpc.lichen.network \
    -H "Content-Type: application/json" \
    -d '{"jsonrpc":"2.0","id":1,"method":"getBountyBoardStats","params":[]}'

use lichen_sdk::crosscall::{CrossCall, call_contract};
use lichen_sdk::{Address, bytes_to_u64};

const LICHENID_ADDRESS: [u8; 32] = [/* well-known address */];
const MIN_REPUTATION: u64 = 500;

fn require_reputation(caller: &[u8]) -> bool {
    let lichenid = Address::new(LICHENID_ADDRESS);
    let call = CrossCall::new(lichenid, "get_reputation", caller.to_vec());
    match call_contract(call) {
        Ok(data) if data.len() >= 8 => {
            bytes_to_u64(&data) >= MIN_REPUTATION
        }
        _ => false,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use lichen_sdk::test_mock;

    #[test]
    fn test_initialize_and_set_value() {
        test_mock::reset();

        // Set up mock caller
        let admin = [1u8; 32];
        test_mock::set_caller(admin);

        // Initialize contract
        let result = initialize(admin.as_ptr());
        assert_eq!(result, 0, "initialize should succeed");

        // Verify admin was stored
        let stored = test_mock::get_storage(b"admin");
        assert_eq!(stored, Some(admin.to_vec()));

        // Set a value
        let value_bytes = 42u64.to_le_bytes();
        test_mock::set_args(&value_bytes);
        let result = set_value();
        assert_eq!(result, 0);

        // Read it back
        let result = get_value();
        assert_eq!(result, 0);
        let returned = test_mock::get_return_data();
        assert_eq!(returned, value_bytes.to_vec());

        // Check logs
        let logs = test_mock::get_logs();
        assert!(logs.iter().any(|l| l.contains("initialized")));
    }
}

# Install the WASM target (one-time)
rustup target add wasm32-unknown-unknown

# Build in release mode
cargo build --target wasm32-unknown-unknown --release

# Output location:
# target/wasm32-unknown-unknown/release/my_contract.wasm

# Reduce WASM size with wasm-opt
wasm-opt -Oz -o optimized.wasm \
  target/wasm32-unknown-unknown/release/my_contract.wasm

# Deploy with full symbol registration (recommended)
lichen deploy target/wasm32-unknown-unknown/release/my_contract.wasm \
    --symbol MYTK --name "My Token" --template mt20 --decimals 9 \
    --metadata '{"website":"https://example.com","logo_url":"https://example.com/logo.png","description":"Community token"}'

# Standard MT-20 launch with owner mint and token profile metadata
lichen token create "My Token" MYTK \
    --wasm target/wasm32-unknown-unknown/release/mt20_token.wasm \
    --decimals 9 --initial-supply 1000000 \
    --website https://example.com --logo-url https://example.com/logo.png

# Deploy with just symbol + name (minimum for explorer visibility)
lichen deploy target/wasm32-unknown-unknown/release/my_contract.wasm \
    --symbol MYTK --name "My Token" --template mt20 --decimals 9

# Deploy without registration (can register later)
lichen deploy target/wasm32-unknown-unknown/release/my_contract.wasm

# Register an already-deployed contract retroactively
lichen contract register <address> --symbol MYTK --name "My Token" --template mt20

# Output:
# 🦐 Deploying contract: my_contract.wasm
# 📦 Size: 45 KB
# 📍 Contract address: 7xK9...mN2q
# ✅ Contract deployed and verified on-chain!
# 🏷️  Symbol 'MYTK' registered in symbol registry
# 📝 Signature: 3hF8...pQ7r

# Call a function on the deployed contract
lichen call 7xK9...mN2q initialize --args '["AdminPubkey..."]'

# Call with arguments
lichen call 7xK9...mN2q set_value --args '[42]'

fn enter_guard() -> bool {
    if storage::get(b"_locked").is_some() {
        return false; // already locked
    }
    storage::set(b"_locked", &[1]);
    true
}

fn exit_guard() {
    storage::remove(b"_locked");
}

#[no_mangle]
pub extern "C" fn sensitive_operation() -> u32 {
    if !enter_guard() { return 99; } // reentrancy blocked

    // ... do work, cross-contract calls, etc.

    exit_guard();
    0
}

//  BAD: can overflow/underflow
let new_balance = balance + amount;
let new_balance = balance - amount;

//  GOOD: saturating arithmetic
let new_balance = balance.saturating_add(amount);
let new_balance = balance.saturating_sub(amount);

//  GOOD: explicit bounds check
if balance < amount {
    return Err(ContractError::InsufficientFunds);
}
let new_balance = balance - amount;

fn require_admin(caller: &[u8]) -> bool {
    match storage::get(b"admin") {
        Some(admin) => caller == admin.as_slice(),
        None => false,
    }
}

#[no_mangle]
pub extern "C" fn admin_only_function(caller_ptr: *const u8) -> u32 {
    let caller = unsafe { core::slice::from_raw_parts(caller_ptr, 32) };
    if !require_admin(caller) {
        log::info("Unauthorized");
        return 2;
    }
    // ... proceed
    0
}