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 valid

Chain-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 work

Cumulative 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

ComponentStatusMeasured
Real Plonky3 FRI fold validationImplemented427/427 relations (100%)
Real leaves pipelineImplemented~19 ms/leaf, ~200 KB proof
4444-leaf tree → rootMeasured~350 KB root, 603 s (16-core)
Chain continuityLive on testnet39+ blocks, 0 breaks
Chain proof verifyMeasured1.5 ms (constant)
ML-DSA-65 signaturesDeployed at genesis~3309 B sig size
SMT state proofsWorking<2 KB typical, <1 ms verify
Full adversarial soundness (Path A)Not implementedPath B soundness only
Public testnetLocal onlySeed nodes not deployed
Mainnet launchNot startedAudit 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

LayerImplementationRationale
LanguageRustMemory safety + zero-cost abstractions
ConsensusPoW-DAG (Ashwa)No orphans, no committee, no stake requirement
PoWSahyadriX (BLAKE3 + 16 MB MemLoop + Poseidon2)Memory-hard + proof-friendly final binding
SignaturesML-DSA-65NIST PQC standard, lattice-based
Proof systemBinary-field STARKsTransparent, post-quantum-secure
Proof frameworkPlonky3AIR abstraction + FRI-based commitment
State commitmentSparse Merkle Tree (Poseidon2)Constant-depth proofs, cheap STARK constraints
StorageRocksDB + content-addressed SMT nodesFast concurrent access, immutable
Light clientWASM verifierBrowser-verifiable, <15 MB footprint
IdentityDID + Verifiable Credentials + DWNsSelf-sovereign, anchored on-chain
InterfacesgRPC · JSON-RPC · WebSocketStandard developer interfaces
SDKJavaScript / TypeScriptBrowser + Node.js native

11. Comparison

PropertySahyadriBitcoinEthereum
FinalityDeterministic (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 verify1.5 ms (constant)N/AN/A
Signature schemeML-DSA-65 (post-quantum)ECDSA (classical)ECDSA (classical)
State modelAccount + CrestUTXOAccount
ConsensusPoW-DAG (no orphans)PoW chain (orphans)PoS (probabilistic)
Supply21M (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.