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

Build on Determinism

A protocol that behaves the same way at every node is a protocol you can build a business on. Sahyadri exposes a minimal, deterministic surface — every query has one answer, every transaction has two outcomes, every proof is checkable. No gas surprises. No governance overrides. No admin keys. The rules are fixed at genesis and enforced by every full node.

01 · The RPC Surface

Four Primitives, Nothing Else

The protocol exposes four operations, each with a fixed, checkable contract. Every operation is deterministic — given the same inputs, every node produces the same outputs. There are no "best-effort" results, no "eventual consistency," no "pending" states.

submit(tx)

Submit a signed FlashTransaction to a node’s mempool. The result is binary: accepted or rejected.

result ∈ { accept, reject }
query(block, key)

Query the state at a given block. Returns a value plus an SMT proof against the block’s state root.

query(B, k) → (v, π_SMT)
verify(π, root)

Verify any proof — inclusion, execution, or recursive — against a known root.

verify(π, root) → { ⊤, ⊥ }
finalize(B)

Check whether a block has accumulated enough weight to be considered final.

finalize(B) ⟺ W(B) ≥ W_threshold
02 · Determinism

Same Inputs, Same Output

Two nodes that see the same set of blocks compute the same state. This is not an aspiration — it is a consequence of the state transition function being a pure function of public data. If they disagree, one of them is wrong, and the disagreement is detectable in a single bit.

viewA = viewB ⟹ stateA = stateB

The practical consequence for developers: a query against any synced node returns a result you can depend on. There is no "approximate" or "delayed" answer. If a node lags, it returns an older block — but it will never return a wrong value for a block it has accepted. This is what makes financial applications possible on top of the protocol.

Why This Matters

In most systems, "eventual consistency" means a client must wait before trusting a value. In Sahyadri, "finality" is not a delay — it is a threshold. Once the threshold is crossed, the value is mathematically irreversible. Clients that need certainty check finality; clients that need speed accept the current view and re-check later. Both behaviors are correct, because both operate on the same underlying state.

03 · Proof-Verified Queries

Query Without Trusting the Node

A query to an untrusted node returns two things: a value and a proof. The client verifies the proof against a state root it already trusts. If the proof fails, the client rejects the response — no matter what the node claims. This turns every query into a cryptographic check.

Verify( leaf, path, root ) = ⊤ ⟹ value is authentic

The Merkle path has a fixed length of 256 hashes (the SMT depth), regardless of how many accounts or objects exist in the state. A client that verifies one value spends a bounded amount of computation — independent of whether the network holds a thousand accounts or a hundred million.

path_length = depth(SMT) = 256   (constant)

For higher assurance, a client can request a recursive proof alongside the Merkle path. The recursive proof attests that the state root itself was produced by a valid chain of blocks — which means the client does not need to have synced the chain to trust the root. This is how a light client with no chain state can verify the current balance of an account.

πn = Prove[ Verify(πn−1) = ⊤ ∧ valid(Bn) = ⊤ ]
04 · Node Modes

Three Trade-offs, One Protocol

Not every application needs to run a full node. The protocol defines three modes that trade storage for trust. Each mode verifies the same protocol rules — they differ only in how much of the chain they hold andwhich proofs they accept.

Full Node

Holds full state, verifies every block

trust(full) = 0

Pruned Node

Holds recent state, verifies recent blocks

trust(pruned) = 0 | recent

Light Client

Holds no state, verifies proofs only

trust(light) = 0 | proof-verified

The key property: no mode requires trusting any other node. A full node re-executes every transition. A pruned node verifies every block in its window. A light client verifies every proof it accepts. The trade-off is always storage vs. verification cost, never trust vs. no trust.

If behavior is not specified by the protocol, it does not exist. Build systems that rely on rules \u2014 not trust.
\u2014 Sahyadri
06 · Support Development

No Treasury. No Foundation. Direct Support Only.

Sahyadri has no founder allocation, no foundation reserve, and no governance-controlled treasury. Developers who want to support the protocol can do so by contributing code, running nodes, mining, or sending CSM directly to the development address below. Every contribution goes to infrastructure, tooling, and protocol work.

Development Address
csm1srvjuzlmmve4wnartusgwgw3x7lt2ra9ayq6mjm53vh5z70qkvjczggq0hpwx

Contributions are voluntary and confer no governance rights, no protocol control, and no claim on the network.

Organization
Sahyadri
Repository
github.com/sahyadri-core
Community
Discord
Protocol
sahyadri.io
Contact
sahyadricore@gmail.com
Social
@SahyadriCore
If behavior is not specified by the protocol, it does not exist. Build systems that rely on rules — not trust.
— Sahyadri