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.

Why “Ashen”?

The name works on three levels.

.sh is the interface. The canonical entrypoint is ashen.sh — a domain and a mental model. Agents don’t read landing pages. They discover through shell, pay for what they need, and move on. The name encodes the distribution strategy: shell-first, agent-first.

Burn away the unnecessary. Current blockchain economics are a decaying system where validators subsidize everyone else. Ashen is what rises from those broken incentives — stripped of buzzwords, proxy patterns, and abstractions that exist to raise valuations. The name matches the ethos: burn the complexity theater, keep what works.

The Ashen One keeps going. In Dark Souls, the Ashen One rises from nothing and pushes forward against a world that’s falling apart. We’re building against the same kind of decay — extractive economics, audit-tax complexity, infrastructure parasitism. The name is a nod to persistence in the face of broken systems.

Key Features

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:

You encrypt your transaction to the validator set’s collective public key
It enters the mempool encrypted—validators can’t read it
At block time, validators collaborate to decrypt (threshold decryption)
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:

Client requests a read (balance, simulation, proof)
Node meters compute + bytes + egress
Payment settles via x402 + stablecoin or sponsored credits
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

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

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

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