Skip to content
The protocol

A record that proves itself.

VEILOPS turns a sensitive financial operation into two artifacts: an encrypted envelope that only authorized parties can open, and a public record that anyone can verify without learning the hidden values.
01  /  Lifecycle

Five stages, in order.

  1. 01

    Created

    The application submits an OperationInput. The SDK assigns a random operation id and timestamp.

  2. 02

    Encrypted

    Name, recipient, amount and memo are sealed in an AES-256-GCM envelope bound to the operation id. The data key is wrapped for the owner and every authorized viewer.

  3. 03

    Policy evaluated

    Public rules (category, asset, mode) and the confidential amount limit are checked on plaintext, locally. A violation stops the pipeline: there is no proof for a violation.

  4. 04

    Proof generated

    The amount is committed (Pedersen, ristretto255) and two range proofs show 0 ≤ amount ≤ limit. The proof id is the hash of the proof.

  5. 05

    Verified

    The public record is signed (Ed25519) and re-verified from scratch, exactly as an independent verifier would.

Operation · op_7c1e…a04f
Amount
48,250.00 USDC
Recipient
contributor-0x91
Memo
October contributor payout
Policy limit
60,000.00 USDC
Category
payroll
Live: real AES-256-GCM ciphertext and Pedersen commitment, computed in your browser.
Commitment & proof
C = v·G + r·H
—
awaiting proof
0 ≤ v·
v ≤ limit·
proof id bound·
operator signature·
02  /  Architecture

Seven layers.

@veilops/proof-engineexperimental

Proof engine

veilops-range-v1: Pedersen commitment + two bit-decomposition range proofs ⇒ 0 ≤ amount ≤ limit.

  • —Commitment C = v·G + r·H on ristretto255. H is derived by hash-to-curve, so no one knows its discrete log.
  • —Each bit commitment carries a CDS OR-proof (it opens to 0 or 1). Fiat–Shamir with SHA-512 binds every challenge to the operation’s public inputs.
  • —The upper bound uses the homomorphism D = max·G − C. Proof size is O(n): tens of KB, not succinct.
  • —Unaudited. Treat as experimental.
input
amount (private), public inputs
output
PolicyProof
03  /  Record format

What gets published.

Every field of a public record, and what kind of information it carries.
FieldClassNotes
operationIdpublicRandom, unique per operation; part of every Fiat–Shamir challenge.
proofIdpublicprf_ + truncated SHA-256 of the canonical proof.
createdAtpublicISO-8601 timestamp, covered by the attestation.
category · asset · modepublicNeeded for public policy checks. This is metadata.
policy { id, maxAmount, rangeBits }publicThe limit is a public input to the proof.
amountCommitmentcommitmentC = v·G + r·H. Perfectly hiding: reveals nothing about v.
envelopeDigestdigestSHA-256 of the envelope; the ciphertext itself is not published.
recipientmode-dependentPresent only in amount-only mode.
proofproofveilops-range-v1 proof, base64. O(n) size.
attestationsignatureEd25519 public key + signature over the canonical record.
04  /  Trust assumptions

What you still have to trust.

The operator’s key

The Ed25519 attestation says who published a record. If the operator key is compromised, an attacker can publish valid-looking records for amounts within policy, but never prove an over-limit amount.

The policy is public

The limit is a public input. Anyone can see that a payroll policy caps payments at a value, though not what any payment was.

Metadata is visible

Timing, category, asset, mode, policy and (in amount-only mode) recipient are public. Volume and frequency analysis remain possible.

Cryptographic assumptions

Discrete log hardness on ristretto255 for binding; SHA-512 modelled as a random oracle for Fiat–Shamir. The construction is classical but this implementation is unaudited.

Your browser

Encryption, proving and verification run in client-side JavaScript. A compromised device or extension can read plaintext before it is sealed.

No chain finality yet

Records are not anchored on any blockchain today. Ordering and existence are only as good as the publisher’s storage.

05  /  Implementation status

What exists today.

Envelope encryptionimplementedAES-256-GCM + X25519/HKDF key wrapping, runs in your browser. Unit-tested, not externally reviewed.
Policy engineimplementedPublic rules + a confidential amount limit that is enforced by the range proof.
Range proof (veilops-range-v1)experimentalReal zero-knowledge proof of 0 ≤ amount ≤ limit on a Pedersen commitment. Not audited, not succinct.
Record attestationimplementedEd25519 signature by the publishing operator. Proves origin, not privacy.
Public proof explorerimplementedReal verification in your browser over a SAMPLE dataset. No live network indexer yet.
Solana anchoringexperimentalBuilds an SPL Memo anchor instruction. Not tested on devnet or mainnet; sends nothing.
Token-2022 confidential transfersplannedIntegration with the confidential transfer extension where supported.
On-chain verifier programplannedAn Anchor program for record registration. Not written yet.
Wallet connectionplannedHidden until there is something real for a wallet to sign.