Skip to main content

The Proof Chain

The domains are registered in batch. Each batch waiting timeout is ~10 minutes. Every batch produces one proof. These proofs form a chain of state transitions from genesis:

genesis_root (empty tree -- known constant)
  |  +-- "richard.pivx" registered at block 100,
  |  +-- "john.pivx" registered at block 110,
  |  ... (could be more registration/update commands)
  |  ! Proof 1 is generated
  |  old_root = genesis_root --> new_root_1
  |  +-- "richard.pivx" put his name on marketplace at block 200,
  |  +-- "sam.pivx" registered at block 250,
  |  ... (could be more registration/update commands)
  |  ! Proof 2 is generated
  |  old_root = new_root_1 --> new_root_2 (= current root)

Each proof's old_root must equal the previous proof's new_root. The first proof's old_root must equal the known genesis root (an empty Sparse Merkle Tree).

Verifying the Chain​

A verifier checks the entire registration history in five steps:

  1. Get the SP1 verification key -- deterministically derived from the guest program binary
  2. Fetch all proofs from the API
  3. Verify each SP1 proof using the verification key
  4. Check the chain -- genesis == P1.old_root, P1.new_root == P2.old_root, ..., PN.new_root == current_root
  5. Spot-check on-chain -- look up any committed txid on a PIVX node and confirm the memo, value, and block match

If all checks pass, the entire registration history is correct -- no trust in the indexer needed.

Proof Pipeline​

The scanner and prover run independently:

PIVX Blockchain
       |
   PiNS Registrar Scanner  (validates, captures SMT state)
       |
    Database               (status: "pending")
       |
   SP1 Prover              (generates ZK proof, verifies it)
       |
    Database               (status: "proved")
       |
   New checkpoint published
       |
   Indexer syncs to the checkpoint   
       |
   API Server   (GET /v1.0/resolve/{name})

The scanner never blocks on proof generation. The prover daemon polls for pending records and can run on separate hardware.