Developers • Integration & Verification Contract

Build on verifiable PoS data

NeuroPoS publishes deterministic, range-scoped proof bundles: reproducible derivations, Merkle commitments, signed trust metadata, and optional on-chain anchoring — so you can verify integrity without trusting a single API.

Verifier contract Deterministic outputs Optional anchoring
Quick links
Jump into live verification or read the security model.
Open Verify Open Explorer Security
Note: APIs are transport. The authoritative layer is the proof bundle: recompute → compare → validate signatures → optionally validate on-chain anchoring.
What you can build
Typical integrations for protocol teams, infra providers, explorers, auditors, and dashboards.
  • Independent verification of finalized epoch/range data (no single RPC trust).
  • Recompute Merkle roots and checkpoint hashes locally for audit-ready integrity checks.
  • Verify publisher signatures using a versioned trust store (KID-only, rotation-safe).
  • Optional on-chain anchoring verification (timestamp + immutability check).
  • Range-scoped “signals with evidence” (neutral by default; no public shaming).
Verifier contract
Any implementation that follows this contract should produce the same result on any machine. 
Given:
  - finalized inputs (epoch / range)
  - published bundle + blobs (content-addressed)
  - trust_store.json (versioned)
  - optional on-chain anchoring
  
  A verifier MUST:
  1) Fetch artifacts by hash
  2) Canonically serialize metadata
  3) Recompute Merkle roots
  4) Recompute checkpoint_hash
  5) Verify publisher signatures against trust store
  6) (Optional) Verify anchoring hashes on-chain
  
  Result:
  - VERIFIED
  - MISMATCH
  - REQUIRES_REVIEW
Determinism requires stable ordering, fixed-point rules where applicable, and canonical bytes prior to hashing.
API surface (transport)
Minimal endpoints used by UI and third-party verifiers. Exact names may evolve; the verification contract remains stable. 
# epochs / ranges
  GET /epochs/latest
  GET /epochs/{epoch_id}
  GET /ranges/{epoch_id}/blocks?only_anomalies=1&offset=0&limit=200
  
  # integrity / commitments
  GET /integrity/{epoch_id}?provenance=summary
  GET /verify/commitments?range={rangeId}    # (Verify Spec v1: step 2)
  
  # anchoring (optional)
  GET /anchors/{epoch_id}
  
  # trust & blobs
  GET /trust_store.json
  GET /manifest/anchor_manifest.json
  GET /blobs/{sha256}
Transport rule: You can mirror blobs and still verify. If the API is unavailable, verification remains possible using content-addressed artifacts + trust store + on-chain anchoring (if used).
Determinism & canonicalization
NeuroPoS is engineered to be reproducible. “Same finalized inputs → same outputs”.
Canonical bytes
Structured objects are serialized canonically before hashing (stable field order + encoding).
Fixed-point rules
Where numeric scoring exists, it is fixed-point and bounded; UI does not compute proprietary formulas.
Deterministic ordering
Leaves and records have stable ordering to avoid “same meaning, different bits” mismatches.
Range-scoped semantics
All claims are tied to an epoch/range. No global verdicts. No name-and-shame outputs by default.
What NeuroPoS is NOT
Clear boundaries reduce ambiguity and make integrations safer.
  • Not a slashing engine or punishment system.
  • Not a real-time monitoring product (range-scoped finalized evidence only).
  • Not a public leaderboard of “bad validators”.
  • Not an oracle of intent — only verifiable evidence and integrity signals.
Want an integration path?
If you need new networks, deeper archival access, or private deployments — contact us with scope and required evidence fields.
Contact
Copied