Clearcompass
GitHub org Get started
Open source · open governance

Don't trust us. Run it yourself.

Every part of Clearcompass that matters — the SDK, the ledger, the monitoring tools, and the domain networks built on top — is open source. Anyone can re-derive the timeline, hold operators accountable, or stand up a parallel deployment.

The entire stack is written in Go, spread across six public repositories.

Architecture

How the pieces fit together.

Three core repos, one protocol. The SDK signs records and submits them to the ledger. The tools let anyone verify what the ledger publishes, run an auditor, or stand up a notary. Domain networks — like our judicial-network reference — sit on top and define what a "record" means in their world. New domains (deeds, licenses, supply chain, agent credentials) plug in the same way.

SDK
attesta

Sign records · build receipts · re-verify offline

LEDGER
ledger

Append-only timeline · notary protocol · checkpoints

TOOLS
attesta-tools

CLI · auditor · notary daemon

REFERENCE NETWORK
judicial-network

A worked demo. Fork as a template for deeds, licenses, credentials, supply chain, agent authority.

core protocol client & tooling reference / demo
The core repositories

The protocol is strictly modular.

Whether you’re building an application, running a node, or auditing the network, the core cryptographic engine is contained within these three repositories.

live from github
SDK
clearcompass-ai/attesta

The signing & verification library.

The library a sender uses to sign a record before it leaves their hands, package it for submission, and later re-verify the receipt offline. Pure cryptographic primitives — no network calls required to check a proof.

What's inside
  • · Six signature families: ECDSA (secp256k1), Ed25519, EIP-191, EIP-712, EIP-1271 (smart-contract wallets), Iden3 ZK
  • · K-of-N notary aggregate signatures (ECDSA + BLS12-381)
  • · Receipt, Merkle, and Sparse-Merkle-Tree proofs (RFC 6962)
  • · Offline re-verification against any published snapshot
  • · Submission client (HTTPS, idempotent)
LEDGER
clearcompass-ai/ledger

The append-only sequencer.

A high-throughput log that stamps signed records into a permanent order. Witness nodes (acting as decentralized notaries) co-sign each checkpoint, and snapshots are written to public, read-only object storage.

What’s inside
  • · Powered by Tessera — the open-source successor to Trillian (the engine behind Certificate Transparency).
  • · Opaque payloads: the ledger never inspects what records mean — it verifies the envelope and signatures, then treats payloads as opaque bytes.
  • · RFC 6962 Merkle tree + Sparse Merkle Tree state engine for O(1) state proofs.
  • · Witness K-of-N co-signing protocol.
protocol
WATCHDOGS & TOOLS
clearcompass-ai/attesta-tools

Auditors, daemons & verifier libraries.

Reference implementations of everyone who isn’t the sequencer. Run your own independent monitor that downloads public snapshots and re-runs the math, or join the notary panel.

What’s inside
  • · Independent auditor daemons that catch equivocation and emit fraud proofs.
  • · Witness co-signing daemons (services/witness) to run your own notary node.
  • · libs/clitools — a verifier library you can import to programmatically check proof files in seconds.
Reference implementation

One working network. Fork it for yours.

The core protocol above is entirely domain-agnostic. To turn it into a working system, you need a schema for what a “record” actually means in your world. We built a fully working reference network to demonstrate exactly how.

DOMAIN DEMO
clearcompass-ai/judicial-network

A working template for domain builders.

A worked example of how to build a domain-specific application on top of Attesta. While this specific repo defines schemas for courts, you’re meant to fork it as a template for your own industry — real estate, supply chain, autonomous agents.

What’s inside
  • · Record schemas (admissions, rulings, delegations).
  • · Jurisdiction registry & appellate-authority vocabulary.
  • · Cross-jurisdiction authority resolution.
  • · Zero-knowledge selective-disclosure proofs (in active development — cryptographic redaction is incredibly hard to get right, and we’re almost there).
Fork it as the starting point for
real-estate deeds supply chain insurance credentials agent authority
Developer quickstart

Verify a proof in three lines of code.

You don’t need an account, an API key, or a CLI tool to trust the network. Import the verifier library, point it at a proof file, and let the math speak for itself.

go libs/clitools 
import "github.com/clearcompass-ai/attesta-tools/libs/clitools"

// Verify any receipt — entirely offline, against the genesis witness keys.
result, err := clitools.VerifyProof("./proof.json", genesisWitnessKeys)

// ✓ genuine: TreeSize 4,812,019 · RootHash 0x8b3ad11e…c2ee
//            co-signed by K-of-N witnesses
Read the docs →
Start with the SDK attesta/README.md.
Run a monitor →
Hold the operator accountable.
Become a witness →
Run a notary daemon (services/witness).

Contribute, audit, or fork.
The protocol belongs to everyone.