Introduction

Ashen is a high-performance blockchain built on Commonware primitives, featuring single-slot finality, RISC-V smart contract execution, and built-in MEV protection through encrypted transactions.

Tip

Ashen is testnet ready. All core infrastructure is complete and battle-tested.

Why Ashen?

True Finality

Transactions finalize in ~1 second. No confirmations to wait for, no reorgs to fear. When a block commits, it’s final.

MEV Protection

Sealed transactions use threshold encryption. Your trades can’t be frontrun because validators can’t see them until execution.

Paid Reads (x402)

Protocol-native micropayments for RPC calls. Validators earn from the reads they serve. No more free-riding on infrastructure.

Agent-Native

Designed for AI agents to read, write, and interact. Deterministic execution, structured APIs, and metered access make automation first-class.

Write in Zig

Smart contracts compile to RISC-V. Write in Zig with a full SDK: safe math, events, storage helpers, and reentrancy guards.

Light Client Native

Cryptographic proofs for everything. Verify state without trusting anyone. Data availability sampling gives 99.99% confidence with 30 samples.

---

Core Features

Single-Slot Finality

Ashen uses Simplex consensus with BLS12-381 threshold signatures. A block is final when 2f+1 validators sign—no probabilistic confirmation, no waiting.

• ~1 second block time
• Deterministic finality — committed blocks never revert
• Threshold BLS signatures — no single validator can finalize alone

RISC-V Execution

Smart contracts run on a deterministic RV64 virtual machine:

• ISA: RV64IMC + Zba/Zbb (no floating point)
• Tiered execution: Interpreter → JIT → AOT compilation
• Hot code tracking: Frequently-called contracts get compiled to native
• Cross-contract calls: Synchronous with automatic rollback on failure

Sealed Transactions (Private Mempool)

Threshold Identity-Based Encryption (TIBE) protects your transactions:

1. You encrypt your transaction to the validator set’s collective public key
2. It enters the mempool encrypted—validators can’t read it
3. At block time, validators collaborate to decrypt (threshold decryption)
4. FIFO ordering prevents content-based reordering

No frontrunning. No sandwich attacks. Your transaction executes as submitted.

Data Availability Sampling

Light clients don’t need to download full blocks:

• Reed-Solomon erasure coding (64-of-128 shards)
• 30 random samples → 99.99% confidence data is available
• Commitment in headers — data_availability_root proves block data

Paid Reads (x402)

Validators subsidize the entire ecosystem while capturing only write fees. Ashen fixes this with protocol-native metered reads:

Read Type	Why It’s Paid	Cache Resistance
Tx Simulation	Pre-trade safety checks	Depends on mempool + caller state
State Proofs	Trustless verification	Must be current to be useful
Account Nonces	Transaction construction	Changes with each write
Pending Mempool	Execution ordering	Updates every block

How it works:

1. Client requests a read (balance, simulation, proof)
2. Node meters compute + bytes + egress
3. Payment settles via x402 + stablecoin or sponsored credits
4. Revenue flows to the serving validator

Freshness is the product. Stale cache can be free; current data is paid.

DKG Key Resharing

Threshold BLS keys rotate every epoch via Distributed Key Generation:

• Per-epoch key rotation — fresh keys limit exposure window
• Resharing protocol — new keys derived from previous epoch (forward secrecy)
• Automatic fallback — continues with previous keys if DKG fails (max 1 epoch)
• BLS12-381 TIBE — threshold encryption for sealed transactions

No single validator ever holds the full private key. Decryption requires threshold cooperation.

Agent-Native Design

Ashen is built for a future where agents write most code:

• Deterministic VM — no contract-visible nondeterminism (no FP, no timers)
• Structured APIs — IDL-driven interfaces with type-safe codegen
• Metered access — per-call pricing, no subscriptions or commitments
• Simulation-first — agents can test transactions before submitting
• Proof-backed reads — agents can verify without trusting RPCs

The contract model is simple enough for AI to generate correctly. The pricing model is transparent enough for agents to budget.

---

Developer Experience

Zig SDK

The Ashen SDK provides everything for Zig contract development:

const sdk = @import("ashen-sdk");

export fn _start(calldata_ptr: [*]const u8, calldata_len: usize) sdk.ByteSlice {
    sdk.heap.reset();
    // Your contract logic
    return sdk.ByteSlice.from(result);
}

Modules: storage, context, crypto, events, math, guards

Rust SDK

The Rust SDK provides low-level control for contracts:

use contract_sdk::{Host, Address};

// Storage
let value = Host::storage_read(key)?;
Host::storage_write(key, &data)?;

// Context
let caller = Host::caller();
let block = Host::block_number();

Features: Host API, storage collections, ABI helpers

IDL Codegen

Generate type-safe bindings from IDL:

cargo run -p idl-abi-gen -- \
  --idl contracts/mycontract/mycontract.idl \
  --out-dir contracts/mycontract/src \
  --zig-stubs --rust-contract

Tools

Tool	Purpose
TUI	Interactive terminal for contract calls, tx history, block explorer
Wallet Extension	Browser extension for signing and account management
RPC	Full JSON-RPC API with simulation, proofs, and subscriptions

---

DeFi Infrastructure

Ashen ships with production-ready DeFi contracts:

AMM & DEX

Constant-product AMM pools, concentrated liquidity, stableswap curves, and a DEX router for optimal routing.

Lending

Lending markets with collateralization, liquidations, and interest rate models.

Staking & Rewards

Stake pools with delegation, reward gauges for liquidity mining.

Vaults

ERC-4626 style vaults with pluggable strategies for yield optimization.

Available Contracts

Category	Contracts
Trading	amm_pool_v1, concentrated_liquidity_v1, stable_swap_v1, order_book_v1, dex_router_v1
Lending	lending_market_v1
Staking	stake_pool_v1, reward_gauge_v1
Vaults	vault_v1, vault_strategy_v1
Tokens	sft_v1 (semi-fungible token)
Governance	timelock_governor_v1
Utilities	fee_sponsor_v1, price_oracle_v1

---

Cross-Chain & Oracles

Bridge Integrations

Axelar GMP

General Message Passing for cross-chain contract calls.

Hyperlane

Interchain Security Modules for verified message passing.

Wormhole

Guardian-verified cross-chain messaging.

Oracle Integrations

Oracle	Contract	Use Case
Pyth	pyth_oracle_v1	High-frequency price feeds
Chainlink	chainlink_ocr2_v1	OCR2 aggregated feeds
Redstone	redstone_oracle_v1	On-demand price data

---

Fee Sponsorship

The fee_sponsor_v1 contract enables gasless transactions:

• Sponsors deposit funds and set policies
• Users submit transactions without holding native tokens
• Contracts can sponsor their own users

Perfect for onboarding new users or subsidizing specific actions.

---

Proofs-First Architecture

Every piece of state is provable:

• Blake3 BMT commitments — hierarchical Merkle trees per account
• Membership proofs — prove a key exists with its value
• Exclusion proofs — prove a key does NOT exist (predecessor/successor)
• Finalized history MMR — Merkle Mountain Range over all finalized blocks
• State proofs RPC — request proofs for any storage slot

Light clients can verify anything without trusting the RPC.

---

Quick Links

Quickstart Get a local node running in minutes

Installation Build from source

Architecture System design deep-dive

Ashen SDK Write your first contract