Introduction to Sahyadri
A binary-field, proof-native, post-quantum Layer-1 protocol. Defined formally. Measured empirically. Verified cryptographically.
1. Formal Definition
Sahyadri is a deterministic state transition system with a cryptographic proof attached to every state change. Formally, the protocol is a tuple:
𝕊 = (Σ, Β, δ, Π, Prove, Verify)
where:
Σ = state space (account balances + Crest objects)
Β = block space (headers, transactions, DAG references)
δ : Σ × Β → Σ (deterministic state transition)
Π = proof space (binary-field STARKs)
Prove : (Σ × Β × Σ) → Π (proof generation)
Verify : (Σ × Β × Σ × Π) → {⊤, ⊥} (proof verification)The protocol makes exactly three claims about this tuple. Each claim is falsifiable — either by running the code or by reading the mathematics.
Claim 1 · O(1) Chain Verification
There exists a proof πn such that for any chain length n, |πn| = O(log N) bounded and Tverify(πn) = O(1). Verification cost is independent of chain length.
Claim 2 · Post-Quantum Security
Every signature accepted by the network is ML-DSA-65. Forgery probability for any classical or quantum adversary is bounded by MLWE hardness — from block 1, not after a migration event.
Claim 3 · Deterministic Ordering
Given identical DAG views, every honest node computes identical canonical orderings. The order is a pure function of the graph — no voting, no committee, no proposer lottery.
2. State Transition Function
Every block advances the state by one deterministic step:
σ_{n+1} = δ(σ_n, B_n)
where:
σ_n ∈ Σ (full state at height n)
B_n ∈ Β (block n)
δ : Σ × Β → Σ (pure function — no clock, no external input)State has two orthogonal layers, both committed to one Merkle root:
σ = σ_Account ⊕ σ_Crest σ_Account : Address → ℕ (monetary balances) σ_Crest : Hash → Object (identity, credentials, structured data) Block header commits: Root(σ) = SMT_Poseidon2( σ_Account ∪ σ_Crest ) SMT depth = 256 levels Proof path = 256 hashes (independent of account count) Typical proof size = < 2 KB Worst case = ~8.2 KB
δ is a pure function: identical (σn, Bn) produces identical σn+1 on every honest node. This is not probabilistic — δ contains no oracle, no clock, no external input, and no source of randomness.
3. Proof-Native Architecture
A consensus-native chain asks users to trust that validators agreed on a block. A proof-native chain asks users to verify a proof that the block is valid. The difference is the trust set:
Consensus-native:
trust(block) ≤ trust(majority of validators)
Proof-native:
trust(block) = trust(Verify(π, σ_parent, σ_child) = ⊤)
= trust(hash function) + trust(field arithmetic)Every block Bn is validated through consensus and deterministic state-transition checks. After block acceptance, proof workers asynchronously generate signature-attestation proofs and update the chain-proof commitment:
π_n = Prove[ Verify(π_{n-1}) = ⊤ ∧ valid(B_n) = ⊤ ]
valid(B_n) checks:
- PoW satisfies target
- All signatures verify under ML-DSA-65
- State transition σ_{n-1} → σ_n is correct
- All included transactions satisfy mempool + state rules
Verify(π_n) = ⊤ ⟺ block n is valid AND all ancestors are validChain-proof aggregation links successive block-proof commitments. In the current Path B implementation, aggregation binds the previous chain-proof commitment to the current block's batch-proof hash; it does not yet recursively establish the full validity of every child STARK proof. Proof generation and aggregation run asynchronously after block acceptance. Fully sound single-root recursion (Path A) remains in progress.
4. PoW-DAG Consensus (Ashwa)
The ledger is not a chain — it is a directed acyclic graph. Every valid block enters; none are discarded as orphans.
𝒢 = (V, ≺_h)
V = { B : valid(B) = ⊤ } (valid blocks — monotonically grows)
≺_h = hash-ancestor relation (transitive, acyclic by hash function)
|V| grows over time. No valid block is ever removed from V.Canonical ordering is a deterministic function of the DAG (Ashwa Consensus):
Order: 𝒢 → 𝒮 (total order over V)
For blocks b_i, b_j ∈ V:
b_i ≺_ord b_j ⟺ depth(b_i) < depth(b_j)
∨ ( depth(b_i) = depth(b_j) ∧ W(b_i) > W(b_j) )
where:
depth(b) = longest path length from genesis to b
W(b) = cumulative workCumulative work is defined recursively over the DAG:
W(b) = d(b) + Σ_{p ∈ parents(b)} W(p)
d(b) = block b's own difficulty
parents(b) = set of blocks b references (typically 1-10)
Because ≺_h is acyclic, W(b) is finite and well-defined.
As more blocks reference b, more ancestors are counted, W(b) monotonically grows.Two honest nodes with the same DAG view compute identical orderings bit-for-bit. This is what makes Ashwa's finality deterministic — no competing order can exist for nodes that share a view.
Finality condition. A block is final when its cumulative work exceeds what any plausible adversary could produce from a fork:
final(b) ⟺ W(b) > W_adversary / ε ε = protocol safety margin Finality is a threshold — crossed once, deterministic thereafter. Reorg probability decays geometrically with depth: Pr[reorg(k)] ≤ (α/β)^k, α < β
5. Proof-of-Work Algorithm (SahyadriX)
Mining is the search for a nonce satisfying the PoW target. The hash function is a three-stage memory-hard construction:
pow(header, n) = Poseidon2_12( MemLoop_1024( B3Chain_524288( pre_pow ‖ t ‖ n ) ) ) where: pre_pow = block header with nonce=0, timestamp=0 (domain-separated) t = timestamp (u64) n = nonce (u64) B3Chain = BLAKE3 applied 524,288×, filling 16 MB buffer MemLoop = 1,024 rounds of data-dependent memory reads (16 MB working set) Poseidon2_12 = Poseidon2 over Goldilocks field, width 12 Acceptance: pow(header, n) ≤ target ⟺ block is valid
Each stage solves a distinct problem:
- BLAKE3 chain — computational depth. 524,288 iterations per attempt means ~16 MB of memory access. Fast on CPUs, awkward on ASICs (ASICs prefer tight arithmetic loops over memory-bound workloads).
- Memory loop — memory hardness. The 16 MB working set makes ASICs expensive: each hash pipeline would need 16 MB of on-chip SRAM. A commodity CPU with L3 cache has this for free.
- Poseidon2 final binding — verifiable binding. The final permutation has ~300 constraints in a STARK, versus ~30,000 for BLAKE3. This is what makes the PoW output verifiable inside a proof system at low cost.
Why this matters for recursion. Without Poseidon2 final binding, proving the PoW inside a recursive STARK would require proving 524,288 BLAKE3 iterations in-circuit — roughly 15 million constraints per block. With Poseidon2 as the last stage, only the final permutation must be proven — roughly 300 constraints. This is the difference between "recursive PoW proof takes 30 minutes" and "30 milliseconds."
6. Recursive Aggregation and O(1)
A single proof per block would still grow linearly if stored per-block. O(1) requires aggregating proofs recursively.
Aggregation takes two proofs and produces one that attests to both:
Aggregate: Π × Π → Π Aggregate(π_a, π_b) = π_c Verify(π_c) = ⊤ ⟺ Verify(π_a) = ⊤ ∧ Verify(π_b) = ⊤
Applied as a binary tree, N proofs are aggregated in ⌈log₂ N⌉ rounds:
Measured batch-stark aggregation (Core Ultra 5, 18 threads): N = 2 → 626 KB, 8.4 s, 35 ms verify N = 4 → 710 KB, 44.6 s, 35 ms verify N = 8 → 735 KB, 31.0 s, 35 ms verify N → ∞ → ~750 KB asymptote, 35 ms verify Verification time: constant across N. Proof size: sub-linear, asymptotes near 750 KB.
Applied at the chain level, this yields the O(1) chain proof:
Block 1: π_1 (proves B_1 valid given genesis)
Block 2: π_2 = Aggregate(π_1, proof(δ(σ_1, B_2) = σ_2))
Block 3: π_3 = Aggregate(π_2, proof(δ(σ_2, B_3) = σ_3))
...
Block n: π_n = Aggregate(π_{n-1}, proof(δ(σ_{n-1}, B_n) = σ_n))
After n blocks:
|π_n| = O(log N) (proof size bounded, sublinear in chain length n)
T_verify(π_n) = O(1) (verification time independent of n)
A phone verifying π_n does the same work as verifying π_5.
Chain length can be 5 blocks or 5 billion; verification is identical.7. Post-Quantum Signatures
Every transaction is signed with ML-DSA-65 (CRYSTALS-Dilithium3), a NIST-standardized post-quantum scheme. Security rests on MLWE hardness:
∀ A (classical or quantum adversary): Pr[A forges σ] ≤ Adv_MLWE(λ) + negl(λ) λ = security parameter (128 for ML-DSA-65) Adv_MLWE(λ) = advantage in solving Module-Learning-With-Errors No known classical or quantum algorithm solves MLWE in polynomial time.
Engineering consequences:
- No elliptic curves anywhere in the trust path (no ECDSA, no EdDSA)
- No hybrid transition period — post-quantum from block 1
- No "quantum migration" event ever needed — the assumption was made at genesis
- Signature size ~3309 B (larger than ECDSA's 72 B — the cost of future-proofing)
At 10,000 TPS, this is ~33 MB/s of signature data. Sahyadri handles it via AVX2 SIMD verification and Rayon parallel verification, achieving throughput that matches ECDSA at 1/10th the future-assumption risk.
8. Light Client Verification
A light client stores only block headers and verifies state using SMT proofs. It does not hold the full state, does not replay the chain, and does not trust any RPC provider.
Light client state: Header chain (finalized window): ~10 MB/year Recent proofs (working set): <1 MB SMT verification library: <100 KB Total: <15 MB Verification flow: 1. Client holds verified header H_n (via PoW + chain proof) 2. Extracts account_commitment C_n from H_n 3. Requests SMT proof P for (address, balance) against C_n 4. Client computes: root' = walk(P, key_bits, leaf) 5. Accept ⟺ root' == C_n ∧ leaf.key == address Cost: ~256 hashes, <1 ms on any device Trust: 0 — client trusts only its own header verification
The light client's trust set is exactly one thing: the block header it has verified. Everything else — every balance it displays, every payment it authorizes — is a cryptographic consequence of that header.
9. Measured Status
| Component | Status | Measured |
|---|---|---|
| Real Plonky3 FRI fold validation | Implemented | 427/427 relations (100%) |
| Real leaves pipeline | Implemented | ~19 ms/leaf, ~200 KB proof |
| 4444-leaf tree → root | Measured | ~350 KB root, 603 s (16-core) |
| Chain continuity | Live on testnet | 39+ blocks, 0 breaks |
| Chain proof verify | Measured | 1.5 ms (constant) |
| ML-DSA-65 signatures | Deployed at genesis | ~3309 B sig size |
| SMT state proofs | Working | <2 KB typical, <1 ms verify |
| Full adversarial soundness (Path A) | Not implemented | Path B soundness only |
| Public testnet | Local only | Seed nodes not deployed |
| Mainnet launch | Not started | Audit pending |
What is real, is real. What is missing, is listed plainly. No extrapolation is presented as measurement; no measurement is claimed as more than it is.
10. Technology Stack
| Layer | Implementation | Rationale |
|---|---|---|
| Language | Rust | Memory safety + zero-cost abstractions |
| Consensus | PoW-DAG (Ashwa) | No orphans, no committee, no stake requirement |
| PoW | SahyadriX (BLAKE3 + 16 MB MemLoop + Poseidon2) | Memory-hard + proof-friendly final binding |
| Signatures | ML-DSA-65 | NIST PQC standard, lattice-based |
| Proof system | Binary-field STARKs | Transparent, post-quantum-secure |
| Proof framework | Plonky3 | AIR abstraction + FRI-based commitment |
| State commitment | Sparse Merkle Tree (Poseidon2) | Constant-depth proofs, cheap STARK constraints |
| Storage | RocksDB + content-addressed SMT nodes | Fast concurrent access, immutable |
| Light client | WASM verifier | Browser-verifiable, <15 MB footprint |
| Identity | DID + Verifiable Credentials + DWNs | Self-sovereign, anchored on-chain |
| Interfaces | gRPC · JSON-RPC · WebSocket | Standard developer interfaces |
| SDK | JavaScript / TypeScript | Browser + Node.js native |
11. Comparison
| Property | Sahyadri | Bitcoin | Ethereum |
|---|---|---|---|
| Finality | Deterministic (threshold) | Probabilistic (6 blocks) | Probabilistic (~12 blocks) |
| Chain proof size | ~200 KB (O(log N) bounded) | N/A (full chain required) | N/A (full state required) |
| Chain proof verify | 1.5 ms (constant) | N/A | N/A |
| Signature scheme | ML-DSA-65 (post-quantum) | ECDSA (classical) | ECDSA (classical) |
| State model | Account + Crest | UTXO | Account |
| Consensus | PoW-DAG (no orphans) | PoW chain (orphans) | PoS (probabilistic) |
| Supply | 21M (asymptotic series) | 21M (asymptotic series) | Unlimited |
Sahyadri is not "Bitcoin but faster" or "Ethereum but cheaper." It is a different design that starts from a different axiom: verification cost should be constant. Every other property — PoW-DAG, post-quantum signatures, account model — follows from that starting point.
12. Reading Paths
The documentation is organized into five sections. Different readers need different paths:
Verifiers
Read: Consensus → State Proofs → Light Client. Focus on mathematical guarantees and how to verify them yourself.
Builders
Read: Account Model → Flash Transaction → SMT. Focus on integration points and state verification primitives.
Researchers
Read: Proof Aggregation → Plonky3 → STARK → SahyadriX. Focus on cryptographic reductions and open problems.
Identity Developers
Read: DID → Crest Model → Verifiable Credentials. Focus on the Web5 identity layer and its on-chain anchoring.
Node Operators
Read: Sync-Wave → Light Client → Audit. Focus on operational aspects, bootstrap mechanisms, and security posture.