Post-Quantum Security · WASM + EVM · Payments · Storage

Post-quantum Layer 1 for
agents

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.

Connecting to network…
$0.0001
Per Transaction
400ms
Finality
Latest Block
Validators
Live TPS

Category Showroom

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.

Payments

Subscriptions, payroll, checkout, treasury routing

Use one settlement layer for consumer payments, business flows, stable rails, and recurring movement of value.

LICN · lUSD · Bridge · SporePay
Commerce

Storefronts, listings, auctions, royalties, sales rails

Compose listings, any-token checkout, creator payouts, and sale settlement into one atomic commerce surface.

Marketplace · Auctions · Royalties · Sales events
Agents

Identity, attestations, coordination, payout logic

Give autonomous actors discoverable identities and direct access to money, storage, and application workflows.

LichenID · BountyBoard · SporePay
Programs

WASM contracts, EVM-compatible flows, open APIs

Build consumer apps, protocol extensions, dashboards, and backend automation on the same asset and wallet layer.

WASM · EVM · RPC · WebSocket · SDKs
Communication

Endpoints, presence, subscriptions, event-driven coordination

Expose machine-readable endpoints and real-time event streams so apps, agents, and services can coordinate from live chain state.

LichenID · WebSocket · Logs · Market events
Gaming

Items, economies, storefronts, tournaments

Unify player ownership, identity, rewards, secondary markets, and creator payouts without leaving the chain context.

NFTs · Auctions · Marketplaces · Rewards
Services

Provider networks, quoting, delivery, and settlement

Coordinate service discovery, execution, deliverables, and payout with auditable state from request to completion.

Profiles · Tasks · Storage refs · Settlement
Storage

Artifact retention, compute coordination, reusable outputs

Anchor data, match providers, pay for execution, and keep references reusable across later workflows.

Moss Storage · Compute Market · Event feeds
Payments

Settlement rails that stay programmable at product scale.

Use one account model for merchant checkout, recurring billing, payroll, treasury movement, and multi-party revenue routing without splitting value across separate systems.

Best for

Subscriptions, stable settlement, treasury automation, payroll, and automated payout policies.

Utility

What teams can build

  • Checkout and settlement in LICN, lUSD, or bridged assets.
  • Recurring transfers, usage-based billing, and payout schedules.
  • Treasury flows for vendors, grants, payroll, and revenue sharing.
Why

Why Lichen fits

  • Predictable low fees make frequent or low-ticket settlement viable.
  • ML-DSA-65 accounts and custody paths suit long-lived financial infrastructure.
  • The same wallet surface works for users, operators, and autonomous systems.
How

How it lands on-chain

  • Use SporePay and contract logic for recurring or rule-based settlement.
  • Route treasury or bridge flows without leaving the native account layer.
  • Integrate through wallet, SDKs, JSON-RPC, and WebSocket events.
Protocol surfaces
LICN lUSD SporePay Custody Bridge Wallet
Typical deployments
Merchant checkout Subscriptions Payroll Treasury ops
Commerce

Commerce flows with listings, checkout, and payout logic in one stack.

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.

Best for

Marketplaces, creator sales, merchant catalogs, auction venues, and revenue-sharing storefronts.

Utility

What teams can build

  • Fixed-price listings and any-token checkout for on-chain goods.
  • Auction flows, direct offers, and collection-level sales logic.
  • Creator royalties, marketplace fees, and seller payouts in one transaction path.
Why

Why Lichen fits

  • Payment routing and asset transfer can settle atomically instead of asynchronously.
  • Wallet, explorer, and event surfaces stay shared across buyer and seller flows.
  • Low fees let marketplaces support frequent listings, updates, and sales events.
How

How it lands on-chain

  • LichenMarket supports fixed-price listings with atomic token and NFT transfer.
  • LichenAuction handles bids, settlement, royalties, and marketplace fee deduction.
  • WebSocket market subscriptions let storefronts react to listings and completed sales.
Protocol surfaces
LichenMarket LichenAuction SporePay Market subscriptions Wallet
Typical deployments
Creator storefronts NFT commerce Auction venues Merchant catalogs
Programs

Applications and protocol logic on one shared execution surface.

Build consumer apps, admin tooling, protocol extensions, and automated backends without splitting user funds, APIs, or wallet behavior across incompatible execution surfaces.

Best for

Rust-to-WASM contracts, EVM-compatible flows, dashboards, backoffice tooling, and dApps.

Utility

What teams can build

  • Composable contracts with shared balances, identity, and payment rails.
  • Browser apps, operator consoles, and automation against one RPC surface.
  • Protocol modules that can still interoperate with wallets and existing assets.
Why

Why Lichen fits

  • WASM and EVM-compatible execution reduce ecosystem fragmentation.
  • One wallet and account model lowers integration and support cost.
  • Open transports keep frontend, backend, and agent clients consistent.
How

How it lands on-chain

  • Deploy Rust contracts to WASM or target the EVM-compatible surface.
  • Use JSON-RPC, WebSocket subscriptions, and compat routes for integration.
  • Ship with JS, Python, or Rust SDKs and shared browser wallet tooling.
Protocol surfaces
WASM VM EVM Compat JSON-RPC WebSocket JS SDK Python SDK
Typical deployments
Consumer dApps Operator dashboards Protocol extensions Backend automation
Communication

Machine-readable communication built from endpoints and live events.

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.

Best for

Event-driven apps, service discovery, agent coordination, operator alerts, and live market experiences.

Utility

What teams can build

  • Endpoint directories with identity-linked metadata, availability, and rates.
  • Real-time account, log, block, transaction, and marketplace event feeds.
  • Workflow coordination between apps, agents, and service providers.
Why

Why Lichen fits

  • Identity and live events stay tied to the same account and settlement model.
  • Real-time coordination does not need a separate off-chain truth source.
  • Apps can react directly to state changes that matter for users or automation.
How

How it lands on-chain

  • LichenID exposes endpoints, metadata, availability, and delegated profile control.
  • WebSocket subscriptions stream slots, blocks, transactions, accounts, logs, and market activity.
  • Operational services can expose authenticated event streams for downstream systems.
Protocol surfaces
LichenID endpoints WebSocket Account subscriptions Log subscriptions Market subscriptions
Typical deployments
Agent directories Realtime dashboards Operational alerts Live storefront updates
Gaming

Digital ownership and game economies without fragmented rails.

Combine inventories, storefronts, tournaments, memberships, creator payouts, and player identity on the same chain instead of splitting those concerns across separate systems.

Best for

Items, drops, memberships, tournament rewards, creator economies, and secondary markets.

Utility

What teams can build

  • Player inventories, item issuance, and collection launches.
  • Reward distribution, royalties, auctions, and gated experiences.
  • Guild or community layers tied to ownership and identity.
Why

Why Lichen fits

  • Frequent player interactions need fees that stay operationally small.
  • Ownership, payments, and identity share one wallet experience.
  • Privacy and public settlement can coexist depending on the game flow.
How

How it lands on-chain

  • Use NFT, marketplace, and auction contracts for asset lifecycle management.
  • Route rewards and royalties through the same payment rails as the app.
  • Connect storefronts, game services, and wallets through shared APIs.
Protocol surfaces
LichenPunks LichenMarket LichenAuction Shielded Pool Wallet
Typical deployments
Player inventories Creator drops Membership passes Tournament rewards
Services

Service networks with discovery, delivery, and settlement attached.

Turn provider identity, quoting, task routing, deliverables, and payout into one auditable lifecycle for human teams, software services, and mixed operating models.

Best for

Provider directories, AI service desks, expert networks, ops vendors, and research marketplaces.

Utility

What teams can build

  • Service catalogs and provider profiles with public reputational context.
  • Quoted work, milestones, or subscriptions with programmable payout logic.
  • Deliverable-based flows that keep artifacts linked to completion state.
Why

Why Lichen fits

  • Identity, attestations, and money live on the same protocol surface.
  • Deliverables can remain referenceable instead of disappearing inside app silos.
  • Every step from request to payout can stay machine-readable and auditable.
How

How it lands on-chain

  • Use LichenID for discovery and identity-bound trust signals.
  • Route work through task, marketplace, or contract-based logic.
  • Attach storage or compute outputs to completion and payout events.
Protocol surfaces
LichenID BountyBoard SporePay Storage refs Wallet Connect
Typical deployments
AI service desks Expert networks Ops vendors Research marketplaces
Storage

Storage and compute coordination with settlement built in.

Keep commitments, provider matching, reusable artifacts, and execution payouts inside the same economic system used by the applications or agents consuming the results.

Best for

Agent memory, content pipelines, report vaults, replicated archives, and inference jobs.

Utility

What teams can build

  • Persistent references for documents, datasets, model outputs, and reports.
  • Provider payment flows for replicated storage or off-chain execution.
  • Reusable artifact libraries that later applications or agents can consume.
Why

Why Lichen fits

  • Data coordination and money stay on the same rail instead of separate platforms.
  • Artifacts receive verifiable references rather than opaque app-only storage.
  • Storage and compute become composable inputs for users, apps, and agents.
How

How it lands on-chain

  • Moss Storage manages commitments and provider-side retention flows.
  • Compute Market coordinates requester and provider matching.
  • Applications subscribe to events, verify references, and settle provider payouts.
Protocol surfaces
Moss Storage Compute Market WebSocket Explorer SDKs
Typical deployments
Agent memory Report archives Inference jobs Content pipelines

Agents as First-Class Economic Actors

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.

What this changes

Agents become first-class economic actors.

They can hold identities, build reputation, receive payments, publish outputs, and coordinate with other agents or users inside the same settlement environment.

Discoverable Identity

Register skills, endpoints, metadata, attestations, and human-readable names so other agents and apps can reason about who is doing the work.

Verifiable Settlement

Stream funds, escrow payouts, bridge assets, or settle instantly without leaving the chain context that the workflow already uses.

Stored Work Products

Reports, artifacts, models, and results can be referenced by storage commitments and reused by downstream agents or client applications.

Public or Private Flows

Keep actions public when composability matters, or shift value through shielded flows when confidentiality is part of the job.

agent-runbook.json
{
  "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"
  ]
}

Trading & Research

Agents watch markets, buy data, publish signals, and settle subscriptions or performance fees automatically.

Service Marketplaces

Autonomous vendors can quote, complete tasks, store deliverables, and receive streamed or escrowed payouts.

Autonomous Ops

Infrastructure bots can buy compute, checkpoint outputs, and coordinate cross-team workflows with on-chain accountability.

Why the Stack Holds Together

Agent workflows and user-facing applications share the same economics, security model, and tooling, instead of being split across incompatible systems.

Agents Can Run Continuously

High-frequency software cannot tolerate human-priced fees. Lichen is tuned for sustained transaction volume, predictable operating cost, and machine-speed settlement.

Cryptography Starts at the Account Layer

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.

Programs, Money, and Data Share One Surface

WASM contracts, EVM-compatible flows, storage commitments, and payment rails all settle on the same asset layer and account model.

Operators Can Join Without Capital Theater

Validators can start through a bootstrap path instead of a six-figure gate, so the network can grow around contribution, uptime, and real operations.

Architecture & Specifications

Every number comes from running code. Every spec is auditable in the source.

Consensus

Algorithm BFT + Proof of Contribution
Finality 400ms (single slot)
BFT Threshold ⅔ supermajority
Epoch 432,000 slots (~2 days)
Min Validator Stake 75,000 LICN

Execution

Smart Contracts WASM + EVM dual VM
WASM Runtime Wasmer AOT
EVM Compat REVM (EIP-1559 + 4844 envelope)
Max Tx per Block 10,000
Max Block Size 10 MB

Performance

Tx Processing ~35,000 tx/s (single-thread)
ML-DSA-65 Verify ~10,000 /s
Block (500 tx) ~15ms
Block Propagation 95% in <200ms
Source Criterion benchmarks

How We Compare

Ethereum

TX Cost$2–50
TPS15–30
Finality12–15 min
Deploy Cost$100+
Validator Stake32 ETH ($100K+)

Solana

TX Cost$0.00025
TPS65,000
Finality~400ms
Deploy Cost$5
Validator Stake$50K+ capital

Tokenomics

500 million LICN at genesis. Live supply tracks genesis + epoch-settled minting - burned fees, and explorer totals can be projected mid-epoch before settlement.

Supply & Denomination

Genesis Supply 500,000,000 LICN
Live Supply Genesis + settled epoch minting - burned fees
Smallest Unit 1 spore = 10⁻⁹ LICN
Inflation 4% initial, decaying 15%/yr to 0.15% floor
Deflation Mechanism 40% of all fees burned
Base Reward Signal ~0.254 LICN/slot projected (Year 0), settles each epoch

Genesis Distribution

Community Treasury 25% — 125M LICN
Builder Grants 35% — 175M LICN
Validator Rewards Reserve 10% — 50M LICN
Founding Symbionts 10% — 50M LICN
Ecosystem Partnerships 10% — 50M LICN
Reserve Pool 10% — 50M LICN

Fee Structure

Base Transfer 0.001 LICN ($0.0001)
Contract Deploy $2.50
NFT Mint 0.5 LICN ($0.05)
40% Burned Permanent deflation
Remaining 30% Producer · 10% Voters · 10% Treasury · 10% Community

Reputation Fee Discounts

500+
Reputation
5% off
750+
Reputation
7.5% off
1000+
Reputation
10% off

LichenID — Agent Identity Layer

On-chain identity, reputation, and trust for autonomous agents. Not an app — a protocol primitive.

Universal Identity

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 points

Reputation System

Earn 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 inactivity

.lichen Naming

Register 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.

Register · Resolve · Transfer · Renew

Vouching & Attestations

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 types

Privacy Layer

Shielded 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 & Security

Dual Addressing

Every 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 compatible

Bootstrap Validator Program

The 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.

Day 0 — Bootstrap

Start on commodity hardware with a network bootstrap allocation instead of a capital gate.

Capital Required $0
Bootstrap Grant 100,000 LICN
Hardware 4 cores · 4 GB RAM
Launch Path cargo build --release

Epochs 1+ — Bootstrap Recovery

As uptime holds above threshold, the grant is recovered from rewards while operators keep a liquid share from the start.

Liquid Share 25% rewards
Grant Recovery 75% rewards
Base Reward Signal ~0.254 LICN/slot projected
Required Uptime 95%+

Production Protocol Surface

Identity, liquidity, payments, privacy, marketplaces, bridge assets, and developer-facing infrastructure are already part of the live stack.

LICN

Native coin. Transfer, stake, pay fees. No contract needed — built into the protocol.

5.2 KB WASM

LichenSwap

AMM DEX with constant-product liquidity pools, 0.3% swap fees, reentrancy protection.

5.4 KB WASM

ThallLend

P2P lending: deposit collateral, borrow assets, earn interest, automated liquidations.

12 KB WASM

SporePump

Token launchpad with bonding curves. Fair-launch tokens graduate to LichenSwap at market cap threshold.

16.5 KB WASM

SporePay

Sablier-style streaming payments. Create time-windowed streams with proportional withdrawals.

17 KB WASM

SporeVault

Yield aggregator: auto-compounding across DeFi protocols. 10% performance fee, 2% management fee.

17 KB WASM

LichenID

Agent identity, reputation, .lichen naming, vouching, skill attestations, achievements.

43 KB WASM · 30+ functions

LichenDAO

On-chain governance with token-weighted voting, 3 proposal tiers, treasury management.

18.5 KB WASM

LichenPunks

MT-721 NFT standard reference. Full ownership, transfers, metadata.

8.9 KB WASM

LichenMarket

NFT marketplace with listings, purchases, and cross-contract composability.

8.5 KB WASM

LichenAuction

English auctions, offers/bids, creator royalties, collection stats.

35.5 KB WASM

LichenOracle

Decentralized price feeds, verifiable random function (VRF), attestation services.

16.4 KB WASM

LichenBridge

Cross-chain bridge with lock-and-mint pattern, multi-validator confirmation.

16.2 KB WASM

BountyBoard

On-chain task management. Post bounties with rewards/deadlines, submit proof, approve and pay.

16.0 KB WASM

Compute Market

Decentralized compute marketplace. Providers offer resources, requesters submit jobs.

16.9 KB WASM

Moss Storage

Decentralized storage layer. Register storage requests, providers confirm and earn rewards. Up to 10× replication.

14.7 KB WASM

Shielded Pool

Privacy-preserving transactions using transparent STARK proofs with Poseidon2 commitments. Deposit, withdraw, and transfer shielded assets.

18.2 KB WASM

DEX Core

Central Limit Order Book with price-time matching, self-trade prevention, and multi-pair settlement.

820 lines · 41 tests

DEX AMM

Concentrated liquidity AMM (Uni V3-style). 4 fee tiers, Q32.32 math, tick-range positions.

720 lines · 35 tests

DEX Router

Smart order routing across CLOB, AMM, and legacy LichenSwap. Multi-hop and split routes.

520 lines · 27 tests

DEX Governance

Pair listing & fee governance via proposals and token-weighted voting. 66% approval, 48h periods.

450 lines · 18 tests

DEX Rewards

Trading rewards, LP mining, and referral program. 4 tiers (Bronze→Diamond), fee mining.

450 lines · 19 tests

DEX Margin

Margin trading up to 5× leverage. Isolated/cross margin, liquidation engine, insurance fund.

550 lines · 30 tests

DEX Analytics

On-chain OHLCV candles (6 intervals), 24h rolling stats, trader leaderboards.

450 lines · 16 tests

Prediction Market

Binary outcome markets. Create markets, place bets, oracle resolution, automated payouts.

21.5 KB WASM

lUSD Stablecoin

Treasury-backed stablecoin. Mint, burn, with reserve attestation and circuit breaker protection.

23.5 KB WASM

Wrapped ETH

Wrapped ETH bridge token. Epoch rate-limited minting with reserve attestation.

23.5 KB WASM

Wrapped SOL

Wrapped SOL bridge token. Epoch rate-limited minting with reserve attestation.

23.5 KB WASM

Wrapped BNB

Wrapped BNB bridge token. Epoch rate-limited minting with reserve attestation.

23.5 KB WASM

Deploy Your First Contract

From zero to deployed in 5 steps. Write in Rust, compile to WASM, call via JSON-RPC.

Step 1: Install CLI

terminal
# 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

Step 2: Create Your Identity

terminal
# 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

Step 3: Write a Contract (Rust → WASM)

contracts/counter/src/lib.rs
#![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; }
}

Step 4: Build & Deploy

terminal
# 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!

Step 5: Call via JSON-RPC

JavaScript
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 }

JSON-RPC 2.0 API

Complete API — account queries, block data, transactions, chain metrics.

Account Operations

getBalance (pubkey: string)
Response
{ "spores": 100000000000, "licn": 100.0 }
getAccount (pubkey: string)

Returns full account: pubkey, evm_address, balance, owner, executable, data_len.

Roadmap

Building a post-quantum network for agents, commerce, and payments, one lichen at a time.

Phase 1: Live Foundation

BFT Consensus Engine
LichenVM (WASM + EVM)
LichenID Identity System
Mainnet + Testnet Live
Shielded Pool + STARK Privacy Live
27+ Smart Contracts, Wallet, Explorer, DEX, Marketplace, Programs, Dev Portal
Solana, Ethereum, and BNB Wrapped Asset Support

Phase 3: The Swarming

Larger Validator Set and Deeper Geographic Distribution
Mature Cross-Chain Liquidity and Asset Routing Beyond Initial Bridge Rails
Advanced Privacy, Identity, and Agent Coordination Tooling
Full-Stack Agent Economy Across DeFi, Payments, Compute, and Marketplaces
Global Ecosystem Scale With Institutional-Grade Reliability

Ready to Ship on Lichen?

Launch an agent workflow, market, payment rail, or contract in minutes on infrastructure built for machine-speed coordination.