02System overview
  1. 01Introduction
  2. 02System overview
  3. 03Cryptographic foundations
  4. 04The confidential Ledger
  5. 05Trusted execution and attestation
  6. 06Threshold keys and the Escape
  7. 07The Crossing engine
  8. 08Unlinkability
  9. 09Solana program engineering
  10. 10The Coprocessor and the off-chain stack
  11. 11Selective disclosure and Receipts
  12. 12Economics and $PRV

Chapter 2

System overview

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 uu 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 skCsk_C and the HPKE key dkCdk_C inside the enclave; the Ledger data key kLk_L 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 ss 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 pkCpk_C, and that key is bound by remote attestation to a published enclave measurement (Chapter 5). Each Commit pays the protocol fee at rate ϕ\phi 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 nn members holding Shamir shares, with threshold tt, of the secret behind the Council key PCP_{\mathcal{C}}, 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 WW. 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 mπ(k)m^{(k)}_\pi 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 aa) SPL or Token-2022 token account holding Va(k)V^{(k)}_a, owned by the Pool’s program-derived authority deposits, Exits, the Residual swap, the Escape
Ledger root Crossing index kk, root ρ(k)\rho^{(k)}, 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 pkCpk_C, ekCek_C, YEY_E with validity intervals registration and rotation (Chapter 5)
Council config nn, tt, the Council key PCP_{\mathcal{C}}, 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 (u,a)↦bu,a(k)(u, a) \mapsto b^{(k)}_{u,a}. 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 ρ(k)\rho^{(k)} is the Merkle root over all leaves after Crossing kk. 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 skCsk_C, dkCdk_C and yEy_E, generated inside the enclave and bound to its measurement, and the Ledger data key kLk_L, 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 π=(a,q)\pi = (a, q) with aa the base asset and qq the quote asset.

Deposit

The trader uu sends dd units of qq to the Pool’s vault for qq with a deposit instruction. The instruction transfers the tokens and appends (q,d,note)(q, d, \mathsf{note}) to a deposit queue, where note\mathsf{note} 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

bu,q(k)=bu,q(k−1)+d.(2.1)b^{(k)}_{u,q} = b^{(k-1)}_{u,q} + d . \tag{2.1}

Intent

To buy xx units of aa at a price no worse than ℓ\ell, the trader builds the Intent i=(u,π,+1,x,ℓ,τ,ν)i = (u, \pi, +1, x, \ell, \tau, \nu), with expiry slot τ\tau and a fresh nonce ν\nu, 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 AuA_u, 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 Δ\Delta 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 τ\tau has passed or whose nonce has been seen, and groups the remainder by pair. For each pair it reads the oracle mid mπ(k)m^{(k)}_\pi and computes a fill fi∈[0,xi]f_i \in [0, x_i] for every eligible Intent under the limit constraints and the allocation rule of Chapter 7. The Residual is the signed net of the fills,

Rπ(k)=∑i∈Iπ(k)si fi,(2.2)R^{(k)}_\pi = \sum_{i \in \mathcal{I}^{(k)}_\pi} s_i \, f_i , \tag{2.2}

where Iπ(k)\mathcal{I}^{(k)}_\pi is the set of eligible Intents on π\pi in Crossing kk. The portion of buy flow matched by sell flow, min⁡(∑si=+1fi, ∑si=−1fi)\min\big(\sum_{s_i=+1} f_i,\ \sum_{s_i=-1} f_i\big), is crossed internally at the clearing price pπ(k)=mπ(k)p^{(k)}_\pi = m^{(k)}_\pi. It pays no DEX fee and moves no market. Only ∣Rπ(k)∣|R^{(k)}_\pi| units of aa are routed, in the direction of sgn⁡Rπ(k)\operatorname{sgn} R^{(k)}_\pi.

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

Δbu,a=sifi,Δbu,q=− sifi pˉi  −  ϕ fi pˉi,(2.3)\Delta b_{u,a} = s_i f_i, \qquad \Delta b_{u,q} = -\, s_i f_i \, \bar p_i \;-\; \phi \, f_i \, \bar p_i , \tag{2.3}

where pˉi\bar p_i is the trader’s average fill price over the crossed and routed portions and ϕ\phi is the protocol fee rate.

The Coprocessor then builds the Residual swap. It requests a route from Jupiter for ∣Rπ(k)∣|R^{(k)}_\pi| 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 ρ(k)\rho^{(k)}, and signs the Commit message:

σ(k)=SignskC(Mk),Mk=privium/commit/v1 ∥ idprog ∥ e ∥ k ∥ ρ(k−1) ∥ ρ(k) ∥ bodyk,(2.4)\sigma^{(k)} = \mathsf{Sign}_{sk_C}\big(M_k\big), \qquad M_k = \texttt{privium/commit/v1} \,\|\, \mathsf{id}_{\mathrm{prog}} \,\|\, e \,\|\, k \,\|\, \rho^{(k-1)} \,\|\, \rho^{(k)} \,\|\, \mathsf{body}_k , \tag{2.4}

with bodyk\mathsf{body}_k the header fields above (Chapter 4 defines MkM_k, Chapter 9 lays it out). The Pool program accepts the Commit only if its checks pass: the signature verifies under an admitted pkCpk_C 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 ρ(k−1)\rho^{(k-1)}, 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 ww of asset aa 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 bu,a(k−1)≥wb^{(k-1)}_{u,a} \ge w inside the enclave, debits the leaf, and lists the Exit in the Commit’s exits root; a permissionless release_exit then pays ww 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 WW slots, any trader can call trigger_escape. The program freezes the Ledger at the last committed root ρ(k⋆)\rho^{(k^\star)} and opens the Escape. Each owner submits a claim with their leaf’s inclusion proof under ρ(k⋆)\rho^{(k^\star)}; Council members publish decryption shares for that leaf, re-encrypted to the owner’s key, with proofs of correct decryption; once tt shares are verified, the owner learns the balance and the program pays bu,a(k⋆)b^{(k^\star)}_{u,a} 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 tt; proofs of correct decryption; proactive resharing
Oracle a mid price within its published confidence the limit price ℓ\ell 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 WW slots opens the Escape.

The Council is trusted below threshold: fewer than tt members together learn nothing about the Council secret or the Ledger data key, and tt 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 mπ(k)m^{(k)}_\pi 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 AuA_u that signs Intents and Exit requests, the viewing root vkuvk_u that decrypts the trader’s own leaves (Chapter 11), and the escape key yuy_u that claims an Escape payout. The Ledger data key kLk_L exists only inside admitted enclaves, and the Council secret behind PCP_{\mathcal{C}} exists only as tt-of-nn 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 aa and every committed Crossing kk,

∑u∈Ubu,a(k)  =  Va(k)  −  Πa(k),(2.5)\sum_{u \in \mathcal{U}} b^{(k)}_{u,a} \;=\; V^{(k)}_a \;-\; \Pi^{(k)}_a , \tag{2.5}

where Πa(k)\Pi^{(k)}_a is the part of the vault the Ledger does not owe traders at root ρ(k)\rho^{(k)}: committed Exits not yet released and deposits not yet credited (Chapter 4). Every Residual fill of Crossing kk is absorbed by Commit kk, 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 uu, asset aa and Crossing kk, an adversary that sees all on-chain state, all ciphertexts, all encrypted Intents, and the shares of fewer than tt 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 negl(λ)\mathsf{negl}(\lambda). Rests on: the integrity and confidentiality of the enclave, the IND-CCA2 security of the Intent encryption and of AE\mathsf{AE}, 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 H∞\mathsf{H}_\infty:

Pr⁡[link]  ≤  2−H∞(D∣view)+negl(λ),(2.6)\Pr[\text{link}] \;\le\; 2^{-\mathsf{H}_\infty(D \mid \text{view})} + \mathsf{negl}(\lambda), \tag{2.6}

where DD 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 H∞\mathsf{H}_\infty 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 WW slots, a Crossing begins as soon as there is something to settle and Δ\Delta 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 WW whatever the trading activity. If no Commit lands within WW slots, every owner of a nonzero leaf under the last committed root can obtain that balance at an address of their choice, provided tt Council members respond. Rests on: Solana’s liveness for the Commit and Escape transactions, and tt 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 π\pi in Crossing kk executes at pπ(k)=mπ(k)p^{(k)}_\pi = m^{(k)}_\pi, and every fill respects its Intent’s limit:

si(ℓi−pˉi)  ≥  0for every Intent i with fi>0.(2.7)s_i \big(\ell_i - \bar p_i\big) \;\ge\; 0 \qquad \text{for every Intent } i \text{ with } f_i > 0 . \tag{2.7}

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 vkuvk_u can, using only public data, decrypt every one of their leaves, verify each leaf’s inclusion under the committed root ρ(k)\rho^{(k)} for every kk, 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 Δ\Delta has passed since the last Commit; a heartbeat Commit otherwise; Escape after WW Solana liveness; tt 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; skCsk_C 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 Δ\Delta, the oracle confidence filter and the Residual slippage bound in Chapter 7; the liveness window WW and the Council size nn and threshold tt 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 ϕ\phi, 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 Δ\Delta and order flow, and Chapter 6 sets WW more than two thousand batch intervals long.

References

  1. 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
  2. “Solana Privacy Rings”, Helius, 2026. https://www.helius.dev/blog/solana-privacy-rings
  3. “Best Practices”, Pyth Network price feeds documentation, accessed 16 November 2026. https://docs.pyth.network/price-feeds/best-practices
  4. “Swap API”, Jupiter Developer Docs, accessed 16 November 2026. https://developers.jup.ag/docs/swap-api