VettedDocs
ExpertsCandidatesCompaniesReference
Back to app
ExpertsCandidatesCompanies
  • Getting started

    • What is Vetted?
    • How it works
    • Quickstart
  • Start here

    • Overview
    • Expert quickstart
    • Applying to a guild
  • Core workflows

    • Reviewing candidates
    • Commit-reveal voting
    • Reputation & ranks
  • Economics

    • Endorsements
    • Slashing & accountability
    • Earnings & withdrawals
  • Advanced

    • Governance & proposals
    • Expert FAQ
  • Reference

    • Glossary
    • FAQ

For experts · Core concept

Intermediate

Commit-reveal voting

Vetted's two-phase voting protocol. Experts commit blind scores first, reveal them together later, and consensus is calculated with outlier filtering. This page explains why the design exists and walks through it with an interactive demo.

Last updated April 2026

TL;DR

  • Commit-reveal is a two-phase voting protocol that hides scores until all reviewers have committed, preventing anchoring and herding bias.
  • Phase 1: you submit a hash of (score + nonce) on-chain. Phase 2: you reveal the actual score; the chain verifies it matches.
  • Consensus is calculated with an IQR filter — scores outside the band [median − 0.75×IQR, median + 0.75×IQR] are excluded, and the average of the rest becomes the final score.
  • Your alignment with consensus earns or costs reputation: +10 if within 1×IQR of median (aligned), −20 if beyond (misaligned).

Phase 1

Commit

Submit hash(score, nonce) on-chain

Phase 2

Reveal

Publish actual score — chain verifies hash

Phase 3

Finalize

IQR consensus + reputation moves

Phase 1

Commit

Submit hash(score, nonce) on-chain

Phase 2

Reveal

Publish actual score — chain verifies hash

Phase 3

Finalize

IQR consensus + reputation moves

A vote moves through three phases. Only the reveal phase exposes your score to other experts.

Why commit-reveal exists

Group evaluation has two chronic failure modes. Anchoring is when reviewers see someone else's score first and unconsciously adjust their own to match it. Herding is the same problem compounded: once the first few reviewers agree, later ones feel social pressure to fall in line.

Both effects collapse the variance of a panel's scores toward whoever votes first, destroying the statistical value of having multiple reviewers in the first place. Commit-reveal voting solves this by making it physically impossible to see anyone else's score until everyone has committed.

This isn't a Vetted invention

Commit-reveal schemes come from cryptographic voting research going back decades. Vetted's contribution is wiring one up specifically for candidate reviews and exposing it as a product primitive.

The protocol

A vote moves through three phases. At the end, the consensus score is calculated and every expert's reputation is updated based on their alignment with that consensus.

1. Commit phase

Your client computes a hash of your score concatenated with a random nonce. The hash is submitted to the on-chain contract along with your wallet signature. Your browser stores the nonce in local storage only — it never leaves your device during commit.

Other experts can see that you committed (your wallet address appears in the application's commit list) but they cannot see your score. They only see a hash, which is information-theoretically useless without the nonce.

2. Reveal phase

After the commit window closes, the reveal window opens. You come back to the application page and click Reveal. The client reads your saved nonce and score, and calls the reveal function on the contract.

The reveal is the only moment you're exposed — once you've clicked it, your score is public to the guild. Until then, nobody has any signal about your vote.

3. Finalization

When every expert has revealed (or the reveal window expires), finalization runs. The backend gathers all revealed scores, filters outliers using interquartile-range math, computes the consensus score (average of included scores), and classifies each expert's alignment.

Try it yourself

The demo below walks through a mock review — you score a fictional candidate, commit blind, reveal, and see how your choice maps to consensus and reputation. Nothing here touches the real app or your reputation.

Interactive demo — commit-reveal voting
1. Score
2. Commit (blind)
3. Reveal

You're reviewing a mock candidate. Score them on a 0–100 scale — anywhere between 75 and 85 will land near the consensus the other four experts produced. Try setting a wild value to see the slashing penalty.

78
050100

Try it twice

Run it once with a score near 80 (aligned) and once with something wild like 10 or 100 (severe deviation). Seeing the penalty move is the fastest way to intuit the slashing curve.

How consensus is calculated

Vetted uses an IQR-based filter rather than a simple mean or median. Here's the exact procedure:

  1. Collect every revealed score for the application.
  2. Calculate the first quartile (Q1), third quartile (Q3), and interquartile range (IQR = Q3 − Q1).
  3. Build an inclusion band around the median: [median − 0.75 × IQR, median + 0.75 × IQR]. Scores outside this band are excluded.
  4. The consensus score is the average of the remaining scores.

Using the average of the filtered set rather than a raw average of everything means one wild score (either honest mistake or bad-faith) cannot swing the consensus away from where the bulk of experts landed. The IQR filter excludes outliers first, then the average of the remaining scores gives a stable consensus.

Alignment tiers

Your reputation change is determined by how far your score landed from the consensus, measured in IQR units. Two tiers:

TierDistance from medianReputationStake slashed
Aligned

Your 78, consensus 80 → no penalty, full reward.

≤ 1.0 × IQR from median+100%
Misaligned

Your 45, consensus 80 → max penalty, reputation loss.

> 1.0 × IQR from median−2025%

The tiers are deliberately lopsided: being aligned earns you a meaningful boost; being wrong costs you more. This matches the underlying economics — one bad reviewer with no downside can consistently bias hiring outcomes, so bad-faith reviewing has to cost real money.

If you lose your nonce

The nonce only exists in your browser. If you clear local storage, switch devices, or use a private window during the commit, you won't be able to reveal.

There is a manual recovery path — contact the guild admin, who can mark your vote as abstained for that cycle. You won't earn or lose reputation on the affected vote, but you will count as inactive for that review, which contributes to long-term decay if it happens repeatedly.

Don't share your nonce

The nonce + score combination is the proof that you're the one who committed. Anyone with both can reveal on your behalf and lock you into that score. Keep them local.

Key takeaways

  • Commit-reveal hides scores until everyone has committed — this is how you prevent anchoring and vote-switching.
  • The hash you commit is immutable on-chain; you cannot edit your vote after committing, period.
  • Your nonce lives only in browser local storage. Lose it = lose the ability to reveal that vote.
  • Consensus uses IQR filtering (inclusion band: median ± 0.75×IQR) then takes the average of the remaining scores.
  • Binary alignment: ≤1×IQR from median = aligned (+10 rep). >1×IQR = misaligned (−20 rep, up to 25% stake slashed).
  • Staked votes amplify both sides: bigger reward on alignment, real money slashed on severe misalignment.

Next steps

Reputation & ranks

How alignment history rolls up into rank tiers and reward multipliers.

Slashing deep-dive

The IQR math, alignment classification, and how to appeal a slashing decision.

App

Open voting queue

Jump into the app and cast your first vote on a real application.

Try the demo again

Scroll back up and experiment with different score values.

PreviousReviewing candidatesNextReputation & ranks

On this page

  • Why commit-reveal exists
  • The protocol
  • Try it yourself
  • How consensus is calculated
  • Alignment tiers
  • If you lose your nonce
Back to app
ExpertsCandidatesCompanies
  • Getting started

    • What is Vetted?
    • How it works
    • Quickstart
  • Start here

    • Overview
    • Expert quickstart
    • Applying to a guild
  • Core workflows

    • Reviewing candidates
    • Commit-reveal voting
    • Reputation & ranks
  • Economics

    • Endorsements
    • Slashing & accountability
    • Earnings & withdrawals
  • Advanced

    • Governance & proposals
    • Expert FAQ
  • Reference

    • Glossary
    • FAQ
commit.ts
const nonce = crypto.randomBytes(16).toHex();   // generated client-side
const hash  = keccak256(score + nonce);          // e.g. keccak256("78|4f2a...")

await vettedContract.commit(applicationId, hash);

// stored locally for reveal:
localStorage.setItem(`vote-nonce-${applicationId}`, nonce);
localStorage.setItem(`vote-score-${applicationId}`, score);
reveal.ts
const nonce = localStorage.getItem(`vote-nonce-${applicationId}`);
const score = localStorage.getItem(`vote-score-${applicationId}`);

await vettedContract.reveal(applicationId, score, nonce);
// the contract re-computes keccak256(score + nonce) and checks it matches
// the hash you committed earlier. If it doesn't, the reveal reverts.