11Selective disclosure and Receipts
  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 11

Selective disclosure and Receipts

A confidential account still has to be shown to the people who need to see it: an accountant closing a tax year, a fund administrator, a follower checking a caller’s record. Privium gives the trader two instruments for this. Viewing keys open the trader’s own Ledger entries to a chosen reader, scoped by asset, by period or down to a single entry. Receipts go the other way: instead of opening the data, the trader asks the Coprocessor for a signed statement about it (realized PnL over a period, volume, a return above a threshold), which anyone can verify against the chain and which names no wallet. This chapter defines both, with the key hierarchy, the PnL rules and the properties each provides, and the controls institutions attach to their accounts, including auditor keys in the form Helius Rings introduced [1].

Two ways to disclose

Disclosure on a public chain is all or nothing: a wallet’s history is either published in full or kept in a wallet nobody knows about. Rings changed the default for balances. “Only the user can decrypt their balances with a viewing key,” and the user can share ongoing read access or a transaction-specific viewing key that opens one transaction without the rest of the history [1]. Token-2022 confidential transfers reached the same place from the issuer’s side: a mint may carry a global auditor ElGamal key, and when it does, every transfer instruction carries an additional encryption of the amount under that key [2].

Privium carries both ideas into the trading account and adds a third that only an attested coprocessor makes possible. The three instruments differ in what the reader learns.

Instrument Reader learns Reader needs Trust the reader extends
Viewing key the plaintext of the Ledger entries the key covers the key and the Crossing diffs on Solana none
Auditor key every entry of an account, for as long as the account’s policy names the auditor the auditor’s own secret key and the Crossing diffs none
Receipt one statement computed over the trader’s entries, and nothing else the Receipt, the Registry, the Ledger root history the integrity of the enclave whose key signed it

A viewing key discloses data; a Receipt discloses a fact about data. A tax accountant wants the first. A follower wants the second, and is better served by it: a Receipt for, say, “realized PnL of +41,200+41{,}200 USDC over Crossings k0k_0 to k1k_1” lets the follower check the number without learning which tokens were traded, when, or from which deposit address.

The viewing key hierarchy

Where the owner component lives

Chapter 4 defines the Ledger leaf. For this chapter one property of it matters: every leaf of trader uu carries an owner component, the leaf’s plaintext encrypted under AE\mathsf{AE} with the leaf key ku,a=F(vku,a,"balance")k_{u,a} = \mathsf{F}(vk_{u,a}, \texttt{"balance"}), which only uu and the Coprocessor can derive. The Council handle in the same leaf serves the Escape (Chapter 6) and is never used for disclosure. Alongside balance leaves, the Coprocessor writes one entry record per event that touches uu (a deposit credit, a fill, a fee, an Exit debit), encrypted under the entry keys below and carried in the Crossing diff that the Commit seals through its data availability digest (Chapter 4, Definition 4.4). Viewing keys are keys to these owner components.

Deriving the root

A trader’s viewing root is derived from the wallet that opened the account, so it can be rebuilt on any device without a backup:

σu=Signsku(macct),vku=HKDF(σu, "privium/view/v1")(11.1)\sigma_u = \mathsf{Sign}_{sk_u}\big(m_{\mathrm{acct}}\big), \qquad vk_u = \mathsf{HKDF}\big(\sigma_u,\ \texttt{"privium/view/v1"}\big) \tag{11.1}

where macctm_{\mathrm{acct}} is the account message of Chapter 10, the one wallet signature from which the SDK also derives the authority key AuA_u and the escape key yuy_u under other labels. Ed25519 signatures are deterministic (RFC 8032 derives the nonce from the key and the message [3]), so the same wallet always yields the same σu\sigma_u, and the domain-separated message cannot be replayed as a transaction signature. The confidential-balances documentation derives encryption keys the same way, “deterministically derived from an owner signing key” and never reusing the signing key itself [2]. When the account is opened, the SDK encrypts vkuvk_u to the Coprocessor’s attested HPKE key ekCek_C (Chapter 3, Chapter 5) and the enclave keeps it in the trader’s record (Chapter 4). The Coprocessor already reads every balance in plaintext inside the enclave to compute a Crossing, so holding vkuvk_u adds nothing to what it can read; it lets the enclave encrypt each new entry to keys the trader can later hand out.

Asset keys and period trees

From the root, keys branch first by asset and then by time. Let F\mathsf{F} be HMAC-SHA-256 used as a PRF. The asset key is

vku,a=F(vku, "asset" ∥ a).(11.2)vk_{u,a} = \mathsf{F}\big(vk_u,\ \texttt{"asset"} \,\|\, a\big). \tag{11.2}

Time is divided into disclosure epochs of EE Crossings each, E=1E = 1 (parameter: one epoch per Crossing makes a period key exact to the Crossing; coarser epochs only shorten the tree). Under each asset key sits a binary tree of depth DD in the style of Goldreich, Goldwasser and Micali [4]: the root node is vku,avk_{u,a}, and each node vv has children

v0=F(v,0),v1=F(v,1).(11.3)v_0 = \mathsf{F}(v, 0), \qquad v_1 = \mathsf{F}(v, 1). \tag{11.3}

The leaf reached by the DD-bit path equal to epoch number ee is the epoch key vku,a,evk_{u,a,e}. With D=40D = 40 (parameter: 2402^{40} epochs outlast any realistic run of Crossings at any batch interval Chapter 7 considers), the tree never fills.

The key that encrypts entry jj of trader uu in asset aa during epoch ee is

ku,a,e,j=F(vku,a,e, "entry" ∥ j),(11.4)k_{u,a,e,j} = \mathsf{F}\big(vk_{u,a,e},\ \texttt{"entry"} \,\|\, j\big), \tag{11.4}

and the owner component of the entry is AE.Enc(ku,a,e,j,entry,ad)\mathsf{AE}.\mathsf{Enc}(k_{u,a,e,j}, \mathit{entry}, \mathit{ad}) with associated data ad=(idprog,a,e,j,H(u))\mathit{ad} = (\mathsf{id}_{\mathrm{prog}}, a, e, j, \mathsf{H}(u)), so a ciphertext cannot be moved to another position and still decrypt. The entry itself is referenced the way Encifher references all encrypted state, by a 128-bit handle [5], and its ciphertext is published on Solana in the Crossing diff.

Scoping a disclosure

A disclosure is a set of nodes. To open asset aa for epochs [e0,e1][e_0, e_1], the trader sends the minimal set of tree nodes whose subtrees cover exactly that range. To open one entry, the trader sends ku,a,e,jk_{u,a,e,j} alone, the per-transaction disclosure Rings offers [1]. To open everything, the trader sends vkuvk_u.

Scope Key handed over Size
Whole account, all time vkuvk_u 32 bytes
One asset, all time vku,avk_{u,a} 32 bytes
One asset, epochs [e0,e1][e_0, e_1] covering nodes of the period tree at most 2D2D nodes
One entry ku,a,e,jk_{u,a,e,j} 32 bytes

Lemma 11.1 (Range cover). For any 0≤e0≤e1<2D0 \le e_0 \le e_1 < 2^D there is a set NN of at most 2D−22D - 2 tree nodes whose subtrees’ leaves are exactly {e0,…,e1}\{e_0, \dots, e_1\}.

Proof. Walk the paths from the root to e0e_0 and to e1e_1. Below the node where they split, take every right sibling hanging off the path to e0e_0, every left sibling hanging off the path to e1e_1, and the two endpoints, merging any two chosen siblings into their parent. Each path contributes at most one node per level over at most D−1D - 1 levels, so ∣N∣≤2(D−1)|N| \le 2(D-1); every leaf strictly between e0e_0 and e1e_1 lies in exactly one chosen subtree, and each chosen subtree lies on the inner side of a boundary path. □\square

The guarantee the trader cares about is that the covering set opens nothing outside the range.

Theorem 11.2 (Scoped disclosure). Let NN be the covering set for [e0,e1][e_0, e_1] in asset aa. If F\mathsf{F} is a secure PRF and AE\mathsf{AE} is IND-CCA2 secure, then for any probabilistic polynomial-time reader A\mathcal{A} given NN and every ciphertext in the store, the advantage of A\mathcal{A} in distinguishing the owner components of any entry outside (a,[e0,e1])(a, [e_0, e_1]) from encryptions of random entries of equal length is negl(λ)\mathsf{negl}(\lambda).

Proof sketch. No ancestor of a node outside the subtrees of NN is in NN, and no such ancestor is computable from NN, since F\mathsf F only maps downward. Replace the tree hybrid by hybrid, top-down: in hybrid HdH_d, every node at depth ≤d\le d not in NN or below a node of NN is replaced by a uniform string. A distinguisher between Hd−1H_{d-1} and HdH_d breaks the PRF at a node at depth d−1d - 1 whose key is already uniform in Hd−1H_{d-1}, so each step costs at most the PRF advantage, and there are DD steps per asset and one step for the asset layer. In the final hybrid every entry key outside the range is uniform and independent of A\mathcal{A}‘s view, and an encryption under a uniform unseen key is indistinguishable from an encryption of a random entry under IND-CCA2. The total advantage is at most (D+1) AdvFprf+J⋅AdvAEcca(D + 1)\,\mathsf{Adv}^{\mathsf{prf}}_{\mathsf F} + J\cdot\mathsf{Adv}^{\mathsf{cca}}_{\mathsf{AE}} for JJ entries outside the range, which is negligible. □\square

A disclosure is therefore bounded in time by construction. A reader holding the node set for last quarter keeps reading last quarter and nothing that comes after it, because future epochs sit under nodes the reader was never given.

Rotation

A trader who has handed out vkuvk_u or an asset key closes future entries to that reader by rotating the root: the trader derives the next root from (11.1) with the label privium/view/vr\texttt{privium/view/v}r for a version counter rr, sends it to the enclave in a RotateViewing Intent, and from the next Crossing entries are encrypted under the new tree, with rr in their associated data. Entries already written stay readable to the old key’s holder; the next epoch begins under a key that holder never had.

Reading with a viewing key

The SDK’s reader takes a key bundle (the node set plus asset and root version, small enough for a QR code), fetches the covered entry ciphertexts from the Crossing diffs, derives each entry key from whichever bundle node is its ancestor, decrypts, and checks each diff against the accumulator δk\delta_k that an accepted Commit sealed (Chapter 4). A reader who reconstructs a history is therefore reading entries the Solana program accepted, not files a server chose to return.

Receipts

What a Receipt states

A Receipt is a statement the Coprocessor computes over one trader’s Ledger entries for a span of Crossings, signs with skCsk_C, and returns to the trader. The trader chooses which fields it carries.

Definition 11.1 (Receipt). A Receipt is a tuple

R=(ver, idprog, ψ, k0, k1, ρ(k1), Σ, pkψ, pkC, att_ref, sR)with signatureσC=SignskC("privium/receipt/v1" ∥ enc(R)),\mathcal{R} = \big(\mathit{ver},\ \mathsf{id}_{\mathrm{prog}},\ \psi,\ k_0,\ k_1,\ \rho^{(k_1)},\ \Sigma,\ \mathit{pk}_\psi,\ pk_C,\ \mathit{att\_ref},\ s_R\big) \quad\text{with signature}\quad \sigma_C = \mathsf{Sign}_{sk_C}\big(\texttt{"privium/receipt/v1"} \,\|\, \mathsf{enc}(\mathcal{R})\big),

where ψ\psi is the Receipt’s pseudonym, [k0,k1][k_0, k_1] the span of Crossings it covers, ρ(k1)\rho^{(k_1)} the Ledger root committed at the end of the span, Σ\Sigma a list of claims, pkψ\mathit{pk}_\psi a public key the trader controls, pkCpk_C the signing key, att_ref\mathit{att\_ref} the EnclaveKey record that binds pkCpk_C to an attested measurement (Chapter 5), and sRs_R the slot at which the enclave signed. enc\mathsf{enc} is a canonical, length-prefixed encoding.

A claim in Σ\Sigma is either an exact value or a predicate:

Claim Exact form Predicate form
Realized PnL in qq RPnL=v\mathrm{RPnL} = v RPnL≥θ\mathrm{RPnL} \ge \theta
Return on capital rTW=vr_{\mathrm{TW}} = v rTW≥θr_{\mathrm{TW}} \ge \theta
Traded notional in qq Vol=v\mathrm{Vol} = v Vol≥θ\mathrm{Vol} \ge \theta
Fills nfill=vn_{\mathrm{fill}} = v nfill≥θn_{\mathrm{fill}} \ge \theta
Fees paid in qq Fee=v\mathrm{Fee} = v none
Ending equity in qq Eq=v\mathrm{Eq} = v Eq≥θ\mathrm{Eq} \ge \theta
Assets traded the set of aa the count of aa

Predicate claims are the reason a Receipt can say less than a viewing key ever could. For example, a trader applying to a fund can prove “time-weighted return of at least 30% over the last 2,000 Crossings” without disclosing the actual return, the capital behind it, or the instruments. The enclave evaluates the predicate on plaintext and signs only its truth; the threshold θ\theta is the trader’s choice and appears in the Receipt.

The pseudonym and the holder key

A Receipt names no wallet. Its pseudonym is

ψ=F(vku, "receipt-id" ∥ label),(11.5)\psi = \mathsf{F}\big(vk_u,\ \texttt{"receipt-id"} \,\|\, \mathit{label}\big), \tag{11.5}

where label\mathit{label} is a string the trader picks. Using the same label across Receipts makes them carry the same ψ\psi, which is what a public caller wants: a stable handle whose track record accumulates. Using a fresh label makes each Receipt stand alone, which is what a trader applying to two funds wants. The holder key pkψ\mathit{pk}_\psi is derived the same way, skψ=F(vku,"receipt-key" ∥ label)sk_\psi = \mathsf{F}(vk_u, \texttt{"receipt-key"} \,\|\, \mathit{label}) mapped to an Ed25519 scalar, so the trader can answer a verifier’s challenge by signing a nonce with skψsk_\psi and show that the Receipt is theirs to present, while a copied Receipt in someone else’s hands cannot answer.

Producing a Receipt

The trader submits a ReceiptRequest Intent, encrypted to the Coprocessor’s HPKE key like any other Intent, carrying the span, the claim selection, the label and a proof of account control (a signature by uu‘s wallet over the request, verified inside the enclave and never published). The enclave recomputes the claims from the plaintext entries of uu between k0k_0 and k1k_1 using the rules in the next section, checks that ρ(k1)\rho^{(k_1)} is a root that has been accepted on chain, signs, and returns the Receipt through the same encrypted channel. No transaction is sent and nothing about the request reaches the chain.

use ed25519_dalek::{Signer, SigningKey};

pub const RECEIPT_DOMAIN: &[u8] = b"privium/receipt/v1";

#[derive(Clone, borsh::BorshSerialize)]
pub enum Claim {
    RealizedPnl { exact: Option<i128>, at_least: Option<i128> }, // quote base units
    TimeWeightedReturn { exact_bp: Option<i64>, at_least_bp: Option<i64> },
    Volume { exact: Option<u128>, at_least: Option<u128> },
    Fills { exact: Option<u32>, at_least: Option<u32> },
    Fees { exact: u128 },
    Equity { exact: Option<u128>, at_least: Option<u128> },
    Assets { mints: Option<Vec<[u8; 32]>>, count: u16 },
}

#[derive(Clone, borsh::BorshSerialize)]
pub struct ReceiptBody {
    pub ver: u8,
    pub pool_id: [u8; 32],
    pub psi: [u8; 32],
    pub k0: u64,
    pub k1: u64,
    pub root_k1: [u8; 32],
    pub claims: Vec<Claim>,
    pub holder_pk: [u8; 32],
    pub coproc_pk: [u8; 32],
    pub att_ref: [u8; 32], // EnclaveKey record address (Chapter 5)
    pub signed_slot: u64,  // s_R
}

pub struct Receipt { pub body: ReceiptBody, pub sig: [u8; 64] }

pub fn sign_receipt(sk_c: &SigningKey, body: ReceiptBody) -> Receipt {
    let enc = borsh::to_vec(&body).expect("canonical encoding");
    let mut msg = Vec::with_capacity(RECEIPT_DOMAIN.len() + enc.len());
    msg.extend_from_slice(RECEIPT_DOMAIN);
    msg.extend_from_slice(&enc);
    let sig = sk_c.sign(&msg).to_bytes();
    Receipt { body, sig }
}

The domain prefix keeps a Receipt signature from ever verifying as a Commit signature, which the same skCsk_C produces over a different prefix (Chapter 5 and Chapter 9 give the Commit message). Borsh serialization is canonical for these types, so verifier and signer agree on the bytes without a second encoding layer.

Verifying a Receipt

Anyone can verify a Receipt with public data and no account of their own:

  1. Decode the body and recompute the signed message with the domain prefix.
  2. Read the EnclaveKey record named by att_ref\mathit{att\_ref} from Solana and check that it records pkCpk_C as an admitted Coprocessor key whose validity interval contains sRs_R, and that sRs_R is not earlier than the Commit of Crossing k1k_1 (registration by remote attestation is Chapter 5).
  3. Verify σC\sigma_C under pkCpk_C with Ed25519.
  4. Check that ρ(k1)\rho^{(k_1)} is the root accepted by the Commit of Crossing k1k_1, from the Ledger root account’s history or the Commit transaction itself (Chapter 9).
  5. If the Receipt is being presented live, send a fresh nonce and check the presenter’s signature under pkψ\mathit{pk}_\psi.

The SDK wraps this as privium.receipts.verify(receipt), and a Receipt rendered as a link carries its encoded bytes in the fragment, so a verifier page checks it entirely in the browser.

Theorem 11.3 (Receipt soundness). Suppose Ed25519 is EUF-CMA secure, the enclave whose measurement is recorded in the Registry entry for pkCpk_C runs the measured code with skCsk_C confined to it (enclave integrity, Chapter 5), and the Ledger roots accepted on chain satisfy the conservation and transition rules of Chapter 4. Then for any Receipt that passes verification, every claim in Σ\Sigma is true of the entries committed under ρ(k1)\rho^{(k_1)} for the trader whose viewing root yields ψ\psi, evaluated by the rules of the next section.

Proof sketch. Let A\mathcal{A} output a verifying Receipt with a false claim. Inside the measured code, skCsk_C signs a message with the Receipt prefix only on the path that recomputes Σ\Sigma from the trader’s entries and checks ρ(k1)\rho^{(k_1)}, so by enclave integrity the enclave never signed this body. The Commit path signs under a different prefix, so no Commit signature is a valid Receipt signature on any body. Hence A\mathcal{A}‘s signature is a forgery on a message the signing oracle (the enclave, exposed through both paths) never signed, and A\mathcal{A} breaks EUF-CMA with the same probability. Step 4 of verification ties the Receipt to a root the program accepted, so the entries the claims describe are the ones the program’s checks bound, not an alternative history. □\square A Receipt rests on exactly what every Commit rests on.

Theorem 11.4 (Receipt unlinkability). Let R0\mathcal{R}_0 and R1\mathcal{R}_1 be Receipts issued with distinct labels, by the same trader or by two different traders. If F\mathsf{F} is a secure PRF, a party holding both Receipts and all public chain data distinguishes “same trader” from “different traders” with advantage at most negl(λ)\mathsf{negl}(\lambda) plus the advantage obtainable from the claims Σ0,Σ1\Sigma_0, \Sigma_1 and spans themselves.

Proof sketch. Replace F(vku,⋅)\mathsf{F}(vk_u, \cdot) with a random function; the change is undetectable by PRF security because vkuvk_u never leaves the trader and the enclave. In the hybrid, ψ\psi and pkψ\mathit{pk}_\psi are fresh uniform values for each distinct label, independent of uu. The remaining fields, k0,k1,ρ(k1),pkC,att_refk_0, k_1, \rho^{(k_1)}, pk_C, \mathit{att\_ref}, are functions of the span and of public chain state and do not depend on uu. What remains is the information in the claims, which the trader chose to disclose. □\square

The claims are the trader’s own lever. Chapter 8 quantifies how exact amounts correlate with deposits and Exits; predicate claims, or exact claims rounded to a resolution ϵR\epsilon_R the request names, add nothing to that correlation.

PnL rules

The arithmetic behind a Receipt is fixed in the measured code, so two traders with the same history receive the same numbers. The Coprocessor computes PnL in the quote asset qq, per Crossing, from the trader’s own entries.

Positions and cost basis

For trader uu and asset a≠qa \ne q, let Qa(k)Q^{(k)}_a be the position in base units after Crossing kk (equal to bu,a(k)b^{(k)}_{u,a}) and ca(k)c^{(k)}_a the average cost per unit in qq. A fill in Crossing kk of size xx at price pp (the clearing price pπ(k)p^{(k)}_\pi for a crossed fill, the executed Residual price for a routed fill, Chapter 7) with side ss changes the position by s xs\,x. Write Q=Qa(k−1)Q = Q^{(k-1)}_a and c=ca(k−1)c = c^{(k-1)}_a. Spot accounts hold no negative positions, so Q≥0Q \ge 0 and a sell satisfies x≤Qx \le Q.

A buy (s=+1s = +1) raises the position and averages the cost:

Q′=Q+x,c′=Q c+x pQ+x.(11.6)Q' = Q + x, \qquad c' = \frac{Q\,c + x\,p}{Q + x}. \tag{11.6}

A sell (s=−1s = -1) realizes the difference between price and basis on the quantity sold and leaves the basis of the rest unchanged:

Q′=Q−x,c′=c,ΔRPnL=x (p−c).(11.7)Q' = Q - x, \qquad c' = c, \qquad \Delta\mathrm{RPnL} = x\,(p - c). \tag{11.7}

Every fill also pays the protocol fee in qq (Chapter 12), which realized PnL subtracts:

RPnL(k0,k1)=∑k=k0k1(∑sells in kx (p−c)  −  ∑fills in kϕ x p).(11.8)\mathrm{RPnL}^{(k_0,k_1)} = \sum_{k=k_0}^{k_1} \Big( \sum_{\text{sells in } k} x\,(p - c) \;-\; \sum_{\text{fills in } k} \phi\, x\, p \Big). \tag{11.8}

Average cost is the default (parameter: it is path independent within a Crossing and needs one number per asset). A request may select first-in-first-out instead, and the Receipt records the method.

Deposits, Exits and the mark

A deposit of asset aa brings no trade history with it. The enclave sets its basis at the oracle mid of the Crossing that credits it, m(a,q)(k)m^{(k)}_{(a,q)}, so PnL inside Privium is measured from the moment the asset entered. An Exit removes quantity at the current average cost and realizes nothing: moving tokens out is not a trade. Both rules keep PnL a function of trading decisions alone.

Unrealized PnL and equity at the end of a span use the oracle mid of Crossing k1k_1:

UPnL(k1)=∑a≠qQa(k1)(m(a,q)(k1)−ca(k1)),Eq(k1)=bu,q(k1)+∑a≠qQa(k1) m(a,q)(k1).(11.9)\mathrm{UPnL}^{(k_1)} = \sum_{a \ne q} Q^{(k_1)}_a \big( m^{(k_1)}_{(a,q)} - c^{(k_1)}_a \big), \qquad \mathrm{Eq}^{(k_1)} = b^{(k_1)}_{u,q} + \sum_{a \ne q} Q^{(k_1)}_a\, m^{(k_1)}_{(a,q)}. \tag{11.9}

The mid is the same price Chapter 7 clears at, from the same Pyth feed the Coprocessor ingests (Chapter 10), so a Receipt’s mark is the mark at which the trader could have crossed in that Crossing.

Return on capital

A raw PnL figure says little without the capital behind it, and capital changes with deposits and Exits. Receipts report the time-weighted return, which removes the effect of external flows. Let k0=t0<t1<⋯<tM=k1k_0 = t_0 < t_1 < \dots < t_M = k_1 be the Crossings at which uu‘s account had a deposit or Exit, together with the endpoints. For each sub-span, let Eqtj−\mathrm{Eq}^{-}_{t_j} be equity just before the flow at tjt_j and Eqtj−1+\mathrm{Eq}^{+}_{t_{j-1}} equity just after the flow at tj−1t_{j-1}. Then

1+rTW=∏j=1MEqtj−Eqtj−1+.(11.10)1 + r_{\mathrm{TW}} = \prod_{j=1}^{M} \frac{\mathrm{Eq}^{-}_{t_j}}{\mathrm{Eq}^{+}_{t_{j-1}}}. \tag{11.10}

Lemma 11.5 (Flow invariance). Suppose that on each sub-span jj the trader’s decisions earn a return gjg_j on the equity the sub-span starts with, so that Eqtj−=(1+gj) Eqtj−1+\mathrm{Eq}^{-}_{t_j} = (1 + g_j)\,\mathrm{Eq}^{+}_{t_{j-1}}. Then rTW=∏j(1+gj)−1r_{\mathrm{TW}} = \prod_j (1 + g_j) - 1, whatever the sizes of the deposits and Exits at t1,…,tM−1t_1, \dots, t_{M-1}.

Proof. Substitute the hypothesis into (11.10): each factor equals 1+gj1 + g_j, and the flows enter only through Eqtj−1+\mathrm{Eq}^{+}_{t_{j-1}}, which cancels within its own factor. □\square

The lemma is what makes return comparable across traders of different size: a trader who doubles the account halfway through a span and keeps trading the same way reports the same return as one who never added a token.

Fee and volume lines

Traded notional is Vol=∑x p\mathrm{Vol} = \sum x\,p over all fills in the span and fees paid are Fee=∑ϕ x p\mathrm{Fee} = \sum \phi\,x\,p, crossed and routed fills alike. The crossed share of a trader’s volume is available as a further claim: the trader’s own crossing rate (Chapter 12).

Auditor keys and institutional accounts

The auditor key

A desk or a fund answers to someone who must see everything without asking the trader. Custom Rings meet this with “a separate auditor key” that grants read access to wallet balances inside the Ring under the policy the Ring configures [1], and Token-2022 meets it at the mint level with an auditor ElGamal key under which every confidential transfer carries an extra amount ciphertext [2]. Privium attaches the same role to an account.

An institutional account carries a policy record Pu\mathcal{P}_u, a Ledger leaf of kind 3 (Chapter 4) anchored like any other leaf. Among its fields is an optional auditor public key pkApk_A, an X25519 key for HPKE. When pkApk_A is set, the Coprocessor writes, next to each owner component, an auditor component: the entry encrypted with HPKE to pkApk_A, with the same associated data. The auditor reads with its own secret key and needs nothing from the trader. Because the auditor component is a separate ciphertext, the auditor’s access is independent of the trader’s viewing keys: rotating vkuvk_u does not close the auditor, and changing pkApk_A does.

Changing the policy is itself governed by the policy. Pu\mathcal{P}_u names a set of policy signers and a threshold tAt_A; a SetPolicy Intent carries tAt_A signatures over the new policy and the current policy’s hash, which the enclave checks before applying. A desk whose policy requires its compliance officer’s signature to change the auditor cannot have the auditor removed by a trader acting alone.

Proposition 11.6 (Auditor completeness). For an account whose policy has carried pkApk_A from Crossing kAk_A onward, every entry of that account written at or after kAk_A has an auditor component under pkApk_A, and the entry is published in the diff of its Crossing.

Proof sketch. The measured entry-writing path reads Pu\mathcal{P}_u from the same plaintext state it updates and emits the auditor component in the same step as the owner component, and both enter the Crossing diff that the Commit seals. By enclave integrity no entry is written by another path, and by the transition rules of Chapter 4 no root is accepted whose leaves were not produced by that path. □\square

Compliance hooks

Institutional policy goes beyond reading. The controls Custom Rings expose to institutions, allowlists and blocklists, freezes and additional required signatures enforced on Solana [1], are what a desk expects of its own account, and Privium’s policy record carries them as rules the enclave applies before it accepts an Intent:

Hook Field of Pu\mathcal{P}_u Applied at
Exit destinations allowlist of addresses, or a screening attestation required per Exit Exit Intent acceptance
Counter-signature set of co-signers and threshold for Exits above a size Exit Intent acceptance
Instrument set allowlist of assets the account may trade Intent acceptance in a Crossing
Position limits maximum QaQ_a per asset, maximum notional per Crossing Intent acceptance in a Crossing
Freeze a flag the policy signers set, holding all Intents except SetPolicy every Intent
Auditor pkApk_A every entry written

Each rule is checked inside the enclave on the plaintext Intent, so a desk’s limits are enforced with the same guarantee as its balances, without its limits or its positions becoming public. A rejected Intent produces an entry of its own, visible to the auditor, so the audit trail includes what a policy stopped as well as what it allowed.

Screening sits at the account’s edges, the only points where it touches a public address: a deposit’s source and an Exit’s destination. Helius lists Range, Chainalysis and Elliptic among the providers supporting wallet screening for Rings [1]. A policy that requires screening names the provider’s attestation key, and the enclave accepts an Exit only with a signed screening result for its destination.

Exits through a Ring

An institution that wants the exit itself confidential routes it through a Ring (Chapter 8). A Custom Ring, confidential or anonymous, carries its own auditor key and policy [1], so the books stay continuous: the auditor reads the Privium account through pkApk_A, the Ring balance through the Ring’s auditor key, and matches them on the Ring destination the Exit entry records.

The sharing flow

Disclosure is something a trader does in a few seconds from the account screen. The two paths split at the first choice: open data or prove a fact.

From the SDK, both paths are one call:

const bundle = await privium.disclose({ asset: "SOL", crossings: [k0, k1] });
const receipt = await privium.receipt({
  crossings: [k0, k1],
  claims: { realizedPnl: { atLeast: 10_000n * 10n ** 6n }, fills: "exact" },
  label: "public-calls",
});

disclose returns a bundle that opens exactly the stated scope; receipt returns a signed Receipt and its link. A trader who publishes calls under one label builds a record anyone can check Receipt by Receipt, under a pseudonym that never touches the deposit wallet.

References

  1. “Solana Privacy Rings”, Helius, 2026. https://www.helius.dev/blog/solana-privacy-rings
  2. “Confidential Balances: Overview”, Solana Program Library documentation, Anza. https://www.solana-program.com/docs/confidential-balances/overview
  3. S. Josefsson and I. Liusvaara, “Edwards-Curve Digital Signature Algorithm (EdDSA)”, RFC 8032, IETF, January 2017. https://www.rfc-editor.org/rfc/rfc8032
  4. O. Goldreich, S. Goldwasser and S. Micali, “How to Construct Random Functions”, Journal of the ACM 33(4), 1986. https://dl.acm.org/doi/10.1145/6490.6503
  5. N. Lokhande et al., “Encifher: A Trusted-Execution Coprocessor for Confidential Computation on Solana”, IACR ePrint 2026/1504, July 2026. https://eprint.iacr.org/2026/1504