Proof-Native
What it means for a chain to carry its own cryptographic evidence of correctness, and why the resulting verification cost is O(1) regardless of chain length.
1. Definition
A proof-native blockchain uses cryptographic proofs and commitments to make independently verifiable claims about block execution and chain history. In Sahyadri, consensus validates blocks and their deterministic state transitions, while dedicated proof workers asynchronously generate signature-attestation proofs after block acceptance. Chain aggregation links proof commitments so that a compact result can be verified without replaying the entire history.
Definition 1.1 (Proof-native architecture)
Sahyadri combines:
(a) Consensus validation of blocks and Proof-of-Work
(b) Native verification of transaction signatures
(c) Deterministic state-transition execution
(d) Asynchronous STARK generation for signature attestations
(e) Chain commitments linking successive proof outputs
Proof workers generate batch proofs after block acceptance.
Chain aggregation binds successive proof commitments.
Current Path B aggregation does not recursively verify the
complete contents of every underlying batch proof.
Definition 1.2 (Trust reduction)
Consensus validity:
Determined by the protocol's PoW-DAG consensus rules.
State validity:
Determined by deterministic execution and account commitments.
Proof verification:
Determined by the configured proof system and its
cryptographic assumptions.
These are distinct verification layers; a chain commitment
must not be confused with a proof of every underlying statement.2. Consensus-Native vs Proof-Native
Both types of chain use cryptography. The distinction is what the cryptography attests to and what the user must trust to accept a block.
| Property | Consensus-native | Proof-native |
|---|---|---|
| What establishes validity | Majority agreement | A cryptographic proof |
| Full node verification | Re-executes every block | Re-executes (defensive) |
| Light client verification | Trusts a header chain + PoW | Verifies a proof |
| Trust assumption | Honest majority | Hash function + field |
| Verification cost per block | O(block size) | O(1) amortized |
| Chain-length dependence | Replay from genesis | Constant |
Proof-native does not mean trustless in the absolute sense. It means the trust set is reduced to cryptographic primitives that are well understood and easy to state. Consensus-native requires the additional assumption that a majority of some set behaves honestly — a sociopolitical assumption rather than a mathematical one.
3. The O(1) Property
O(1) verification means that verifying an available aggregated chain result does not require work proportional to the number of blocks it covers. Proof construction and aggregation are separate operations and can be substantially more expensive. Proof size is reported separately and may grow with aggregation structure and parameters.
Definition 3.1 (O(1) chain verification)
Verification is O(1) with respect to chain length if:
T_verify(π_n) = O(1)
where n is the number of blocks or commitments covered,
under fixed proof parameters and verification configuration.
Proof construction and aggregation are not O(1).
Comparison:
Naive blockchain:
Verify: O(n) — replay every block
PoW header chain:
Verify: O(n) — check every header's PoW
Aggregated chain result:
Verify: O(1) with respect to covered chain length
Build: depends on aggregation work and implementation
Size: depends on the aggregation structure
The measured 4444-leaf result demonstrates constant-time
verification at the tested scale. It does not imply constant-time
proof generation or aggregation.4. Sahyadri's Construction
Sahyadri uses two stages to produce an aggregated chain result. First, proof workers generate batch STARK proofs for signature attestations after block acceptance. Second, chain aggregation links successive proof commitments. The current Path B construction provides compact commitment verification; it does not yet recursively prove the full validity of every underlying batch proof.
Stage 1: Signature batch proof (per block)
Batch-STARK proof attests to:
(a) The configured ML-DSA-65 signature-verification statements
Generated asynchronously by proof workers after block acceptance.
Measured: 631-735 KB for N = 2..8 signatures
35 ms verification time in the tested configuration
Stage 2: Chain commitment aggregation
C_n = Hash(
C_(n-1),
hash(batch_proof(B_n))
)
The aggregation result links the previous commitment
to the current block's batch-proof hash.
Current Path B:
Binds public values and commitments.
Does not recursively verify the full batch-proof contents.
Measured aggregated result:
~200 KB at 4444 leaves
1.5 ms verification in the tested configuration
Combined:
The aggregated result can be checked without replaying
all 4444 leaves. Its commitment structure must not be
interpreted as recursive verification of every batch proof.The key structural choice is that current Path B aggregation does not recursively prove the content of each batch proof. It links successive chain commitments and binds each block's batch-proof hash into that commitment structure. This provides a compact result whose verification does not require replaying all covered leaves. It must not be interpreted as a recursive proof that every underlying batch STARK is valid.
5. What O(1) Enables
O(1) verification is not just a technical curiosity. It changes what categories of users can independently verify the network's state.
Without compact verification:
A client may need to process a long sequence of headers,
blocks, or historical data.
With aggregated verification:
A client can:
- Verify an available chain-aggregation result
(~200 KB, 1.5 ms at the measured 4444-leaf scale)
- Verify an account inclusion or exclusion proof
(~2 KB typical, < 1 ms) against a trusted account_commitment
These are separate verification operations.
The chain commitment does not replace the account state proof.
Verification can run on phones, browsers, and embedded devices.6. Applications of O(1)
7. What O(1) Does Not Solve
O(1) verification is a strong property, but it does not solve every problem. Stated plainly:
Not solved by O(1):
1. Privacy.
A chain proof attests to correctness, not to confidentiality.
State values are public. Zero-knowledge variants exist and could
be added later, but they are not part of the current design.
2. Full adversarial soundness.
Current Path B aggregation binds public values and proof
commitments but does not recursively verify the full
validity of every child batch proof. Full adversarial
soundness requires the stronger Path A construction.
This limitation is documented in proof-aggregation.
3. Historical state queries.
O(1) verification tells you the chain is valid. It does not
answer "what was balance X at block Y." For historical state,
a state proof against the historical block's root is needed —
which may require an archive node to serve.
4. Chain reorgs.
A reorg invalidates the chain proof from the reorg point forward.
The chain proof must be rebuilt from that point. Reorg depth is
typically small (< 5 blocks), so the rebuild is bounded.
5. Proving cost.
Generating the chain proof is expensive: 603 s at 4444 blocks
on a 16-core consumer CPU. This is a background process, not
part of block production.8. Measured Numbers
| Metric | Measured value | Test scale |
|---|---|---|
| Block proof size | 631-735 KB | N = 2..8 signatures |
| Block proof verify | 35 ms | Constant in N |
| Chain proof size | ~200 KB | 4444 leaves |
| Chain proof verify | 1.5 ms | 4444 leaves |
| Chain proof build | 603 s | 4444 leaves, 16-core CPU |
| State proof size | ~2 KB typical | < 64 depth |
| State proof verify | < 1 ms | Any depth |
| Continuous chain depth | 39+ blocks, zero breaks | Live testnet |
9. Summary
Sahyadri combines deterministic consensus validation, account-state commitments, asynchronous signature-attestation proofs, and chain commitment aggregation. Its measured chain-aggregation result at 4444 leaves is approximately 200 KB and verifies in 1.5 ms under the tested configuration. This demonstrates O(1) verification with respect to the covered chain length, while proof construction and aggregation remain computationally expensive. Current Path B aggregation binds commitments and does not recursively verify every underlying batch proof.
The property is not a marketing claim. It is a measurable consequence of the protocol's design. A chain of 4444 blocks produces a proof whose size and verification time are the same as a chain of 39 blocks. This is what makes light clients, bridges, and audits run on devices that their users actually own.
O(1) does not solve privacy, adversarial soundness, or historical queries. It solves one specific problem: verifying the state of an unbounded chain in bounded time. That single problem is what separates a chain whose security relies on trust from one whose security relies on verification.