Ref Node Live| VIEW RUST CORE ON GITHUB →
INTRODUCTION
CHAIN
RESOURCES
INNOVATION
CONNECT

Sahyadri Protocol Reference

Formal questions about the protocol, the mathematics, and the money.

General

Who created Sahyadri?

Sahyadri was founded and originally developed by Suraj Datir in 2026 as an open, sovereign Layer-1 protocol. The protocol is open source, and its mathematics and implementation are publicly verifiable. Suraj Datir is the founder and original creator of Sahyadri. This founding role is independent of protocol ownership or control. There is no founder token allocation, foundation reserve, or privileged upgrade authority. Network participants independently validate the protocol rules, and no individual can unilaterally change them.

Who controls the Sahyadri network?

No single entity. Control is distributed across every node that validates blocks and every miner that produces them. There is no admin key, no governance committee, no emergency mint, no validator whitelist. A block is valid if and only if it satisfies the transition function evaluated by every honest node:

σn+1 = δ(σn, Bn)   where   δ : Σ × 𝔅 → Σ

If a block violates δ, it is rejected. There is no override. There is no "governance vote" that can make an invalid block valid. The state transition is a pure function of public data.

What are the advantages of Sahyadri?

Three structural properties. First, post-quantum signaturesfrom genesis — every transaction is signed with ML-DSA (Dilithium), a NIST-standardized lattice scheme whose security rests on the Module-Learning- With-Errors problem, which no known quantum algorithm solves in polynomial time. Second, deterministic finality — the ordering of blocks is a function of the DAG, not of a voting round, so two honest nodes with the same view compute the same canonical history bit-for-bit. Third, fixed monetary supply — the 21M cap is a theorem of the emission series, not a policy that can be revised.

Why do people trust Sahyadri?

Because trust is replaced by verification. Every transaction is signed and publicly checkable. Every state is committed to a Merkle root that any node can recompute. Every rule is expressed as an equation. There is nothing to trust in an operator — a user only needs to trust that the mathematics they run locally produces the same result as the mathematics every other node runs. This is a fundamentally different kind of trust: grounded in reproducibility, not in reputation.

What happens if Sahyadri's founder disappears?

Nothing. The protocol is a mathematical object, not a company. The nodes on the network do not query the founder for anything — they validate blocks according to rules that were fixed at genesis. The emission function, the ordering algorithm, the state transition function — all of them run on every node independently. There is no server to take down, no domain to expire, no team to disband. This is the point of writing a protocol rather than running a service.

Architecture

What is SahyadriDAG?

SahyadriDAG is the ledger structure: a directed acyclic graph where each block references multiple parents. Unlike a linear chain, where a block has exactly one parent and competing blocks are orphaned, the DAG absorbs every valid block. The set of blocks V and the ancestor relation ≺ form a partial order:

𝒢 = (V, ≺h)   where   bi ≺h bj ⟺ bi is a hash-ancestor of bj

Acyclicity follows from the hash function — a block cannot reference a future block that references it. Because every valid block enters the graph, hash power spent on parallel blocks is never discarded.

What is Ashwa Consensus?

Ashwa Consensus is the ordering layer. Given the DAG, it produces a unique total order that every honest node computes identically. Two blocks at the same depth are ordered by cumulative proof-of-work weight; ties are broken by hash. Formally, for blocks bi and bj:

bi ≺ord bj   ⟺   depth(bi) < depth(bj)   ∨   (depth(bi) = depth(bj) ∧ W(bi) > W(bj))

Where W(b) is cumulative work. There is no voting, no proposer lottery, no committee. Consensus has no members — only mathematics. This is why Ashwa is deterministic rather than probabilistic in its ordering.

What is cumulative work?

Cumulative work is the sum of the difficulty of every block in a block's ancestor set. It is defined recursively over the DAG:

W(b) = d(b) + Σp ∈ parents(b) W(p)

Where d(b) is the block's own difficulty. Because the DAG is acyclic, this recurrence is well-defined and finite. Cumulative work is the metric by which finality is measured — a block becomes final when its cumulative work exceeds what any plausible adversary could produce.

What is the Account + Crest model?

State is split into two orthogonal domains, both committed to the same Merkle root. The Account layer handles monetary balances; the Crest layer handles structured objects like DIDs and credentials:

σ = σAccount ⊕ σCrest   where   σAccount : Addr → ℕ   and   σCrest : Hash → Object

Account transitions are atomic: a transfer debits one balance and credits another in a single deterministic step. Crest transitions are ownership changes: a credential is a signed claim bound to a public key, and its owner is defined by a cryptographic relation rather than a database entry.

How is state committed?

State is committed via a Sparse Merkle Tree. The root of this tree is a single 32-byte value that fully determines the state — two nodes are in consensus if and only if their roots are equal:

Root(σ) = SMTPoseidon2( σAccount ∪ σCrest )

Poseidon2 over the Goldilocks field is used for internal SMT hashing because its algebraic structure makes Merkle proofs verifiable within a recursive proof system at low constraint cost. SHA3-256 is used for content hashing (transaction IDs, object identifiers). The split is deliberate: internal hashing needs to be provable; content hashing needs to be collision-resistant.

What stops a chain reorganization?

Economics. A reorg at depth k requires an adversary to produce more cumulative work than the honest network has produced since that block. If the adversary controls a fraction α of hash power and the honest network controls β = 1 − α, the probability of a successful reorg at depth k decays geometrically:

Pr[reorg(k)] ≤ (α / β)k,   α < β

Every additional block multiplies the adversary's required work while dividing their probability of success. A few confirmations make a reorg economically irrational; a few dozen make it physically implausible.

Transactions

How is a transaction signed and validated?

Every transaction is signed with the sender's private key using ML-DSA (Dilithium) over the SHA3-256 of the transaction payload. Validation checks that the signature is valid under the public key that controls the sender's balance:

Transfer(a → b, amt) is valid   ⟺   Verify(pka, σa, tx) = ⊤   ∧   bal[a] ≥ amt + fee

There is no other condition. No nonce, no sequence number, no external registry of accounts. The transaction is valid if the signature is valid and the balance is sufficient. The state transition function δ enforces both atomically — a block that would leave the state in an inconsistent state is rejected before any change is applied.

What is a FlashTransaction?

A FlashTransaction is the native transaction format. It is nonce-less — no replay counter — because replay protection is provided by the salt field and the expiry bound. Its fields include the sender pubkey, recipient, amount, fee, expiry DAA score, a 16-byte random salt, and the signature. The payload is encoded as:

FLASH_V1 ‖ version ‖ pubkey ‖ recipient ‖ amount ‖ fee ‖ expiry ‖ salt ‖ signature

Replay is prevented because each FlashTransaction carries a unique salt. A transaction with a repeated salt and identical fields would produce an identical transaction ID, which is rejected as duplicate. There is no need for a nonce because the salt provides uniqueness and the expiry bounds the time-window in which the transaction is valid.

Why do I have to wait for confirmation?

Confirmation is not a fixed wait — it is accumulated proof-of-work behind a transaction. Each confirmation adds one block's worth of difficulty to the ancestors that would need to be rewritten. Because the probability of a successful rewrite decays geometrically in depth, a single confirmation already reduces the risk to negligible levels for typical adversaries, and a handful of confirmations reduces it to cryptographic irrelevance.

Risk(k) = Pr[reorg(k)] ≈ (α / β)k

How much is the transaction fee?

Fees are small and fixed. There is no auction, no priority fee market, no block-space bidding war. The base fee is expressed in the smallest CSM unit (one kana, 10−8 CSM) and serves two purposes: to prevent transaction spam and to compensate miners for the work of validating and including the transaction. The fee is deterministic — the same transaction submitted at any time costs the same fee.

What is CSM?

CSM is the native currency of Sahyadri. Its supply is fixed at exactly 21,000,000 by the emission function — not by policy, vote, or foundation reserve. It is divisible to 10−8 CSM (one kana). CSM has three roles: it pays transaction fees, it rewards miners, and it is the unit of account for on-chain value transfers.

Why is the supply capped at 21 million?

Because the emission function is a geometric series with a finite sum. The reward halves every 4 years, so the total emitted converges:

Σh=0∞ R0 · 2−⌊h/H⌋ = 21,000,000 CSM

Where H is the halving height. The sum is a mathematical identity — it does not depend on any human decision, only on the parameters R0 and H that were fixed at genesis. Even if every miner colluded and every node operator agreed, they could not mint a 21,000,001st CSM without breaking the state transition function that every honest node evaluates.

Mining

What is SahyadriX?

SahyadriX is the Proof-of-Work hash function. It is memory-hard: every nonce attempt requires a 16 MB working set, so mining cost is dominated by memory bandwidth rather than raw arithmetic throughput. The design is a deliberate trade-off: it makes specialized hardware (ASICs) expensive because each unit would need 16 MB of fast on-chip SRAM per hash pipeline, while commodity CPUs already have large caches and RAM that fit the working set comfortably.

How does the SahyadriX hash work — step by step?

Three sequential stages. First, a BLAKE3 chain fills a 16 MB buffer: 524,288 iterations of BLAKE3, each hashing the previous output. Second, 1,024 rounds of data-dependent random-access mixing fold the buffer into a 32-byte state, where the read address in each round is derived from the current state. Third, a Poseidon2 permutation over the Goldilocks field compresses the final state into the difficulty-checked output. Formally:

pow(n) = Poseidon212( MemLoop1024( B3Chain524288( pre_pow ‖ t ‖ n ) ) )

Where pre_pow is the block header with nonce and timestamp zeroed, t is the timestamp, and n is the nonce being searched. The resulting 32-byte value is compared against the target.

Why BLAKE3 for the memory loop?

Speed and preimage resistance. BLAKE3 is roughly 3–5× faster than SHA3-256 on the same hardware, which matters when the loop runs 524,288 iterations per nonce attempt. Its 256-bit output gives about 128-bit preimage resistance under Grover's algorithm, matching the quantum profile of SHA3-256. The memory loop does not need algebraic structure — it needs to be fast and cryptographically sound. BLAKE3 is both.

Why Poseidon2 at the end?

Verifiability. BLAKE3 is expensive to prove inside a recursive proof system — roughly 30,000 constraints per hash. Poseidon2 over the Goldilocks field has about 300 constraints per permutation. The final Poseidon2 stage makes the PoW output bound to a value that can be verified by a compact recursive proof, without proving every BLAKE3 iteration. This is why the two primitives are combined: BLAKE3 for computational depth, Poseidon2 for verifiable binding.

Why does the miner run 1,024 rounds but consensus runs 256?

The two implementations serve different roles. The miner searches — it runs the heavy loop to raise the cost of producing a valid block. The validator verifies — it runs a lighter loop to confirm the miner's output without spending a full mining round on every block it processes. Both loops converge because the Poseidon2 final binding is identical in both cases; the intermediate rounds are an optimization of search cost, not of final value.

A useful consequence: a node does not need 16 MB of memory to verify a block. Verification cost is bounded by the reference loop, not by the miner's heavier search. This is why light clients can participate in PoW verification without the memory requirements of a miner.

How is difficulty adjusted?

Difficulty is updated based on observed block times in a moving window. The adjustment is a closed-loop controller — if blocks are arriving too fast, difficulty increases; if too slow, it decreases:

dn+1 = dn · ⌊ Ttarget / Tobserved ⌋

Where Ttarget is the protocol target block interval. The network converges to this interval regardless of how much hash power joins or leaves. There is no committee setting difficulty — there is an equation.

What is the expected block time?

Block discovery is a Poisson process. The expected time to find a valid block is inversely proportional to the network's total hash rate:

E[tblock] = 2κ / (H · D)

Where κ is the hash space size, H the network hash rate, and D the difficulty. Because discovery is memoryless, blocks can arrive in clusters or long gaps — the target interval is a mean, not a guarantee. This is a property of any PoW network, not a defect of Sahyadri.

What do I need to start mining?

A CPU with several cores and enough RAM to hold 16 MB per mining thread. The reference miner runs on commodity hardware — no GPU, no ASIC, no specialized rig required. You point the miner at a Sahyadri node, provide a payout address, and start. For testnet, difficulty is low enough that a laptop can participate; for mainnet, the difficulty adjusts to make mining economically competitive with the network's total hash rate.

Security

Is Sahyadri secure?

Security is a quantitative bound, not a boolean. The probability that an adversary controlling a fraction α of hash power can reverse a block at depth k is bounded by:

Advreorg(α, k) ≤ (α / (1 − α))k

This bound decays geometrically with depth. For α = 0.30 and k = 6, the probability is about 10−4. For k = 12, it is about 10−8. The bound assumes only that the hash function is collision-resistant and that a majority of hash power follows the protocol.

Is Sahyadri vulnerable to quantum computers?

No, by design. Every signature on Sahyadri is a ML-DSA (Dilithium) signature, a NIST-standardized post-quantum scheme. Its security rests on the hardness of Module-Learning-With-Errors (MLWE), a lattice problem for which no classical or quantum algorithm is known to run in polynomial time. The forgery probability under a quantum adversary is bounded by the MLWE advantage:

∀ AQ : Pr[AQ forges σ] ≤ AdvMLWE(λ) + negl(λ)

This bound applies from the first block to the last. Sahyadri is post-quantum from genesis, not as a later upgrade.

What happens if a quantum computer appears tomorrow?

Nothing changes for Sahyadri. Every signature the network has ever accepted was already quantum-resistant. There is no migration event, no hybrid transition, no emergency upgrade. The protocol made the assumption that the quantum threat is real from genesis — so the day a quantum computer breaks ECDSA has no effect on this network. Users do not need to do anything. Their keys and balances remain valid and secure.

What about a 51% attack?

A 51% attack is not a protocol failure — it is an economic assumption. No PoW network is secure against an adversary who controls the majority of hash power, because the protocol's guarantee is "majority-honest" by construction. What Sahyadri adds on top is cost: a 51% attack requires acquiring enough hardware to out-hash the rest of the network, which for a mature network becomes prohibitively expensive. The attack is possible in theory; it is economically irrational in practice, because the value destroyed by the attack typically exceeds the value gained.

The deeper answer: no majority-honest PoW system — Bitcoin included — can claim to be secure against a rational adversary with more hash power than the rest of the network. What changes is the cost of acquiring that power, and the marginal benefit of attacking. Sahyadri makes the first high and the second low by construction.

What stops transaction censorship?

Economics. A miner can refuse to include a particular transaction in their own block, but they cannot prevent other miners from including it — and on a permissionless network, other miners will include it because fees are their incentive. Censorship is not a technical possibility; it is an economic trade-off that miners almost never have a rational reason to make, because they would be forgoing fee revenue in favor of a political preference they can achieve more cheaply through other means.

Has Sahyadri been audited?

The protocol has been public and reviewable from the beginning. Formal external audits of the consensus code and cryptographic primitives are part of the roadmap before mainnet. The mathematics — post-quantum signatures, fixed supply, deterministic ordering — is designed to prevent entire classes of bugs that plague centralized systems. But no claim of absolute infallibility is made. The code is open. Audit it yourself, or commission an audit. That is the point of an open protocol.

Help

Where can I read the full protocol?

The whitepaper formalizes the state transition function, the emission series, the ordering algorithm, and the security arguments. Every claim in the whitepaper corresponds to code that runs the network. Read the whitepaper for the mathematics; read the source for the implementation. When the two disagree — which they should not — the source is ground truth, because the source is what runs.

How can I run a node?

The reference implementation runs on Linux, macOS, and Windows. Download the binary, provide a data directory, and start the node. It will sync with the network, validate every block according to the same transition function that every other node runs, and expose RPC endpoints for wallets and other clients. No permission is required. Running a node is not a privileged role — it is how you verify the network without trusting anyone else's verification.

How can I contribute?

The source is open. Bug reports, mathematical reviews, protocol analysis, and code improvements are all welcome. This is not a company that owns the protocol — there is nothing to join, only something to build on. Contributions matter because the protocol is only as strong as the scrutiny it receives. If you find a flaw in the mathematics or a bug in the implementation, reporting it is the single most valuable thing you can do.

How do I verify the protocol myself?

Three independent verification paths. First, run a node — it validates every block against the transition function. Second, check the Merkle root of any state — anyone can verify that a balance or object exists in state by checking a Merkle path against the root. Third, verify the PoW of any block against the declared target — this does not require trusting the node that gave you the block. Independent verification is the entire purpose of a permissionless protocol.