The Protocol,
specified.

OPAQ is a programmable privacy protocol on Solana. It does not hide you. It lets you decide, in code, which parts of your on-chain life are visible, to whom, and for how long.

Four primitives ship at launch:

• Privacy Score -- quantifies how trackable an arbitrary Solana wallet is.
• MEV Exposure-- detects sandwich, frontrun and backrun losses across a wallet's history.
• Private Transfer -- ZK-backed SOL/SPL transfer that hides amount and counterparty.
• Programmable Disclosure -- policies that reveal data only to the parties a user names.

The protocol separates three concerns: client surfaces (web/extension/bot), the OPAQ service (scoring, proofs, disclosure enforcement), and the Solana runtime (on-chain verifier and state). Nothing inside the service ever receives a private key. Clients talk to Solana through our RPC proxy so the Helius endpoint is never exposed to the browser.

                ┌──────────────────────────────┐
                │   Client surfaces            │
                │   web · extension · telebot  │
                └──────────────┬───────────────┘
                               │ HTTPS
                ┌──────────────▼───────────────┐
                │   OPAQ Service (FastAPI)     │
                │   · privacy-score engine     │
                │   · mev scanner              │
                │   · disclosure policy vm     │
                │   · RPC proxy (allowlist)    │
                │   · api-key / rate limit     │
                └──────────────┬───────────────┘
                               │ JSON-RPC
                ┌──────────────▼───────────────┐
                │   Solana (mainnet-beta)      │
                │   · opaq_core (Anchor)       │
                │   · verifier · pools · tree  │
                └──────────────────────────────┘

Privacy Score grades a wallet from 0 to 100, where 0 is an open book and 100 is maximally covered. The score is a weighted sum of six independent signals computed over the wallet's last 100 transactions.

Risk levels derived from the total: 0-20 critical, 21-40 high, 41-60 medium, 61-80 low, 81-100 minimal.

MEV Scan reads every swap from the wallet's history, finds same-slot neighbour transactions, and classifies attacks into four buckets.

• Sandwich-- a victim's trade is wrapped by a neighbour that trades the same pair before and after, with priority fees ≥ the victim's. Loss modelled at ~0.5% of input.
• Frontrun -- a same-direction neighbour pays more fee and executes first. Loss modelled at ~0.3% of input.
• Backrun -- an opposite-direction neighbour pays more and fires after. Loss modelled at ~0.2% of input.
• Slippage-- no attacker visible, but realised USD out vs USD in ≥ 1.5%. Counted as extractive slippage.

Private Transfer spends a commitment from an OPAQ privacy pool and creates a new one for the recipient. A Groth16 proof attests that the input existed, that the output has the same total value, and that a unique nullifier has not been used before. Anchor verifies the proof on-chain and consumes the nullifier.

import { OpaqClient } from "@opaq-labs/sdk";

const client = new OpaqClient({ endpoint: "https://opaq.fun/api/rpc" });

const result = await client.privateTransfer({
  from: await client.pool.commitmentForOwner(signer.publicKey),
  toCommitment: await client.pool.newCommitment(recipientCommitment),
  amount: 1_000_000_000n, // 1 SOL
  proof: await client.proofs.transfer(inputs),
});

Disclosure policies are small expressions compiled to a ZK circuit. A policy is stored on-chain with a commitment, and a prover can show that their private data satisfies the policy without revealing the underlying data.

import { Disclosure } from "@opaq-labs/sdk";

const policy = Disclosure.policy({
  when: "tx.amount > 10_000 USDC",
  reveal: ["amount", "sender"],
  to: ["auditor.sol"],
  validFor: "90d",
});

await client.disclosure.register(policy);

A policy is a pure function. It has no side effects and cannot call external oracles at proof time. Anything an auditor or counterparty will see must be named in reveal; everything else stays encrypted.

Three authenticated endpoints are exposed today. Get a key at opaq.fun/developers.

curl https://opaq.fun/api/v1/privacy-score/vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg \
  -H "X-API-Key: opq_..."

TypeScript SDK lives at github.com/opaq-labs/opaq. The SDK wraps the API, the on-chain program, and the ZK proof generation pipeline. Rust and Python bindings follow the same shape.

git clone https://github.com/opaq-labs/opaq.git
cd opaq
npm install --prefix sdk
npm test --prefix sdk

Any Solana dApp can call the API without running a circuit locally. Typical wiring:

• DEX aggregators -- surface a Privacy Score badge next to routes involving known MEV-active pools.
• Wallets -- warn before a send if the recipient has a high cluster score linked to the sender.
• DAO treasuries -- gate large payouts behind a disclosure policy so auditors see what they are entitled to and nothing else.
• Analytics dashboards -- annotate address rows with trackability grades pulled from the public API.

• OPAQ service never receives a private key. All signing is client-side.
• The RPC proxy uses a server-side allowlist. Only read methods and standard transaction submission are forwarded.
• ZK circuits are compiled with anchor-lang 0.30.1 and Groth16. Trusted setup ceremony artifacts are published with every release.
• API keys are scoped to rate-limit buckets, not to endpoints. A key cannot elevate its own tier; tier is a function of staked $OPAQ.
• Privacy pools enforce an anonymity-set minimum before withdrawal becomes available. Pools below the minimum remain locked.