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.

PropertyConsensus-nativeProof-native
What establishes validityMajority agreementA cryptographic proof
Full node verificationRe-executes every blockRe-executes (defensive)
Light client verificationTrusts a header chain + PoWVerifies a proof
Trust assumptionHonest majorityHash function + field
Verification cost per blockO(block size)O(1) amortized
Chain-length dependenceReplay from genesisConstant

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)

Light Clients
A phone holds one header and one chain proof. Every account balance it displays is verified against a state proof derived from that chain proof. No node, no explorer, no intermediary.
Cross-Chain Bridges
A bridge contract on another chain verifies a Sahyadri state transition by checking a chain proof. Trust is reduced to a hash function and a proof system. No multi-sig committee.
Solvency Audits
A custodian publishes a chain proof and inclusion proofs for customer balances. Any customer verifies their balance independently. The audit is a cryptographic check, not a PDF report.
Cross-Chain Coordination
Two proof-native chains can verify each other's state. Each side checks a proof from the other side. No oracle, no committee, no trust assumption between the two networks.

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

MetricMeasured valueTest scale
Block proof size631-735 KBN = 2..8 signatures
Block proof verify35 msConstant in N
Chain proof size~200 KB4444 leaves
Chain proof verify1.5 ms4444 leaves
Chain proof build603 s4444 leaves, 16-core CPU
State proof size~2 KB typical< 64 depth
State proof verify< 1 msAny depth
Continuous chain depth39+ blocks, zero breaksLive 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.