Developers
Read the record. Verify a wave. Build on it. (Coming.)
The design for the path to read the open record, verify a wave, and build on the contracts and protocol references — not yet live; see the page for current status.
Veraq's open-record design is built to make this true: every wave runs on a mechanism committed before it begins and provable after, and every participation, outcome and contribution is written to a record anyone will be able to read. That reading path — a public API to fetch an entry, walk its links, and check the mechanism that produced it — is not live yet; this page describes the design an engineer can assess today, ahead of it.
This page is the short path for engineers to that design: the entities, the mechanism, and the verification math, described below. The repository these are defined in is not yet public, and @veraq/contracts and @veraq/protocol-ref are not yet published anywhere installable — both are on the roadmap, not shipped.
Quickstart (the design, not yet a live API)
- 01
Read a wave
Once the open-record read API is live: fetch a wave by id. The response carries its Mechanism, its Participations, and the Outcome, each as a linked entry you'll be able to resolve on its own.
- 02
Resolve its links
Follow the wave to the Mechanism commitment published before it ran, and to the Contribution that routes the defined share to a Cause after it settled.
- 03
Verify the mechanism
Recompute the commit-reveal-v1 result from the published commitment and the revealed inputs. A matching digest is the proof that the recorded outcome is the one the committed mechanism produced.
- 04
Build on it
Once @veraq/contracts and @veraq/protocol-ref are published, install them to read, verify, and integrate against the same entities and rules described below.
The open-record data model
- Wave
- One round of participation. Names the mechanism it ran on and the participations it collected, and links to a single outcome.
- Mechanism
- The published selection process for a wave (commit-reveal-v1). Committed before the wave begins, revealed after it ends.
- Participant
- A person taking part on legible terms. Referenced by participations; identifying data is kept off the open record.
- Participation
- A single act of taking part in a wave, linked to its participant and its wave.
- Outcome
- What a wave produced, derived from the revealed mechanism. Linked to its wave and verifiable against the commitment.
- Contribution
- The defined share of a participation, allocated automatically and recorded from outcome to cause.
- Cause
- A verified destination for a contribution, fixed per wave and published in advance, named openly on the record.
commit-reveal-v1
- 01
Commit
Before a wave opens, the mechanism’s inputs are sealed and a commitment digest is written to the open record. The digest binds the result without disclosing it, so no party can alter the mechanism once participation is under way.
- 02
Participate
Participations are collected and recorded against the open wave. The committed digest is already public and fixed at this point.
- 03
Reveal
After the wave closes, the sealed inputs are revealed and written to the record. Anyone can hash the revealed inputs and confirm they match the earlier commitment.
- 04
Recompute
With the revealed inputs and the recorded participations, recompute the outcome deterministically. A matching result proves the recorded outcome followed the mechanism committed in step one — no privileged path, no hidden state.
SDKs, contracts, and protocol (planned)
Clients
Not built yet. Once the read API and SDK land, typed clients will resolve entity links for you, so a wave, its mechanism, and its contribution come back as connected objects rather than raw rows.
@veraq/contracts
The internal contracts package behind the record's schemas. Not yet published anywhere installable — reading it to confirm what is written on commit, on reveal, and on contribution, rather than trusting a description of it, is the intended use once it is.
@veraq/protocol-ref
The protocol reference implementation for commit-reveal-v1: the commitment format, the reveal format, and the recompute rule. Not yet published anywhere installable — the design is enough to verify a wave without any Veraq code in the path once it is.
Stable entities
The seven entities — Wave, Mechanism, Participant, Participation, Outcome, Contribution, Cause — are defined and versioned internally today. This page describes the surface Veraq itself builds on, ahead of it being publicly documented and installable.
Verification recipes (the process once the read API and packages are live)
Prove an outcome
Resolve a wave to its mechanism, recompute commit-reveal-v1 from the reveal, and check the result against the recorded outcome.
Confirm a commitment held
Hash the revealed inputs and compare against the commitment digest written before the wave opened. Equality means the mechanism was fixed before participation.
Follow the defined share
Walk an outcome to its contribution and on to the verified cause it names, confirming the recorded share matches the published rule.
Audit a range of waves
Page through recent waves and run the same checks in a loop to verify a window of activity, not a single hand-picked entry.
Status (illustrative; the record is authoritative)
- 7
- core entities
- v1
- mechanism version (commit-reveal-v1)
- 2
- internal packages defined (contracts, protocol-ref) — not yet published anywhere installable
- 100%
- of outcomes verifiable from the record
commit-reveal-v1 and the seven entities are versioned and dated, designed so older shapes stay readable once the record is live — what you build against will stay checkable. Don’t trust the box — open it.