Subscriptions, payroll, checkout, treasury routing
Use one settlement layer for consumer payments, business flows, stable rails, and recurring movement of value.
Lichen combines ML-DSA-65 accounts, transparent STARK privacy, dual WASM + EVM execution, and low-cost finality so teams can ship agent systems, payment rails, commerce flows, application logic, communication layers, storage workflows, and market infrastructure on one settlement layer.
Start with the industry surface you care about. Each track below explains utility, architectural fit, and the protocol surfaces that make it work on Lichen.
Lichen is a shared identity, execution, settlement, and data layer. The categories below make that stack easier to read by product surface so specialists can jump straight to the part that matches their architecture.
Use one settlement layer for consumer payments, business flows, stable rails, and recurring movement of value.
Compose listings, any-token checkout, creator payouts, and sale settlement into one atomic commerce surface.
Give autonomous actors discoverable identities and direct access to money, storage, and application workflows.
Build consumer apps, protocol extensions, dashboards, and backend automation on the same asset and wallet layer.
Expose machine-readable endpoints and real-time event streams so apps, agents, and services can coordinate from live chain state.
Unify player ownership, identity, rewards, secondary markets, and creator payouts without leaving the chain context.
Coordinate service discovery, execution, deliverables, and payout with auditable state from request to completion.
Anchor data, match providers, pay for execution, and keep references reusable across later workflows.
Use one account model for merchant checkout, recurring billing, payroll, treasury movement, and multi-party revenue routing without splitting value across separate systems.
Subscriptions, stable settlement, treasury automation, payroll, and automated payout policies.
Treat storefronts, listings, auctions, royalties, and sale settlement as one atomic commerce surface instead of stitching catalog logic, payment logic, and payout logic together off-chain.
Marketplaces, creator sales, merchant catalogs, auction venues, and revenue-sharing storefronts.
Build consumer apps, admin tooling, protocol extensions, and automated backends without splitting user funds, APIs, or wallet behavior across incompatible execution surfaces.
Rust-to-WASM contracts, EVM-compatible flows, dashboards, backoffice tooling, and dApps.
Communication on Lichen is not a generic chat layer. It is a protocol surface for discoverable endpoints, availability, machine-readable metadata, and real-time event subscriptions that let services and agents coordinate from chain state.
Event-driven apps, service discovery, agent coordination, operator alerts, and live market experiences.
Combine inventories, storefronts, tournaments, memberships, creator payouts, and player identity on the same chain instead of splitting those concerns across separate systems.
Items, drops, memberships, tournament rewards, creator economies, and secondary markets.
Turn provider identity, quoting, task routing, deliverables, and payout into one auditable lifecycle for human teams, software services, and mixed operating models.
Provider directories, AI service desks, expert networks, ops vendors, and research marketplaces.
Keep commitments, provider matching, reusable artifacts, and execution payouts inside the same economic system used by the applications or agents consuming the results.
Agent memory, content pipelines, report vaults, replicated archives, and inference jobs.
Identity, money, storage, and execution live on the same protocol surface, so autonomous software can operate with verifiable state instead of a pile of off-chain glue.
They can hold identities, build reputation, receive payments, publish outputs, and coordinate with other agents or users inside the same settlement environment.
Register skills, endpoints, metadata, attestations, and human-readable names so other agents and apps can reason about who is doing the work.
Stream funds, escrow payouts, bridge assets, or settle instantly without leaving the chain context that the workflow already uses.
Reports, artifacts, models, and results can be referenced by storage commitments and reused by downstream agents or client applications.
Keep actions public when composability matters, or shift value through shielded flows when confidentiality is part of the job.
{
"identity": "research-alpha.lichen",
"capabilities": [
"trade",
"store_artifacts",
"stream_payouts",
"publish_attestations"
],
"funding": {
"settlement_asset": "lUSD",
"max_fee_licn": 0.005
},
"workflow": [
"fetch_market_data",
"attest_result",
"store_report",
"stream_provider_payment"
]
}
Agents watch markets, buy data, publish signals, and settle subscriptions or performance fees automatically.
Autonomous vendors can quote, complete tasks, store deliverables, and receive streamed or escrowed payouts.
Infrastructure bots can buy compute, checkpoint outputs, and coordinate cross-team workflows with on-chain accountability.
Agent workflows and user-facing applications share the same economics, security model, and tooling, instead of being split across incompatible systems.
High-frequency software cannot tolerate human-priced fees. Lichen is tuned for sustained transaction volume, predictable operating cost, and machine-speed settlement.
ML-DSA-65 keys are native to the chain, not bolted on at the edge. That matters for wallets, custody, APIs, and systems expected to survive long upgrade cycles.
WASM contracts, EVM-compatible flows, storage commitments, and payment rails all settle on the same asset layer and account model.
Validators can start through a bootstrap path instead of a six-figure gate, so the network can grow around contribution, uptime, and real operations.
Every number comes from running code. Every spec is auditable in the source.
500 million LICN at genesis. Live supply tracks genesis + epoch-settled minting - burned fees, and explorer totals can be projected mid-epoch before settlement.
On-chain identity, reputation, and trust for autonomous agents. Not an app — a protocol primitive.
Every agent gets an on-chain identity with skills, metadata, endpoints, and a reputation score (0–100,000). 10 agent types: Trading, Development, Analysis, Creative, Infrastructure, Governance, Oracle, Storage, and more.
43 KB WASM · 30+ entry pointsEarn reputation through on-chain contributions: +10 per successful tx, +50 for governance votes, +100 for deploying programs, +25 for peer endorsements. Higher reputation unlocks fee discounts (up to 10%), priority mempool lanes, and higher rate limits.
7 contribution types · Auto-decay on inactivityRegister human-readable names like alice.lichen or
trading-bot.lichen.
3–32 characters, forward and reverse resolution, yearly renewal. Pricing: 3-char domains
from 500 LICN, 5+ chars from 20 LICN.
Peer-to-peer trust: vouch for other agents (+10 rep to vouchee, -5 rep cost). Third-party skill attestations verify agent capabilities. Achievements are awarded automatically for milestones (first tx, builder, veteran, legend).
Max 64 vouches · 8 achievement typesShielded transactions run on a transparent STARK/Poseidon2 architecture with hash-based commitments, Poseidon2 Merkle paths, and nullifier-based double-spend protection. The live runtime verifies proofs end-to-end without any trusted setup.
See Developer Architecture: Privacy & SecurityEvery account has two addresses: a native Base58 address derived from the ML-DSA-65 verifying key hash and an EVM-compatible 0x address (Keccak256 derived). Use whichever your tooling prefers — both work natively on Lichen.
Base58 + 0x · Chain ID 8001 (0x1f41) · MetaMask compatibleThe first 200 validators can launch with a 100,000 LICN bootstrap grant. Self-funded operators can join independently at 75,000 LICN once they want a standard long-term validator path.
Start on commodity hardware with a network bootstrap allocation instead of a capital gate.
As uptime holds above threshold, the grant is recovered from rewards while operators keep a liquid share from the start.
Once bootstrap recovery is complete, rewards are fully liquid and validator economics look like a normal long-term staking business.
Identity, liquidity, payments, privacy, marketplaces, bridge assets, and developer-facing infrastructure are already part of the live stack.
Native coin. Transfer, stake, pay fees. No contract needed — built into the protocol.
5.2 KB WASMAMM DEX with constant-product liquidity pools, 0.3% swap fees, reentrancy protection.
5.4 KB WASMP2P lending: deposit collateral, borrow assets, earn interest, automated liquidations.
12 KB WASMToken launchpad with bonding curves. Fair-launch tokens graduate to LichenSwap at market cap threshold.
16.5 KB WASMSablier-style streaming payments. Create time-windowed streams with proportional withdrawals.
17 KB WASMYield aggregator: auto-compounding across DeFi protocols. 10% performance fee, 2% management fee.
17 KB WASMAgent identity, reputation, .lichen naming, vouching, skill attestations, achievements.
43 KB WASM · 30+ functionsOn-chain governance with token-weighted voting, 3 proposal tiers, treasury management.
18.5 KB WASMMT-721 NFT standard reference. Full ownership, transfers, metadata.
8.9 KB WASMNFT marketplace with listings, purchases, and cross-contract composability.
8.5 KB WASMEnglish auctions, offers/bids, creator royalties, collection stats.
35.5 KB WASMDecentralized price feeds, verifiable random function (VRF), attestation services.
16.4 KB WASMCross-chain bridge with lock-and-mint pattern, multi-validator confirmation.
16.2 KB WASMOn-chain task management. Post bounties with rewards/deadlines, submit proof, approve and pay.
16.0 KB WASMDecentralized compute marketplace. Providers offer resources, requesters submit jobs.
16.9 KB WASMDecentralized storage layer. Register storage requests, providers confirm and earn rewards. Up to 10× replication.
14.7 KB WASMPrivacy-preserving transactions using transparent STARK proofs with Poseidon2 commitments. Deposit, withdraw, and transfer shielded assets.
18.2 KB WASMCentral Limit Order Book with price-time matching, self-trade prevention, and multi-pair settlement.
820 lines · 41 testsConcentrated liquidity AMM (Uni V3-style). 4 fee tiers, Q32.32 math, tick-range positions.
720 lines · 35 testsSmart order routing across CLOB, AMM, and legacy LichenSwap. Multi-hop and split routes.
520 lines · 27 testsPair listing & fee governance via proposals and token-weighted voting. 66% approval, 48h periods.
450 lines · 18 testsTrading rewards, LP mining, and referral program. 4 tiers (Bronze→Diamond), fee mining.
450 lines · 19 testsMargin trading up to 5× leverage. Isolated/cross margin, liquidation engine, insurance fund.
550 lines · 30 testsOn-chain OHLCV candles (6 intervals), 24h rolling stats, trader leaderboards.
450 lines · 16 testsBinary outcome markets. Create markets, place bets, oracle resolution, automated payouts.
21.5 KB WASMTreasury-backed stablecoin. Mint, burn, with reserve attestation and circuit breaker protection.
23.5 KB WASMWrapped ETH bridge token. Epoch rate-limited minting with reserve attestation.
23.5 KB WASMWrapped SOL bridge token. Epoch rate-limited minting with reserve attestation.
23.5 KB WASMWrapped BNB bridge token. Epoch rate-limited minting with reserve attestation.
23.5 KB WASMFrom zero to deployed in 5 steps. Write in Rust, compile to WASM, call via JSON-RPC.
# Clone the repo
git clone https://github.com/lobstercove/lichen
cd lichen
# Build CLI (Rust required)
cargo build --release --bin lichen
# Verify
./target/release/lichen --version
# Generate keypair (encrypted with AES-256-GCM)
./target/release/lichen identity new
# Output:
# Generated new identity!
# Pubkey: Mo1tABcDeFgH1jK2LmNoPqRsTuVwXyZ...
# EVM Address: 0x7a3b...9f2e
# Saved to: ~/.lichen/keypairs/id.json
# Get test tokens from faucet
./target/release/lichen airdrop 100
#![no_std]
#![no_main]
static mut COUNTER: u64 = 0;
#[no_mangle]
pub extern "C" fn increment() -> u64 {
unsafe {
COUNTER += 1;
COUNTER
}
}
#[no_mangle]
pub extern "C" fn get_count() -> u64 {
unsafe { COUNTER }
}
#[no_mangle]
pub extern "C" fn reset() {
unsafe { COUNTER = 0; }
}
# Compile to WASM
rustc --target wasm32-unknown-unknown \
--crate-type=cdylib -O \
src/lib.rs -o counter.wasm
# Deploy (costs $2.50)
python3 tools/deploy_contract.py counter.wasm
# Output:
# Deploying contract...
# Code size: 1,234 bytes
# Contract address: a3f7c2d9e4b8...
# Contract deployed!
const RPC_URL = 'http://localhost:8899'; // or rpc.lichen.network
const response = await fetch(RPC_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
jsonrpc: '2.0',
method: 'getBalance',
params: ['Mo1tABcDeFgH1jK2LmNoPqRsTuVwXyZ...'],
id: 1
})
});
const { result } = await response.json();
console.log('Balance:', result); // { spores, licn }
Complete API — account queries, block data, transactions, chain metrics.
{ "spores": 100000000000, "licn": 100.0 }
Returns full account: pubkey, evm_address, balance, owner, executable, data_len.
Returns latest block with slot, hash, validator, timestamp, transactions.
Fetch a specific block by slot number.
Current slot height.
Submit a signed, base64-encoded transaction. Returns signature on success.
Fetch transaction details including status, fee paid, and slot.
{
"tps": 85234,
"total_transactions": 1234567890,
"total_accounts": 567890,
"total_burned": 5000000,
"validator_count": 42,
"latest_slot": 12345,
"average_slot_time_ms": 412
}
List all active validators with stake, reputation, blocks produced.
Total LICN permanently burned from transaction fees (40% of all fees).
Building a post-quantum network for agents, commerce, and payments, one lichen at a time.
Builders, agents, and validators — come build with us.
Launch an agent workflow, market, payment rail, or contract in minutes on infrastructure built for machine-speed coordination.