substrate v1.0 · apache-2.0 · sole attester ready

The substrate for
signed claims

Anima Provenance is a content-addressed substrate where any party can stamp a claim with their own key — and anyone in the world can verify it, offline, in milliseconds. EIP-712 typed data, Merkle records root, Bitcoin-anchored timestamps. We record who signed what under which methodology. We never assert what is true.

// substrate envelope · GET /v1/verify/<claim-id>
{
  "claim_id": "0b14a7c2…e9c3",
  "substrate_address": "19e7…ff2a",
  "records_root": "7c1f…02d8",
  "attestations": [{ "attester": "1563…5508",
    "methodology": "news.fact-check.v2" }],
  "ots_proofs": [],
  "verdict": "matches"
}
1ms
Go verify p50
< 12kb
browser verifier · gzip
2
crypto primitives · frozen
0
trust in substrate operator
01 · how it works

Stamp. Verify. Replay.

Three primitives. The same four-step verification works in Go, TypeScript, the browser, and a static CLI — byte-identical results.

1 · Stamp

An attester signs a claim with their own secp256k1 key, declares which methodology they followed, and posts it. The substrate anchors the bundle, OTS-timestamps it on Bitcoin, and returns a 32-byte claim_id.

EIP-712 · attester-owned key

2 · Verify

Any reader fetches the envelope, re-derives the digest, recomputes the records root, recovers every attester address. Free, deterministic, runs anywhere. Output is tri-state: matches / drifted / unverifiable.

4 steps · < 4ms in browser

3 · Replay

Every record is content-addressed, every digest is byte-reproducible. Forks of the substrate produce identical claim IDs. The verifier doesn't trust us — it trusts the math.

apache-2.0 · forkable
02 · drop-in verifiers

Three runtimes,
one cryptographic answer

Every verifier is byte-parity tested against the Go reference. Pick the one that fits your stack.

embed · < 1kb

HTML badge

Drop a single web component next to the claim. Renders state (signed / witnessed / finalized) and links to a public proof page.

<!-- public claim badge -->
<anima-claim
  id="0b14…e9c3"
  substrate="https://substrate.anima.dev"
></anima-claim>
npm · < 12kb

TypeScript / browser

Pure-JS twin of the Go primitives. No WASM, no native module. Node ≥ 18 and any modern browser. ESM only.

// @anima/provenance-verify
import { verifyEnvelopeSig,
  verifyRecordsRoot } from
  "@anima/provenance-verify";
verifyEnvelopeSig(env); // throws on drift
cli · static · 8 MB

anima-verify

Single static binary. No kernel needed. Runs offline against a saved envelope or online against any substrate URL. Tri-state exit codes.

$ anima-verify provenance \
  0b14…e9c3 \
  --substrate https://substrate.anima.dev
matches
substrate_addr: 19e7…ff2a
03 · download · API

Self-host the substrate.
Or call the reference API.

Spec, primitives, and verifier are Apache-2.0. The public reference instance is operated by Anima Provenance, PBC — paid stamping, free verification, fork-safe.

npm
@anima/provenance-verify
TypeScript verifier twin · ESM · Node ≥18 + browser · byte-parity tested
npm install · coming soon
cli · binaries
anima-verify v1.0
linux/amd64 · darwin/arm64 · windows/amd64 · static · trimpath · signed
Download · coming soon
reference API
GET /v1/verify/<claim-id>
Signed envelope · records root · OTS proofs · attestations[]. Free reads.
API reference →
go module
anima.kerneld/pkg/provenance/verify
Go reference implementation. Vendor it directly or import as a module.
substrate spec
VERIFIER_TOOL_SPEC v1
Wire format, EIP-712 domain strings, records-root rules, tri-state semantics.
parity fixture
parity_fixture.json
Deterministic envelope your verifier can re-derive end-to-end as a smoke test.
04 · methodology registry

Every claim names its method.
Every method is public.

A claim without a methodology is just a signature. The registry records the rules an attester followed to produce a stamp — anyone can read them, dispute them, or fork them.

news · fact check
news.fact-check.v2
3-source corroboration, named author, primary-source link required, 24h public correction window.
media · provenance
media.c2pa-bridge.v1
C2PA manifest hashed, signer pinned, ingestion device class declared, edit history retained.
finance · disclosure
finance.disclosure.v1
Filed source document hash, jurisdiction, filing officer DID, retention window per regulator.
model · evaluation
model.eval.v1
Model hash, eval-set hash, harness version, hardware class. Reproducible from declared inputs.
05 · substrate invariants

What the substrate refuses
to do.

Seven inviolable rules. Each one is a load-bearing reason an external attester can trust the substrate as much as they trust themselves.

I-1 · no methodology exec
The substrate does not run your method.
It anchors what you signed. Methodology re-execution is the attester's job, not the substrate's. Keeps the substrate vertical-agnostic.
I-2 · no opinions
The substrate makes no truth claim.
Library returns typed errors. Tri-state classification lives only in the verifier CLI a consumer chooses to run. No "trust score" is ever assigned by the substrate.
I-3 · canonical wire
JSONL with EIP-712 typed data.
One canonical encoding. No version negotiation surface, no proprietary protocol. Every envelope is parseable by any spec-compliant implementation.
I-4 · vertical-agnostic
No fintech, gov, or medical bias.
Records what was signed under what methodology. The methodology — not the substrate — decides whether a claim belongs in payments, government, or healthcare.
I-5 · operator DID-agnostic
The operator is not the truth.
Substrate operator key is recorded, not privileged. A reader who doesn't trust the operator can re-derive every digest themselves and reach the same answer.
I-6 · frozen crypto surface
keccak256 + secp256k1. Forever.
Two primitives, no negotiation. Adding a curve or a hash would split the verifier graph in half. Substrate v2 is a new substrate.
I-7 · fork-safe
Apache-2.0. Forkable. Foundation-stewarded.
If the operator behaves badly, the spec and verifier survive the operator. Forks produce byte-identical claim IDs against the same input. The substrate cannot hold its users hostage.
06 · pricing

Verification is free.
Stamping is metered.

Anyone can verify, forever. Attesters pay to stamp on the reference instance — or self-host and pay nothing.

reader
Free / unlimited
  • Verify any claim ID
  • Fetch envelope · records root · attestations
  • Embed HTML badge anywhere
  • CLI + npm verifier, full source
Get verifier →
attester
$0.01 / stamp
  • Stamp claims with your own key
  • Bitcoin OTS anchor included
  • Methodology registry entry
  • Cross-attestation surface
  • Email support
Start stamping →
self-host
Apache-2.0
  • Run your own substrate instance
  • Operate the spec on your hardware
  • Byte-identical claim IDs vs reference
  • Foundation-stewarded spec
  • Commercial support optional
Read the spec →
07 · products on the substrate

What you build
on top of provenance.

The substrate doesn't pick verticals. The Anima Kernel does. Same EIP-712, same Merkle root, same verifier — but with vertical-specific methodology bundles, HSM signing, and compliance exports.

anima kernel · payments
Cryptographic attestation for every payment decision

Fraud decisions, SCA challenges, routing choices, settlement batches. Sub-ms attestation, PCI scope = ∅, M-of-N reconciliation. PSD2 · Visa CE 3.0 · MC CE 3.0 · CFPB.

Explore payments →
anima kernel · government
Public sector determinations

Benefits eligibility, tax assessment, permits, procurement, immigration. FedRAMP · FISMA · FIPS 140-3.

Explore government →
anima kernel · healthcare
Clinical & administrative decisions

Prior auth, claims adjudication, utilization review, CDS, formulary. HIPAA · HITRUST · 21 CFR Part 11.

Explore healthcare →
anima kernel · secops
Safe-harbor security attestations

Three-tier active attester model (T1 / T2 / T3). Signed incident evidence, SBOM provenance, sandbox detonations. — in development

phase S1 · 2026

Start verifying in 30 seconds

Pick a claim ID. Run anima-verify or paste the embed tag. The substrate cannot tell you what's true — it gives you everything you need to decide for yourself.

Try the verifier (free) → Read the invariants →