01 · The institution
Imagine a regulated institution that uses an independent compliance firm.
Species Suite · Onli private market technology
Onli introduces
A consensus of one.
Private truth. Public proof.
Owner-controlled access.
Witness makes private sources of truth publicly provable — without making them publicly readable.
0.1 — The thesis
01 · The institution
Imagine a regulated institution that uses an independent compliance firm.
02 · The verifier
The compliance firm needs to verify that something happened. It does not need unrestricted access to the underlying private record.
03 · The principle
Witness separates the two. The fact becomes provable to anyone. The record stays with its owner.
Independence does not imply privileged access.
Oracle record
Stays private.
Proof
Is public.
Access
Belongs to the owner.
Owners control who, when, where, and for how long someone can see proof.
0.2 — The model
Witness gives a private Oracle record a publicly verifiable proof without publishing the record. Witness itself never learns what the record means.
01
Private truth
The underlying record remains private, inside the appliance that produced it.
02
Public proof
A public proof establishes that the private record exists and has not been altered.
03
External anchoring
Witness Nodes anchor each checkpoint outside the system — to Bitcoin through OpenTimestamps by default, or through another anchor provider.
04
Human meaning
Connects a public Witness proof to the meaning held in the appliance's private Oracle — for its owner only.
05
Owner-controlled disclosure
The owner decides what to prove, to whom, and under what conditions.
The public node gives you the proof.
The appliance Oracle tells you what that proof means.
0.3 — How it works
One privacy boundary. Above it, everything is public and content-agnostic. Below it, everything belongs to the owner. Only a commitment crosses — unless the owner proves.
Step 01 · Create the public proof
The Oracle Adapter turns a private record into a commitment and registers it with the Headless Witness. The server appends it to an append-only transparency log and returns a signed receipt.
Independent Witness Nodes follow the log, verify its checkpoints and cosign them. Checkpoints are anchored through a pluggable anchor provider — Bitcoin through OpenTimestamps by default.
Step 02 · Reconnect meaning
The owner signs in with Onli ID. Their app hands opaque witness_ids to the Adapter, which looks up the private Oracle record and renders its meaning — a headline, detail and the claims that can be proven.
Translate happens behind the privacy boundary, inside the appliance's Adapter. The public server is never asked what anything means, because it does not know.
Step 03 · Disclose on your terms
The owner selects specific claims and a recipient. The Adapter seals a presentation to that recipient, with a purpose and an expiry. Nothing else leaves.
The recipient verifies the presentation against the public log on their own — no Onli UI, no live Onli service, no trust in the sender required.
ORACLE RECORD (private)
│ witness
▼
PUBLIC PROOF (commitment in a transparency log)
│
├── no disclosure by default
│
└── owner Prove ──► selected claims, independently verifiable
0.4 — Components
Witness is an Onli protocol with reference implementations. Every piece can be run, replaced or verified independently.
Shared contracts, cryptographic construction and verification rules.
Public registration, append-only transparency log, receipts, checkpoints and proof retrieval. Content-agnostic.
Independently operated node: follow, verify, mirror, cosign, anchor, serve, audit.
Appliance-side bridge between Oracle records and public proofs. Owns Translate and Prove.
Reusable developer interface — TypeScript, Rust, Swift, Kotlin.
Web — a visual relationship surface. Mobile — table-first.
Running a Headless Witness Server or a Witness Node grants no access to private Oracle records.
Witness is not
0.5 — Witness Nodes
No global network of strangers has to agree. You choose who verifies — one node you trust, or a quorum of several. Every operator verifies public history without seeing a private record.
Option 01
Operate your own Witness Node beside your appliance. You follow, verify and cosign the log directly.
Option 02
You don't need to run a node at all. An independent financial audit firm operates it, cosigns what it verified, and still never sees your records.
FOLLOW
Track checkpoints and log growth.
VERIFY
Check signatures, log identity, protocol version and append-only consistency.
MIRROR
Retain enough public history to serve or rebuild verification evidence.
COSIGN
Countersign verified checkpoints with C2SP transparency-log cosignatures.
ANCHOR
Anchor checkpoints through a pluggable provider — OpenTimestamps to Bitcoin by default — and keep the proofs.
SERVE
Serve retained public proof material.
AUDIT
Apply an organization's own policy to public history.
A node never cosigns a checkpoint it cannot verify, and never cosigns two histories that disagree.
Anchor providers
Witness Nodes anchor each checkpoint through a pluggable anchor provider. OpenTimestamps to Bitcoin is the built-in provider and the production default; other anchoring systems plug in through the owp3-anchor-plugin/1 protocol, and every system must define a proof that third parties verify independently. An Ethereum L1 calldata provider is a reference add-on example of the plugin architecture; production anchors to Bitcoin through OpenTimestamps.
0.6 — Developers
Headless and protocol-first. The TypeScript SDK runs the reference owp3-core compiled to WebAssembly,
so a result in your app is byte-for-byte what the reference verifier reports.
import { WitnessdClient, verifyWitness } from "@onli/witness-sdk";
// Anyone can check a proof. No account, no private access.
const log = new WitnessdClient("https://onli-witnessd.onrender.com");
const check = await verifyWitness(log, witnessId, {
tsPks: [TRANSPARENCY_SERVICE_PK], // pinned out of band
checkpointPks: [CHECKPOINT_PK], // adds note-signed
nodeKeys: { "node-a": NODE_A_PK }, // adds cosigned
});
check.ok; // true only when every check passes
check.checks; // published · receipt · stable-id · on-log · note-signed · cosigned
import { AdapterClient, AUDIENCE_NAMED } from "@onli/witness-sdk";
// Owner side: runs against the Adapter of the appliance that holds the record.
const adapter = new AdapterClient(ADAPTER_URL);
const session = await adapter.session(ownerEmail); // Onli ID sign-in
// Translate: opaque witness_id → private meaning
const [item] = await adapter.translate(session.token, [witnessId], {
includeProofableClaims: true,
});
// Prove: one claim, one recipient, one week
const grant = await adapter.prove(session.token, {
witnessId,
claims: [item.proofableClaims![0]],
audience: { kind: AUDIENCE_NAMED },
recipient: "auditor@compliance.example",
purpose: "quarterly review",
expiresAt: Math.floor(Date.now() / 1000) + 7 * 86400,
});
# Discovery
curl -H "Accept: application/cbor" \
https://onli-witnessd.onrender.com/owp
# Latest checkpoint, with cosignatures and anchors
curl -H "Accept: application/cbor" \
https://onli-witnessd.onrender.com/owp/3/checkpoints/latest
# One witness: statement, receipts, log index
curl -H "Accept: application/cbor" \
https://onli-witnessd.onrender.com/owp/3/witnesses/{base64url(witness_id)}
The bundle is served with state PUBLISHED.
The receipt verifies under the Transparency Service key.
The statement hashes to the witness_id you asked for.
The statement's index sits inside a checkpoint of the log.
That checkpoint is signed by the log under a key you pinned.
At least one Witness Node you pinned cosigned it, and every pinned node's line verifies.
TypeScript
@onli/witness-sdk
Rust
owp3-core · owp3 CLI
Swift
planned
Kotlin
planned
A consensus of one
The record stays private.
The proof is public.
Access belongs to the owner.