This chapter describes Privium as a whole before the following chapters take it apart. It introduces each actor and what that actor wants from the system, follows one trade from deposit to Exit, lays out where every piece of state lives and which trust domain protects it, and states the six properties that the rest of the paper proves: custody, confidentiality, unlinkability, liveness, price fairness and auditability by the owner.
Actors
Privium has five kinds of participant that act on the protocol and two that only observe it. The table gives each one’s goal and its means; the prose explains how the design serves the three actors that hold keys, and the observer and verifier are treated in Chapters 8 and 11.
| Actor | Wants | Holds | Can do |
|---|---|---|---|
| Trader | to trade any Jupiter-routable token without publishing a trace; to keep a claim on funds that no operator can revoke | a wallet key and the keys derived from it: an Intent authority key, a viewing root for their own leaves, an escape key | deposit, submit Intents, request Exits, trigger the Escape, issue Viewing keys and Receipts |
| Coprocessor | to advance the Ledger correctly each Crossing and earn the protocol fee | and the HPKE key inside the enclave; the Ledger data key | decrypt Intents and leaves, cross, sign Residual orders, sign and submit Commits |
| Council member | to keep the Council key safe and to honour Escapes | one share of the Council secret | publish re-encryption shares with proofs, take part in resharing |
| Pool program | to keep every vault equal to what the Ledger owes | the vault token accounts, the Ledger root, the Registry | accept or reject Commits, release Exits, run the Escape |
| Liquidity venues | to fill the Residual at a market price | public pools reachable through Jupiter | execute the Residual swap |
| Observer | to infer which trader did what | the full public chain | read every account and transaction |
| Receipt verifier | to check a claim a trader makes about their results | a Receipt and the Registry | verify signatures and inclusion |
The trader wants two things that pull in different directions on a public chain: privacy of their trading and a claim on their funds that does not depend on anyone’s good behaviour. Privium serves the first by never letting a trader’s order appear as a transaction of their own, and the second by keeping custody in a program whose only release paths are the Exit, which needs the trader’s signature, and the Escape, which needs the Council and pays only the owner.
The Coprocessor is an enclave service, run by an operator, that executes the Crossing. Its operator controls the host, the network and the schedule, and is trusted for none of them: the Pool program accepts a Commit only if it carries a signature under the registered key , and that key is bound by remote attestation to a published enclave measurement (Chapter 5). Each Commit pays the protocol fee at rate on crossed and routed notional to the token’s launch wallet, where it buys $PRV on the market and is burned (Chapter 12).
The Council is a set of members holding Shamir shares, with threshold , of the secret behind the Council key , under which the Ledger data key and every leaf’s Council handle are encrypted. Its members never see a trader’s balance in ordinary operation. They are called on in two situations: when a new Coprocessor enclave must be provisioned with the key, and when the Escape is triggered because no Commit has landed within the liveness window . In both cases the output of their computation is bound to a destination, the attested enclave or the balance’s owner, and is accompanied by proofs of correct decryption (Chapter 6).
Two external services feed the Coprocessor and are trusted only within narrow bounds. The oracle supplies the mid for each pair; Privium reads Pyth price feeds, which publish a confidence value alongside each price and recommend treating it as a range around the price [3], and the Coprocessor refuses to cross a pair whose confidence interval is too wide relative to its price (Chapter 7). Jupiter supplies the route for the Residual; its Swap API V2 Router path /swap/v2/build returns swap instructions for a transaction the integrator composes [4], which is what lets the Residual execute from the Pool inside Privium’s own instruction flow (Chapter 9).
State
Privium’s state is divided between the chain and the enclave’s memory. Every byte that determines a trader’s claim is on chain: in accounts, or in the ciphertext diffs that Commits publish as transaction data. The enclave holds plaintext only transiently.
On-chain state
| Account | Contents | Written by |
|---|---|---|
| Vault (one per asset ) | SPL or Token-2022 token account holding , owned by the Pool’s program-derived authority | deposits, Exits, the Residual swap, the Escape |
| Ledger root | Crossing index , root , slot of the last Commit, data availability digest, recent exits roots | Commit |
| Crossing state | the open Crossing’s verified mids, recorded Residual fills and ciphertext diff accumulator | open_crossing, route_residual, log_diff |
| Registry | admitted measurements; attested keys , , with validity intervals | registration and rotation (Chapter 5) |
| Council config | , , the Council key , member verification keys | DKG and resharing (Chapter 6) |
| Asset state and deposit queues | committed total and unreleased Exits per asset; deposits not yet credited, in public amounts | deposits, Commits, Exits |
| Escape state | whether the Escape is active, the open Crossing’s fills, and which entries have been paid | Escape instructions |
The vault balances are public by nature: they are ordinary token accounts. What Privium hides is the partition of each vault among traders. Deposits and Exits move public amounts across the boundary of the Pool, and are therefore recorded in the deposit queues and exits roots in the clear; the Coprocessor folds deposits into the encrypted Ledger at the next Crossing. Chapter 8 treats the information content of these boundary events and the countermeasures that reduce it, including amount denominations and Ring Exits.
The Ledger
The Ledger is the encrypted mapping . Each entry is a leaf carrying a Pedersen commitment to the balance, a Council handle, and AEAD ciphertexts for the enclave and the owner, and the Ledger root is the Merkle root over all leaves after Crossing . Following Encifher, on-chain state refers to encrypted values by short ciphertext handles [1]; Privium publishes the ciphertexts themselves on Solana, hash-chained by the program. Chapter 4 defines the leaf structure, the handle model, the state transition function and the growth of the Ledger with the number of traders and assets.
Off-chain state
The Coprocessor holds three things off chain. The Intent queue is the set of encrypted Intents received for the current Crossing; each is encrypted to an enclave key bound to the attestation (Chapter 3 gives the HPKE construction). The working set is the plaintext of the leaves touched by the current Crossing, held in enclave memory for the duration of one batch. The key state is the epoch keys , and , generated inside the enclave and bound to its measurement, and the Ledger data key , which the Council releases only to admitted enclaves (Chapter 5). None of these is needed to recover a trader’s funds: if the Coprocessor disappears, the Escape works from on-chain state alone.
The life of a trade
We follow one trade from the moment a trader funds the Pool to the moment the proceeds land at a fresh address. The pair is with the base asset and the quote asset.
Deposit
The trader sends units of to the Pool’s vault for with a deposit instruction. The instruction transfers the tokens and appends to a deposit queue, where seals the trader’s record identifier to the Coprocessor’s HPKE key, so the public record shows an amount entering the vault and never which leaf it credits. The tokens can come from a public wallet or be withdrawn from a Ring [2]; Chapter 8 compares what each funding path reveals. At the next Crossing the Coprocessor credits the leaf, so that
Intent
To buy units of at a price no worse than , the trader builds the Intent , with expiry slot and a fresh nonce , encrypts it to the Coprocessor’s attested encryption key, and submits the ciphertext. Submission is off chain to the Coprocessor’s endpoint, or on chain as an opaque blob in an account the Coprocessor reads; in both cases the ciphertext reveals neither pair, side, size nor limit. The nonce makes each Intent unique and lets the Ledger reject a replay (Chapter 4).
The listing gives the plaintext form of an Intent as the Coprocessor sees it after decryption, together with the public header of a Commit. The field names follow the shared notation.
/// Plaintext Intent, visible only inside the enclave.
pub struct Intent {
pub trader: LeafId, // u, as a Ledger leaf identifier
pub pair: PairId, // pi = (a, q)
pub side: Side, // s: Buy = +1, Sell = -1
pub size: u64, // x, base units of a
pub limit: Price, // l, quote units per base unit
pub expiry_slot: u64, // tau
pub nonce: [u8; 16], // nu
pub auth: [u8; 64], // signature by the trader's authority key A_u
}
#[repr(i8)]
pub enum Side { Buy = 1, Sell = -1 }
/// Public header of a Commit, checked by the Pool program (layout in Chapter 9).
pub struct CommitHeader {
pub crossing: u64, // k
pub prev_root: [u8; 32], // rho^(k-1)
pub new_root: [u8; 32], // rho^(k)
pub da_digest: [u8; 32], // accumulator over the ciphertext diff of k
pub exits_root: [u8; 32], // Exits listed by this Commit
pub fills_hash: [u8; 32], // Residual fills recorded on chain for k
pub assets: Vec<AssetLine>, // per asset: total, exits, fees, cuts, commitment delta
}
/// Signed by the enclave before each Residual leg executes.
pub struct ResidualOrder {
pub crossing: u64, // k
pub pair: PairId, // pi, routed in the direction of sgn R^(k)_pi
pub amount_in: u64, // exact input from vault 0
pub min_out: u64, // slippage bound checked on the measured fill
}
The auth field is the signature of the trader’s authority key , derived from their wallet (Chapter 10), over the Intent’s fields, so that the Coprocessor executes only Intents their owner authorized. CommitHeader contains no trader, no balance and no individual size: everything in it is either a root, a hash, a counter or a per-pair aggregate.
Crossing
Once the Coprocessor holds something to settle and slots have passed since the last Commit, it closes the batch and runs one Crossing (Chapter 7 fixes the cutoff, Chapter 10 what counts as work). It decrypts the Intents in the queue, drops any whose expiry has passed or whose nonce has been seen, and groups the remainder by pair. For each pair it reads the oracle mid and computes a fill for every eligible Intent under the limit constraints and the allocation rule of Chapter 7. The Residual is the signed net of the fills,
where is the set of eligible Intents on in Crossing . The portion of buy flow matched by sell flow, , is crossed internally at the clearing price . It pays no DEX fee and moves no market. Only units of are routed, in the direction of .
If our trader’s buy meets a sell of equal or larger size in the same Crossing, the trader is filled entirely at the mid. If the batch is net long, the trader’s fill is completed from the Residual swap at the Residual’s execution price, and Chapter 7 specifies how that price is blended across the participants on the routed side. In both cases each leaf touched changes by
where is the trader’s average fill price over the crossed and routed portions and is the protocol fee rate.
The Coprocessor then builds the Residual swap. It requests a route from Jupiter for units, fixes a minimum output from the oracle mid and a slippage bound, signs both into a ResidualOrder, and submits a route_residual transaction in which the Pool’s authority is the swap’s signer [4]. The program measures the vault deltas, rejects a fill outside the signed bound, and records the fill on chain for the Crossing. The Residual of every pair executes from the Pool’s vaults; no trader’s wallet is involved.
Commit
The Coprocessor re-encrypts every touched leaf with its decoys, publishes the new ciphertexts as log_diff transaction data, computes , and signs the Commit message:
with the header fields above (Chapter 4 defines , Chapter 9 lays it out). The Pool program accepts the Commit only if its checks pass: the signature verifies under an admitted that opened the Crossing; prev_root equals the stored root and crossing equals the stored index plus one; the data availability digest, mids and fills match what the chain recorded; and for every asset, once the Commit has paid the Crossing’s fees to the fee recipient, the vault holds exactly the attested Ledger total plus the committed Exits not yet released and the deposits not yet credited, with the Pedersen commitments of the leaves summing to that total. These checks are the public face of the conservation theorem that Chapter 4 proves. The program never sees a balance, and it does not need to.
Each stage is atomic. A Residual leg outside its bound reverts and records nothing; a Commit that fails any check reverts, the root stays at , and the Coprocessor resubmits it with the fills already on chain (Chapter 10). The Ledger credits exactly the fills the program recorded, so no trader’s entry ever reflects a swap that did not execute.
Exit
To withdraw, the trader signs an Exit request for an amount of asset to a destination address of their choice. The request travels sealed to the Coprocessor like an Intent; once its delay has passed (Chapter 8) the Coprocessor checks inside the enclave, debits the leaf, and lists the Exit in the Commit’s exits root; a permissionless release_exit then pays from the vault to the destination against that root (Chapter 9). The destination can be any address, including a fresh one or a Ring. An Exit into a Ring lands in a shielded balance whose assets and amounts are encrypted from then on [2]. Chapter 8 analyses Exit timing, denominations and delays as countermeasures against linkage.
Escape
If no Commit lands for slots, any trader can call trigger_escape. The program freezes the Ledger at the last committed root and opens the Escape. Each owner submits a claim with their leaf’s inclusion proof under ; Council members publish decryption shares for that leaf, re-encrypted to the owner’s key, with proofs of correct decryption; once shares are verified, the owner learns the balance and the program pays to the owner’s chosen address after checking a proof that the claimed amount matches the ciphertext, settling the fills of a Crossing left open at the halt across the holders of the assets it spent. Chapter 6 gives the protocol step by step and proves that the Escape pays every owner exactly their last committed balance and pays nobody else.
The lifecycle
Trust domains
Privium’s guarantees rest on five domains, each trusted for a specific statement and bounded by checks from the others. The table lists them; the paragraphs below describe the bound on each.
| Domain | Trusted for | Bounded by |
|---|---|---|
| Solana consensus and runtime | executing the Pool program as written; ordering transactions | the chain’s own security |
| Coprocessor enclave | correct decryption, crossing arithmetic and re-encryption; secrecy of plaintext in use | remote attestation of the measurement; on-chain signature and conservation checks; the Escape |
| Council | secrecy of the Ledger key below threshold; release of shares only to the attested enclave or the owner | threshold ; proofs of correct decryption; proactive resharing |
| Oracle | a mid price within its published confidence | the limit price of each Intent; the confidence filter |
| Jupiter and venues | executing the Residual at a market price | the enclave-signed min_out checked by the program |
The enclave is trusted for computation and for confidentiality of plaintext while it is in use. Its operator is not trusted for anything. Encifher states the same trust base for its coprocessor: TEE integrity, honest threshold key management and the cloud attestation root [1]. What the enclave can and cannot do is bounded from both sides. It cannot move a token the public checks do not account for, because the program verifies vault conservation against public flows on every Commit. It cannot sign under any key other than the one bound to its measurement, because the Registry accepts only attested keys (Chapter 5). And it cannot hold traders’ funds hostage, because its silence for slots opens the Escape.
The Council is trusted below threshold: fewer than members together learn nothing about the Council secret or the Ledger data key, and honest members suffice to complete an Escape. Every share a member publishes is accompanied by a proof that it is the correct partial decryption under that member’s committed key share, so a dishonest member can withhold but cannot corrupt (Chapter 6).
The oracle is trusted only to the extent that a trader’s own limit lets it be. A crossed fill happens at only if that price satisfies the limit of every Intent it fills, so a wrong mid can cause a fill the trader would have accepted anyway at that price, or no fill, but never a fill outside the trader’s limit. The confidence filter keeps the Coprocessor from crossing at all when the oracle’s own uncertainty is wide.
The keys are separated along the same lines. The trader’s wallet key signs deposits and one message from which the SDK derives the rest (Chapter 10): the authority key that signs Intents and Exit requests, the viewing root that decrypts the trader’s own leaves (Chapter 11), and the escape key that claims an Escape payout. The Ledger data key exists only inside admitted enclaves, and the Council secret behind exists only as -of- shares. The Coprocessor’s epoch keys exist only inside the enclave that generated them, bound to its measurement and registered with a validity interval (Chapter 5). A Viewing key, when a trader issues one, decrypts that trader’s leaves and nothing else (Chapter 11).
Design goals as properties
We state Privium’s design goals as properties of the system. Each statement names the assumption it rests on and the chapter that proves it. The precise games and definitions are given in the owning chapters; here we fix what each property says.
Property 2.1 (Custody). For every asset and every committed Crossing ,
where is the part of the vault the Ledger does not owe traders at root : committed Exits not yet released and deposits not yet credited (Chapter 4). Every Residual fill of Crossing is absorbed by Commit , so none is outstanding at a committed root. Moreover, tokens leave a vault only through an Exit authorized by the balance’s owner, a Residual swap that satisfies its signed bound, or an Escape payment to the balance’s owner. Rests on: Solana’s execution of the Pool program and the integrity of the enclave’s arithmetic; the second sentence rests on the program alone. Proved in: Chapter 4 (conservation theorem) and Chapter 9 (the program’s checks).
The release rule is enforced by code anyone can read and holds whatever the enclave does; the equality (2.5) concerns the partition of each vault among traders, which only the enclave sees, while the public check on every Commit keeps the vault itself equal to the public flows.
Property 2.2 (Confidentiality). For every trader , asset and Crossing , an adversary that sees all on-chain state, all ciphertexts, all encrypted Intents, and the shares of fewer than Council members distinguishes the Ledger and Intent contents of any two executions with the same public trace (1.2) of Chapter 1 with advantage at most . Rests on: the integrity and confidentiality of the enclave, the IND-CCA2 security of the Intent encryption and of , the semantic security of the Ledger ciphertexts, and an honest threshold of the Council. Proved in: Chapter 3 (reductions) and Chapter 4 (the Ledger).
Property 2.3 (Unlinkability). Within a Crossing, an observer cannot attribute any Intent, fill or balance change to a trader beyond what the boundary events (deposits and Exits) reveal. Across the boundary, the probability that an observer links a given Exit to its originating deposit is bounded by a function of the anonymity set of the Pool over the interval between them, measured by its min-entropy :
where is the deposit that funded the Exit and the view is everything the observer sees. Rests on: Property 2.2, and the Pool’s activity over the interval. Proved in: Chapter 8, which defines the unlinkability game, computes as a function of Pool activity, and shows how amount denominations, exit delays and Ring Exits raise it.
Property 2.4 (Liveness). If the Coprocessor submits a valid Commit at least once every slots, a Crossing begins as soon as there is something to settle and slots have passed since the last Commit, every Intent that is eligible at a Crossing’s cutoff is processed in that Crossing, and every Exit request enters an exits root at the first Commit after its delay (Chapter 8). With nothing to settle, a live Coprocessor sends a heartbeat Commit 750 slots after the last (Chapter 10), so the gap between Commits stays far inside whatever the trading activity. If no Commit lands within slots, every owner of a nonzero leaf under the last committed root can obtain that balance at an address of their choice, provided Council members respond. Rests on: Solana’s liveness for the Commit and Escape transactions, and honest and available Council members for the Escape. Proved in: Chapter 6 (the Escape safety theorem) and Chapter 10 (Commit submission and retries).
Property 2.5 (Price fairness). Every crossed fill on pair in Crossing executes at , and every fill respects its Intent’s limit:
The routed portion executes at a price no worse than the bound the enclave signed, and the allocation of crossed and routed quantity among Intents follows a published rule whose fairness properties are proved. Rests on: the integrity of the enclave, the oracle within its confidence filter, and the program’s check of each min_out. Proved in: Chapter 7, which also gives the expected-cost inequality that makes a crossed fill cheaper than the same trade routed, and the ordering analysis of a batched Residual against individual swaps.
Price fairness here has the same content as the best-execution obligation of a broker that internalizes: a client crossed internally receives the midpoint, and a client routed receives a market price within a bound, and neither can be filled outside their limit. The difference is that in Privium the rule is executed by attested code and its public consequences are checked by a program.
Property 2.6 (Auditability by the owner). A trader holding their viewing root can, using only public data, decrypt every one of their leaves, verify each leaf’s inclusion under the committed root for every , and reconstruct their balance history. The trader can delegate exactly this capability to a holder of a Viewing key, disclose a single entry, or issue a Receipt, an enclave-attested statement about their realized results that anyone can verify against the Registry without learning the trader’s wallet. Rests on: the ciphertext diffs that every Commit publishes on Solana, and the security of the enclave’s signing key. Proved in: Chapter 4 (inclusion), Chapter 11 (Viewing keys and Receipts).
Auditability belongs to the owner and to whomever the owner chooses. The design follows the disclosure model that Rings established on Solana, where an owner reads their own balance with a viewing key and can disclose a single transaction with a transaction viewing key [2], and extends it to trading results through the Receipt.
Summary
| Property | Statement in one line | Rests on | Chapter |
|---|---|---|---|
| 2.1 Custody | vaults equal the Ledger plus unreleased Exits, fees and uncredited deposits; tokens leave only by owner, bound or Escape | Solana; enclave arithmetic | 4, 9 |
| 2.2 Confidentiality | Ledger and Intents indistinguishable given the public trace | enclave; IND-CCA2; Council threshold | 3, 4 |
| 2.3 Unlinkability | linkage bounded by the anonymity set’s min-entropy | 2.2; Pool activity | 8 |
| 2.4 Liveness | a Crossing once work waits and has passed since the last Commit; a heartbeat Commit otherwise; Escape after | Solana liveness; honest Council members | 6, 10 |
| 2.5 Price fairness | crosses at mid, limits respected, routed within signed bound | enclave; oracle filter; program check | 7 |
| 2.6 Auditability by the owner | owner decrypts and verifies their history; delegates by Viewing key or Receipt | on-chain ciphertext diffs; | 4, 11 |
Parameters introduced
The overview has introduced the protocol’s parameters by symbol. Each is fixed, with a recommended value and its reason, in the chapter that owns its mechanism: the batch interval , the oracle confidence filter and the Residual slippage bound in Chapter 7; the liveness window and the Council size and threshold in Chapter 6; the heartbeat interval and the resting-order scan in Chapter 10; the key epoch length in Chapter 5; denominations, exit delays and the decoy floor in Chapter 8; and the fee rate , 0.10%, in Chapter 12. Two of them interact at the level of the whole system. The batch interval sets how much opposing flow each Crossing collects, and so how much of each order is crossed at the mid rather than routed; the liveness window must span many batch intervals, so that one delayed Commit never opens the Escape. Chapter 12 derives the crossing rate as a function of and order flow, and Chapter 6 sets more than two thousand batch intervals long.
References
- N. Lokhande, R. Gupta, R. Chahar, A. Jangra, A. Prajapati, M. Kumari, “Encifher: A Trusted-Execution Coprocessor for Confidential Computation on Solana”, IACR ePrint 2026/1504, July 2026. https://eprint.iacr.org/2026/1504
- “Solana Privacy Rings”, Helius, 2026. https://www.helius.dev/blog/solana-privacy-rings
- “Best Practices”, Pyth Network price feeds documentation, accessed 16 November 2026. https://docs.pyth.network/price-feeds/best-practices
- “Swap API”, Jupiter Developer Docs, accessed 16 November 2026. https://developers.jup.ag/docs/swap-api