Skip to content
VEILOPS / Privacy infrastructure

Privacy is notthe absenceof proof.It’s proof without exposure.

Financial operations should not require exposing everything. VEILOPS explores a new infrastructure model where sensitive information remains confidential while the validity of an operation can still be independently verified.

proof system
veilops-range-v1
curve
ristretto255
payload cipher
AES-256-GCM
status
phase 01 · experimental
02  /  The problem

Transparency
has a cost.

Public ledgers made settlement verifiable by making everything visible. For individuals that is uncomfortable. For organizations it is often unacceptable: the same openness that lets anyone audit a transfer also lets anyone read the business behind it.
01 · Treasury

Public payment records can expose spending patterns.

Every rebalance, runway decision and counterparty becomes a public time series that competitors and attackers can read.

02 · Payroll

Contributor payments can reveal compensation information.

Paying a team on a public ledger publishes each person’s salary, start date and raises, permanently.

03 · Operations

Business relationships and transaction patterns can become visible.

Vendor lists, deal sizes and payment timing reveal strategy long before an announcement does.

03  /  The VEILOPS model

Hide what matters.
Prove what counts.

An operation enters. Its sensitive values are sealed. A proof is produced that the hidden amount satisfies the policy. Anyone can check that proof, and nobody learns the amount.
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·
04  /  What is visible?

Selective, not
invisible.

Privacy claims are only useful when they are precise. Here is exactly what an outside observer sees in each model.
FieldOrdinary public transferVEILOPS operation
SenderDao7…TreasuryDao7…Treasury
Recipientcontributor-0x91sealed · 3f9a…c21e
Amount48,250.00 USDCC = 6a1f…09bd (commitment)
MemoOctober contributor payoutsealed · AES-256-GCM
Timestamp2026-11-04 14:02 UTC2026-11-04 14:02 UTC
Fee / assetUSDC · 0.000005 SOLUSDC · 0.000005 SOL
Policyn/apol_3c… · max 60,000.00
Proofn/aprf_91d0… · 48 OR-proofs
ResultEverything, forever0 ≤ amount ≤ limit · VALID

Illustrative values. Sender, timing, fees, asset, policy limit and the fact that an operation happened remain observable. That is metadata the underlying chain or indexer exposes. VEILOPS conceals amounts and, by mode, recipients and memos. It does not make operations anonymous.

05  /  Protocol modules

Five modules,
one discipline.

Each module is labelled with what it actually is today: implemented, experimental, simulated or planned.
01
experimental

Private Treasury

Confidential financial operation workflows for digital treasuries. Rebalances and transfers carry a commitment to the amount and a proof that it respects the treasury policy.

  • — Policy limits per category and asset
  • — Amounts committed, not published
  • — Encrypted operation log for signers
02
experimental

Proof Engine

Generate and verify cryptographic proofs. Today: veilops-range-v1, a bit-decomposition range proof on Pedersen commitments over ristretto255, made non-interactive with Fiat–Shamir.

  • — Proves 0 ≤ amount ≤ limit
  • — No trusted setup
  • — Verifies in the browser in well under a second
03
simulated

Private Payroll

Support confidential contributor payment workflows. Batch payouts where each line item is sealed for the contributor and finance, and proven against the payroll policy.

  • — Per-recipient envelopes
  • — Compensation never in public records
  • — Batch workflow is simulated today
04
implemented

Selective Disclosure

Reveal specific information only to authorized parties. A data key is wrapped per viewer (X25519 + HKDF). An auditor can open the envelope and check the commitment opening.

  • — Grant access without re-encrypting
  • — Commitment opening proves the disclosed amount
  • — Keys never leave the browser
05
implemented

Public Proof Explorer

Allow independent verification of permitted public proof records. Every record can be re-verified from scratch in your browser. The dataset is sample data today.

  • — Search by operation or proof id
  • — Re-verify any record locally
  • — Tampered samples fail, by design
06  /  Architecture

Confidential by design.
Verifiable by construction.

Seven layers from your application down to Solana. Select a layer for its technical detail.
@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
07  /  Verify it yourself

Don’t take
our word for it.

Load a published record and run the verifier in your own browser. Then try to cheat: change the limit, the asset or the date, and watch the proof refuse to cooperate.
sample data
Public inputs
Loading…
Verification

Runs the full veilops-range-v1 verifier (both range proofs, the proof-id hash and the Ed25519 attestation). No trust in this website is needed. The same code ships in @veilops/proof-engine.

Implementation status: real cryptographic verification · proof system experimental and unaudited · records are sample data signed by a throwaway sample-operator key · no blockchain involved.
08  /  Developer ecosystem

Build on privacy.

@veilops/sdk · TypeScript
import { createClient } from '@veilops/sdk';
import { definePolicy } from '@veilops/policy-engine';

const veil = createClient({ viewers: [auditorPublicKey] });
const policy = definePolicy({ name: 'payroll', maxAmount: 25_000_00 });

const { record, envelope } = await veil.process({
  name: 'Nov payout', category: 'payroll', recipient: 'alice.sol',
  amount: 4_825_00, asset: 'USDC', policyLimit: 25_000_00,
  mode: 'amount-and-recipient',
}, policy);

veil.verify(record).valid; // true, and the amount is not in the record
09  /  Roadmap

Honest milestones.

Statuses describe the code in this repository, not intentions.
Phase 01

Foundation

Protocol architecture, SDK foundation and interactive proof demonstration.

in progress
Phase 02

Proof infrastructure

Proof generation, verification and policy engine integration.

planned
Phase 03

Solana integration

Devnet testing, supported confidential-transfer integrations and operation lifecycle.

planned
Phase 04

Applications

Treasury, payroll and selective disclosure workflows.

planned
Phase 05

Security and ecosystem

External review, security testing, developer integrations and expanded infrastructure.

planned

The information stays private. The proof speaks.