Verify Anything

The framework's claim is not "trust us" — it's "here is everything you need to check us, offline, with no account and no secrets." This page is the map: four verification surfaces, what each one proves, and how to run all of them in a few minutes.

Surface	Proves	Tool
Signed envelope	who computed it, and that nothing changed since	zeq verify · /verify-zeq-result.mjs
Cross-node attestation	an independent node re-derived the same bits	POST /api/attest
Entangled-state seal	history wasn't silently rewritten (PoEZ VDF)	/verify-zeq-chain.mjs
Conformance	the node computes the golden physics, today	zeq conformance · /zeq-conformance.mjs

All three .mjs scripts are zero-dependency Node scripts served by every node — fetch them from the node you're auditing, or from a different node if you don't trust the first one.

1. The signed envelope

Every compute returns a CKO envelope whose signed block carries the claim (operators, inputs, value, unit, uncertainty, registry_version, Zeqond, phase), an Ed25519 signature over the canonical JSON of that claim, and the node's public key. Check it without trusting the wire:

zeq compute NM19 mass=5 acceleration=2 --json > envelope.json
zeq verify envelope.json

Or fully offline:

curl -fsSO https://zeqstate.com/verify-zeq-result.mjs
node verify-zeq-result.mjs envelope.json

The script fetches /api/identity for the trust anchor, verifies the signature, then re-derives the physics independently — pure float64 arithmetic, pinned constants, no clock — and bit-compares.

2. Cross-node attestation

One node agreeing with itself is weak. Hand the claim to a different sovereign node:

curl -s -X POST https://zeqond.com/api/attest \
  -H "Content-Type: application/json" \
  -d '{"claim":{…},"signature":"…","origin_public_key":"…"}'

The verifier pins the registry generation, checks the origin signature, recomputes the physics, and returns a verdict (agree / disagree / unverifiable) signed by its key. Envelopes minted on mesh nodes already carry peer attestations — the fan-out to the verifier mesh happens at compute time, fail-open.

3. The entangled state, offline

Each machine's history is a hash-linked, tamper-evident entangled state, and the spine of PoEZ seals (GET /api/chain/seal) makes rewriting it cost real sequential time:

curl -s "https://zeqstate.com/api/chain/seal?seals=100" > seal.json
curl -fsSO https://zeqstate.com/verify-zeq-chain.mjs
node verify-zeq-chain.mjs seal.json

Hash links, Wesolowski VDF proofs, Zeqond arithmetic, Ed25519 seal signatures — all checked locally, no network after the two fetches. From the CLI: zeq chain verify.

4. Conformance

Finally, prove the node's current registry computes the canonical physics — every golden vector, bit-identical:

zeq conformance          # or: node zeq-conformance.mjs https://zeqstate.com

See GET /api/zeq/conformance.

What composes with what

Each surface covers the others' blind spots. The envelope proves provenance but not history; the seal proves history but not physics; conformance proves physics today but not yesterday; attestation adds an independent witness to all of it. Run all four and the remaining trust assumptions are: Ed25519, SHA-256, sequentiality of modular squaring, and IEEE-754 determinism — all stated, all inspectable.

Honest limits

• Verification is only as good as your key↔origin binding — fetch /api/identity over TLS from the origin yourself.
• The seal spine binds relative sequential time (see the honest-limits section — a faster attacker compresses the cost, not to zero).
• A KO42-only claim has no recomputable solver value and attests unverifiable.