08Unlinkability
  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 8

Unlinkability

Confidentiality hides what a balance holds; unlinkability hides whose it is. A trader in Privium deposits from one wallet, trades through sealed Intents, and exits to another, and the question this chapter answers is how well an observer can connect the two wallets, or connect either of them to the trades in between. We fix three adversaries, define the public transcript they see, and measure what it says about any one trader with Shannon entropy and min-entropy over the anonymity set. We then bound the three channels through which linkage leaks in any shielded pool (amounts, timing, and flow) and give the countermeasures that close each one: denominations, exit delays and Ring exits. The chapter ends with a formal unlinkability game and the theorem Privium achieves in it: the cryptographic layers leak nothing beyond a stated leakage function, and the statistical bounds of the earlier sections measure exactly what that function reveals.

What the chain shows

Privium’s public surface is small and fixed. Every Intent is encrypted to the Coprocessor’s attested key (Chapter 3 gives the HPKE construction, Chapter 5 the attestation), and Intents reach the enclave through its relay or as opaque blobs posted by a relayer, so no Intent carries a trader’s wallet on chain. The Ledger is a Merkle root over ciphertext leaves (Chapter 4). What remains visible is the movement of tokens across the boundary of the Pool and the net flow per pair.

Definition 8.1 (Leakage function). For an execution of Privium up to Crossing kk, the leakage L(k)\mathcal{L}^{(k)} is the sequence of:

  1. Deposits (w,a,d,t)(w, a, d, t): source wallet ww, asset aa, amount dd, slot tt.
  2. Exits (w′,a,e,t)(w', a, e, t): destination address w′w', asset, amount, slot.
  3. Residuals (k,π,spent,got)(k, \pi, \text{spent}, \text{got}) for every pair with a routed Residual (Chapter 7).
  4. Commit metadata: the root ρ(k)\rho^{(k)}, the Crossing index, the slot the Commit lands in, the number of live leaves, the set of assets it carries (empty for a heartbeat Commit, Chapter 10), the rewrite pattern (for each asset the Commit carries, the positions it vacates and the positions it fills), and the success or failure of each public instruction.

Commits follow a rewrite discipline built on the leaf of Chapter 4. In every asset a Commit carries, it rewrites the leaves the Crossing changed together with decoys drawn uniformly from the asset’s other live leaves, so that at least m0=64m_0 = 64 leaves of the asset are rewritten (parameter: one aggregated range proof covers 64 leaves at 16.5 bytes per leaf, Chapter 4, and a batch of 64 hides each changed leaf among 63 others). Each Crossing that settles also carries one asset in a fixed rotation over the admitted assets, whether the Crossing changed it or not, so no single carried asset shows that it moved; a heartbeat Commit carries no asset. Every rewritten leaf moves to a fresh uniform position with a fresh owner tag, fresh commitment randomness and fresh ciphertexts. In the Encifher model, on which the Ledger builds, programs hold only handles to ciphertexts [10]; Privium publishes the ciphertexts on Solana itself (Chapter 4). Everything an observer of the chain sees is then computable from L(k)\mathcal{L}^{(k)} plus ciphertexts whose distribution does not depend on plaintext. Theorem 8.9 makes this precise.

The table compares that surface with a trader’s footprint when trading from a wallet.

Observable Trading from a wallet Trading through Privium
Wallet behind each swap yes no swap carries a trader wallet
Size and side of each order yes only the net Residual per pair per Crossing
Balance history yes ciphertext leaves under one root
Entry and exit of funds the same wallet deposit and exit, linked only through L\mathcal{L}
Position across tokens yes not observable

Adversary model

We consider three adversaries of increasing reach. All three are computationally bounded in λ=128\lambda = 128 and see every Solana transaction, including every ciphertext the Commits publish.

  • Chain observer Achain\mathcal{A}_{\text{chain}}: passive; sees the full transcript.
  • Wallet tracker Atrack\mathcal{A}_{\text{track}}: additionally holds auxiliary labels on wallets (exchange deposit addresses, known traders) and controls a set C⊂U\mathcal{C} \subset \mathcal{U} of Pool accounts of its own, through which it may deposit, trade and exit freely. Clustering of addresses by co-spending and change heuristics is the standard toolkit of such an adversary [6].
  • Timing analyst Atime\mathcal{A}_{\text{time}}: additionally exploits slot-level timing of deposits and exits, including the heuristic that a withdrawal close in time to a deposit of matching amount came from it, one of the heuristics Wang et al. used to link deposits to withdrawals in zero-knowledge mixers [5].

The guarantees in this chapter rest on three assumptions, each proved or specified elsewhere: the integrity and confidentiality of the Coprocessor enclave (Chapter 5), an honest threshold of the Council, with fewer than tt of nn shares in adversarial hands (Chapter 6), and the IND-CCA2 security of the Intent encryption and the security of the Ledger’s ciphertexts (Chapters 3 and 4). Traders who disclose through a Viewing key or a Receipt disclose by choice (Chapter 11), and the game below excludes those disclosures for its challenge accounts.

The anonymity set and its measures

Definition 8.2 (Anonymity set). For an Exit ee at slot tet_e, the anonymity set N(e)\mathcal{N}(e) is the set of honest accounts u∈U∖Cu \in \mathcal{U} \setminus \mathcal{C} that hold a live Ledger leaf at tet_e. Write N(e)=∣N(e)∣N(e) = |\mathcal{N}(e)|.

Because every pair crosses against the quote asset and balances are encrypted, any live account can fund an Exit in any asset: an account that deposited SOL may exit in USDC after a Crossing, and nothing public says it traded. The set is therefore every live honest account, not only those that deposited the exited asset.

Size alone overstates protection when some members are much more likely than others. Let UeU_e be the random variable “the owner of ee”, and let Pe(u)=Pr⁡[Ue=u∣L]P_e(u) = \Pr[U_e = u \mid \mathcal{L}] be the adversary’s posterior.

Definition 8.3 (Entropy measures). The Shannon anonymity of ee is H(Ue∣L=L)=−∑uPe(u)log⁡2Pe(u)\mathsf{H}(U_e \mid \mathcal{L} = L) = -\sum_u P_e(u) \log_2 P_e(u), with effective set size 2H2^{\mathsf H} [1]. The degree of anonymity is d(e)=H/log⁡2N(e)∈[0,1]\mathsf{d}(e) = \mathsf{H}/\log_2 N(e) \in [0,1] [2]. The min-entropy anonymity is H∞(Ue∣L=L)=−log⁡2max⁡uPe(u)\mathsf{H}_\infty(U_e \mid \mathcal{L} = L) = -\log_2 \max_u P_e(u), and the average conditional min-entropy over transcripts is

H~∞(Ue∣L)=−log⁡2EL[max⁡uPr⁡[Ue=u∣L=L]].(8.1)\tilde{\mathsf H}_\infty(U_e \mid \mathcal{L}) = -\log_2 \mathbb{E}_{L}\Big[\max_u \Pr[U_e = u \mid \mathcal{L} = L]\Big] . \tag{8.1}

Shannon entropy measures the average uncertainty; min-entropy measures the adversary’s best single guess, and is the right measure for a tracker who acts on one guess. Smith argues for min-entropy on exactly these grounds in quantitative information flow [3].

Lemma 8.1 (Ordering of measures). For every ee and transcript, H∞(Ue∣L)≤H(Ue∣L)≤log⁡2N(e)\mathsf{H}_\infty(U_e \mid L) \leq \mathsf{H}(U_e \mid L) \leq \log_2 N(e), with both equalities if and only if the posterior is uniform on N(e)\mathcal{N}(e).

Proof. H=E[−log⁡2Pe(U)]≥min⁡u(−log⁡2Pe(u))=H∞\mathsf{H} = \mathbb{E}[-\log_2 P_e(U)] \geq \min_u (-\log_2 P_e(u)) = \mathsf{H}_\infty, with equality iff PeP_e is constant on its support. The upper bound is Gibbs’ inequality against the uniform distribution on N(e)\mathcal{N}(e), with equality iff PeP_e is that distribution. Both conditions coincide when the support is all of N(e)\mathcal{N}(e). □\square

The set as a function of Pool activity

The anonymity set grows with the Pool. Model honest account openings as a stationary process with rate λU\lambda_{\mathcal U} per slot and account lifetimes (slots from first deposit to last exit) with mean E[TU]\mathbb{E}[T_{\mathcal U}].

Proposition 8.2 (Set size). In steady state, E[N]=λU E[TU]\mathbb{E}[N] = \lambda_{\mathcal U}\,\mathbb{E}[T_{\mathcal U}].

Proof. The number of live honest accounts is the number of customers in a stationary queueing system with arrival rate λU\lambda_{\mathcal U} and mean sojourn time E[TU]\mathbb{E}[T_{\mathcal U}]; Little’s law gives the time-average number in the system as their product, for any arrival and sojourn distributions with finite means [8]. □\square

Two consequences follow. The Pool’s anonymity set is not the number of trades but the number of resident accounts, and an account that stays in Privium as its trading account, the way a client stays at a broker, raises E[TU]\mathbb{E}[T_{\mathcal U}] and with it everyone’s set. Second, only honest accounts count: an adversary who opens accounts of its own does not enlarge the set it has to search, because it knows which members are its own. Proposition 8.2 bounds the ceiling; the next sections bound how close the posterior stays to uniform below it.

Linkage channels

A shielded pool leaks through the amounts and times at its boundary and through the aggregate flow it shows inside. We bound each channel in turn.

Amount correlation

An Exit of exactly the amount a unique deposit brought in links the two with near certainty. Kappos et al. showed that matching the values that enter and leave Zcash’s shielded pool links a substantial part of its transactions [4]. The bound we need is a general fact about how much any observation can leak.

Lemma 8.3 (Min-entropy leakage of a finite observation). Let UU be secret and OO an observation taking at most MM values. Then

H~∞(U∣O)  ≥  H∞(U)−log⁡2M.(8.2)\tilde{\mathsf H}_\infty(U \mid O) \;\geq\; \mathsf{H}_\infty(U) - \log_2 M . \tag{8.2}

Proof. EO[max⁡uPr⁡[U=u∣O]]=∑omax⁡uPr⁡[U=u,O=o]≤∑omax⁡uPr⁡[U=u]=M⋅2−H∞(U)\mathbb{E}_O[\max_u \Pr[U = u \mid O]] = \sum_o \max_u \Pr[U = u, O = o] \leq \sum_o \max_u \Pr[U = u] = M \cdot 2^{-\mathsf H_\infty(U)}. Taking −log⁡2-\log_2 gives (8.2). This is the bound of Smith [3]: leakage is at most the logarithm of the number of distinguishable outputs. □\square

Lemma 8.3 is useless for exact amounts, where MM is as large as the token’s range, and decisive for denominated ones.

Definition 8.4 (Denominations). For asset aa with dad_a decimals, the denomination unit is δa=10da−2\delta_a = 10^{d_a - 2} base units (parameter: one hundredth of a whole token keeps the sub-unit remainder that stays in the Ledger below any meaningful size), and the denomination set is Da={δa2j:0≤j<J}\mathcal{D}_a = \{\delta_a 2^j : 0 \leq j < J\} with J=24J = 24 (parameter: 24 binary denominations cover a single Exit of up to (224−1)δa(2^{24}-1)\delta_a, about 1.68×1051.68 \times 10^5 whole tokens). A denominated Exit of amount ee is executed as the pieces δa2j\delta_a 2^j for each set bit jj of ⌊e/δa⌋\lfloor e / \delta_a \rfloor, each piece a separate Exit with its own delay (next section). Deposits through the SDK are split the same way.

Theorem 8.4 (Amount leakage under denominations). Each denominated piece lowers the adversary’s average min-entropy about its owner by at most log⁡2J\log_2 J bits. If deposits are denominated as well, the candidate set for a piece of denomination δa2j\delta_a 2^j is the set of honest accounts live at its slot, and no exact-match link exists.

Proof. A piece’s amount takes at most JJ values, so (8.2) with M=JM = J gives the first claim. For the second, a piece of denomination δa2j\delta_a 2^j is a sum the Ledger can debit from any account whose encrypted balance covers it, and since deposits arrive in the same denominations, every denomination class contains every honest depositor who used that class; balances after trading are not observable, so the amount does not narrow the set below the live accounts. □\square

The contrast is sharp. With exact amounts, a deposit of 1,234.567 USDC followed by an Exit of 1,234.567 USDC is a fingerprint. With denominations, both are sums of pieces shared by everyone in the same class, and the pieces themselves are scattered in time.

Timing correlation

An Exit soon after a deposit, in a quiet Pool, has few plausible sources. We bound the timing analyst’s success in a continuous-time model with slots as the unit.

Model. Honest deposits in the relevant class (one denomination of one asset, or all deposits if amounts are not denominated) form a stationary Poisson process with rate λ\lambda per slot. Each deposit’s matching Exit occurs after a holding time TT drawn independently with density gg bounded by gmax⁡g_{\max}. The adversary Atime\mathcal{A}_{\text{time}} sees all deposit slots in the class and the slot tet_e of a target Exit, and guesses which deposit it came from.

Theorem 8.5 (Timing bound). The adversary’s success probability is at most

Pr⁡[link]  ≤  6 gmax⁡λ.(8.3)\Pr[\text{link}] \;\leq\; \frac{6\, g_{\max}}{\lambda} . \tag{8.3}

Proof. Condition on a target Exit at tet_e. By the Palm property of the Poisson process (Slivnyak’s theorem), the other deposits form a Poisson process of rate λ\lambda independent of the target, whose own deposit lies at te−T∗t_e - T^\ast with T∗∼gT^\ast \sim g. All deposits being exchangeable a priori, the posterior that deposit jj is the source is proportional to g(te−tj)g(t_e - t_j), so the best guess succeeds with probability

max⁡jg(te−tj)g(T∗)+S,S=∑j≠∗g(te−tj),\frac{\max_j g(t_e - t_j)}{g(T^\ast) + S}, \qquad S = \sum_{j \neq \ast} g(t_e - t_j) ,

which is at most min⁡(1,gmax⁡/S)\min(1, g_{\max}/S). Campbell’s theorem gives E[S]=λ∫0∞g=λ\mathbb{E}[S] = \lambda \int_0^\infty g = \lambda and Var⁡[S]=λ∫0∞g2≤λ gmax⁡\operatorname{Var}[S] = \lambda \int_0^\infty g^2 \leq \lambda\, g_{\max}. By Chebyshev, Pr⁡[S<λ/2]≤Pr⁡[∣S−λ∣≥λ/2]≤4gmax⁡/λ\Pr[S < \lambda/2] \leq \Pr[|S - \lambda| \geq \lambda/2] \leq 4 g_{\max}/\lambda. On the complement, gmax⁡/S≤2gmax⁡/λg_{\max}/S \leq 2 g_{\max}/\lambda. Hence Pr⁡[link]≤4gmax⁡/λ+2gmax⁡/λ\Pr[\text{link}] \leq 4 g_{\max}/\lambda + 2 g_{\max}/\lambda. □\square

The bound depends on the holding-time density only through its peak. A Pool whose traders hold for varied times is already hard to time; the danger is a sharp peak, a trader who always exits a fixed number of slots after depositing. An exit delay flattens every peak.

Corollary 8.6 (Exit delay). If each Exit is executed after an additional delay DD drawn independently from the exponential distribution with mean μ\mu slots, then for any trader behavior

Pr⁡[link]≤6λμ,H~∞≥log⁡2λμ6.(8.4)\Pr[\text{link}] \leq \frac{6}{\lambda \mu}, \qquad \tilde{\mathsf H}_\infty \geq \log_2 \frac{\lambda \mu}{6} . \tag{8.4}

Proof. The holding time becomes T=T0+DT = T_0 + D with T0T_0 independent of DD, so its density is the convolution g=g0∗fDg = g_0 * f_D, and g(t)=∫g0(s)fD(t−s) ds≤sup⁡fD∫g0=1/μg(t) = \int g_0(s) f_D(t - s)\,ds \leq \sup f_D \int g_0 = 1/\mu for any distribution of T0T_0, including a point mass. Substitute gmax⁡≤1/μg_{\max} \leq 1/\mu into (8.3); the entropy bound is (8.1) applied to the success probability. □\square

The exponential is the natural choice: its peak density is 1/μ1/\mu, and it is memoryless, so an observer who has waited tt slots since an Exit request learns nothing about the remaining delay. The Coprocessor samples DD inside the enclave at the moment the Exit request is decrypted, so the schedule is unknown to everyone, the requester included. The recommended mean is μ=9,000\mu = 9{,}000 slots (parameter): 30 minutes at the slot time of Chapter 9, long enough to cover half an hour of Pool deposits and short enough for a trading account. A trader can request an immediate Exit, which is then bounded by (8.3) with the trader’s own holding-time density.

Denominations and delays compose. With denominated amounts, each piece is timed against deposits of its own denomination only, so λ\lambda in (8.4) becomes the class rate λj\lambda_j; the pieces of one Exit are delayed independently, so they arrive interleaved with other accounts’ pieces of other denominations and are not observable as one Exit.

Flow correlation

Inside the Pool the public traces of trading are the Residual, the rewrite pattern and the Crossings’ times. For pair π\pi in Crossing kk, L\mathcal{L} contains the vault deltas of the routed size R~π(k)\tilde R^{(k)}_\pi (Chapter 7), the positions rewritten in each carried asset, and nothing about the crossed size XπX_\pi, the number of Intents, or their owners.

Apart from the heartbeat, which carries no asset and settles nothing, a Crossing goes on chain only when it settles something (Chapter 10), so its slot shows that the Pool had work in that batch, and its carried set shows in which assets, alongside the one in rotation. What the work was, a trade, a cancel, a deposit credit, an Exit piece, an expiry or a resting order the market reached, and whose it was, stays sealed: the schedule of Crossings follows the slots at which Intents reached intake, their expiries and limits against the live price, and the boundary events of L\mathcal{L}, and takes no account identity as input.

Proposition 8.7 (Residual and rewrite leakage). Under the rewrite discipline and the confidentiality of the enclave: (a) for every honest account uu and every Crossing, the adversary’s posterior that uu had an Intent in pair π\pi given L\mathcal{L} is the same for any two honest accounts with identical public deposit and exit records; (b) for any leaf, the adversary’s largest posterior that a given position holds it never increases from one Crossing to the next, and is at most 1/m01/m_0 from the first rewrite of the leaf onward.

Proof. (a) The Residual is a deterministic function of the multiset of eligible Intents’ sizes, sides and limits, the mid and the seed (Chapter 7); it does not take account identities as input. The slot and carried set of each Crossing are functions of the times and assets of the work it settles, which carry no account identity either. A rewrite batch is a set of vacated and filled positions with fresh tags and ciphertexts, which carry no plaintext and no account identity under the assumptions of Theorem 8.9. Two honest accounts with identical public records are therefore exchangeable given L\mathcal{L}, so their posteriors coincide. (b) Within a batch of m≥m0m \ge m_0 leaves, the leaves are relocated to uniform fresh positions and their new public parts are independent of the old ones (Theorem 4.3), so the map from vacated to filled positions is uniform in the adversary’s view. A filled position therefore receives the average of the posterior mass on the vacated positions, at most max⁡⋅m/m=max⁡\max \cdot m / m = \max, and a position outside the batch keeps its mass. After the leaf is in a batch, its mass is spread over m≥m0m \ge m_0 positions, each at most 1/m01/m_0. □\square

A Residual reveals that someone in the Pool traded a net amount in a pair; it never reveals who, and a Crossing in which buyers and sellers cancel leaves no public trace beyond its Commit’s slot and rewrite batches that look like decoys. Every deposit credit is itself a rewrite batch, so from the first Crossing that touches a leaf the rewrite pattern locates it only to within m0m_0 positions. The tracker’s tools that read a wallet’s history and react to its next move [7] have no wallet to read.

Countermeasures in the product

The three countermeasures are defaults in the SDK and the Coprocessor, not settings a trader has to find.

Denominations. The SDK splits deposits and Exits into Da\mathcal{D}_a pieces by Definition 8.4; the sub-δa\delta_a remainder stays in the trader’s Ledger balance.

Exit delays. Each piece is scheduled by the enclave with an independent exponential delay of mean μ\mu, giving (8.4) per denomination class.

Ring exits. An Exit can land in a Helius Ring instead of a wallet. The default Ring encrypts assets and amounts while wallets stay visible; Custom Rings can be configured anonymous, encrypting counterparties and balances, with mainnet release targeted for Q4 2026 [9]. An Exit through a Ring adds a second, independent mixing stage, and the two stages compose.

Lemma 8.8 (Composition). Let a funds path pass from a deposit wallet ww through a Privium Exit into a Ring and out to a wallet w′w', and let the observations of the two stages be independent given the intermediate Ring deposit ZZ. If the best success probability of linking ww to its Pool Exit is εP\varepsilon_P and that of linking a Ring deposit to its Ring withdrawal is εR\varepsilon_R, then the probability of linking ww to w′w' is at most min⁡(εP,εR)\min(\varepsilon_P, \varepsilon_R).

Proof. Give the adversary, in addition to its view, the identity of ZZ‘s Ring withdrawal. This can only raise its success. Given that, the Ring stage is fully revealed and linking ww to w′w' is exactly linking ww to ZZ, which succeeds with probability at most εP\varepsilon_P. Symmetrically, revealing the link from ww to ZZ reduces the task to the Ring stage, bounded by εR\varepsilon_R. Each bound holds for the original adversary, which knows less. □\square

The listing shows the SDK’s Exit with the defaults written out, and the denomination split.

export interface ExitOptions {
  denominate?: boolean;              // default true: split into D_a pieces
  delay?: "default" | "none";        // default: enclave samples D ~ Exp(mu) per piece
  via?: "wallet" | "ring";           // ring: land in a Helius Ring
}

export function denominate(amount: bigint, unit: bigint, J: number): bigint[] {
  let units = amount / unit;
  const pieces: bigint[] = [];
  for (let j = 0; j < J && units > 0n; j++, units >>= 1n) {
    if (units & 1n) pieces.push(unit << BigInt(j));
  }
  if (units > 0n) throw new Error("amount exceeds largest denomination run; split the Exit");
  return pieces;
}

export async function exit(
  client: PriviumClient,
  asset: PublicKey,
  amount: bigint,
  to: PublicKey,
  opts: ExitOptions = {},
): Promise<ExitTicket> {
  const unit = client.denominationUnit(asset);
  const pieces = opts.denominate === false ? [amount] : denominate(amount, unit, client.params.J);
  const request = {
    asset, to, pieces,
    delay: opts.delay ?? "default",
    via: opts.via ?? "wallet",
    nonce: client.nextNonce(),
  };
  const sealed = await client.sealToCoprocessor(request); // HPKE to the attested key
  return client.relay.submit(sealed);
}

The request travels like an Intent: sealed to the Coprocessor and relayed, so neither the destination nor the split is visible until each piece executes. The ticket lets the SDK track pieces as they land.

The unlinkability game

The statistical bounds measure what L\mathcal{L} reveals. What remains is to prove that the rest of Privium’s transcript, every ciphertext, signature and root, reveals nothing more. We state this as an indistinguishability game in which the adversary must tell which of two accounts it chose funded an Exit.

Definition 8.5 (Game ExpAunl(λ)\mathsf{Exp}^{\text{unl}}_{\mathcal A}(\lambda)).

  1. Setup. The challenger runs Privium’s setup: the Coprocessor generates (skC,pkC)(sk_C, pk_C) inside the enclave and registers it (Chapter 5); the Council runs key generation (Chapter 6). The adversary receives all public keys and the key shares of any t−1t - 1 Council members of its choice.
  2. Oracles. The adversary may open accounts, deposit, submit Intents and request Exits for any account, advance slots (which runs Crossings and Commits), and corrupt any account, receiving its keys and Viewing key. It sees every transaction, every ciphertext the Commits publish, and every Commit.
  3. Challenge. The adversary names two honest accounts u0,u1u_0, u_1 and an Exit request (asset, amount, destination, options). The challenger draws b∈{0,1}b \in \{0, 1\} and executes the Exit from ubu_b.
  4. Admissibility. The challenger runs every subsequent query in both worlds, b=0b = 0 and b=1b = 1, and answers it only if the leakage L\mathcal{L} it produces is identical in both; otherwise the query is refused. u0,u1u_0, u_1 may not be corrupted, and Receipts and Viewing-key disclosures of u0,u1u_0, u_1 are not available.
  5. Output. The adversary outputs b′b'. Its advantage is AdvAunl=∣2Pr⁡[b′=b]−1∣\mathsf{Adv}^{\text{unl}}_{\mathcal A} = |2\Pr[b' = b] - 1|.

Admissibility rules out the trivial wins: if u0u_0 could not afford the Exit, or a later Intent of u0u_0 would be funded in one world and not the other, the difference would appear in L\mathcal{L}, and that is the leakage the statistical sections measure, not a break of the cryptography.

Theorem 8.9 (Unlinkability). Let the Coprocessor be realized by an enclave whose integrity and confidentiality hold except with advantage εTEE\varepsilon_{\text{TEE}} (Chapter 5), let the Intent encryption be IND-CCA2 with advantage εHPKE\varepsilon_{\text{HPKE}}, let the Ledger ciphertexts be IND-CPA with advantage εAE\varepsilon_{\text{AE}} under nonce discipline (Chapters 3 and 4), let Commits follow the rewrite discipline, and let the adversary hold fewer than tt Council shares. For any adversary making at most qIq_I Intent and Exit requests and observing at most qLq_L leaf ciphertexts,

AdvAunl(λ)  ≤  2(εTEE+qI εHPKE+qL εAE)+negl(λ).(8.5)\mathsf{Adv}^{\text{unl}}_{\mathcal A}(\lambda) \;\leq\; 2\big(\varepsilon_{\text{TEE}} + q_I\,\varepsilon_{\text{HPKE}} + q_L\,\varepsilon_{\text{AE}}\big) + \mathsf{negl}(\lambda) . \tag{8.5}

Proof. We move from the real game with b=0b = 0 to a game whose view is a function of L\mathcal{L} alone, then back to b=1b = 1 by the same steps in reverse. Each hop changes the adversary’s output distribution by at most the stated term.

Hybrid 0. The real game with b=0b = 0.

Hybrid 1. Replace the Coprocessor by an ideal functionality that receives plaintext Intents and Exit requests over a private channel, computes Crossings and Exits by the specification of Chapter 7, and outputs only signed Residual orders, Exit transfers and Commits. The adversary’s view changes by at most εTEE\varepsilon_{\text{TEE}}, by the integrity and confidentiality of the enclave: the enclave’s outputs are the specified function of its inputs, and its memory and sealed keys are not observable.

Hybrid 2. Replace every Intent and Exit ciphertext from an honest account by an encryption of the all-zero message of the same padded length under ekCek_C, while the functionality still receives the true plaintexts. A distinguisher between consecutive sub-hybrids yields an IND-CCA2 adversary against the Intent encryption: the reduction answers decryption queries for adversarial ciphertexts through its decryption oracle, which is exactly what the adversary’s own Intents require, and embeds the challenge ciphertext at one position. A hybrid over qIq_I positions costs qI εHPKEq_I\,\varepsilon_{\text{HPKE}}.

Hybrid 3. Replace every honest account’s leaf ciphertext in every Commit by an encryption of zero under fresh randomness. Leaf keys are held inside the ideal functionality, so a distinguisher yields an IND-CPA adversary against the Ledger encryption; nonce discipline ensures each encryption uses a fresh nonce, the condition under which AES-256-GCM’s confidentiality bound applies. A hybrid over qLq_L ciphertexts costs qL εAEq_L\,\varepsilon_{\text{AE}}. The rewrite pattern is an element of L\mathcal{L} under the rewrite discipline, and the leaves are now independent of balances.

Hybrid 4. Replace the adversary’s t−1t - 1 Council shares by uniformly random field elements. With fewer than tt shares of a Shamir sharing, the shares are uniformly distributed and independent of the secret (Chapter 6), so this change is perfect. The Council’s public outputs in the execution, which arise only in an Escape, are simulatable from L\mathcal{L} and the decryption proofs of Chapter 6, whose zero-knowledge simulators are perfect or statistical; we absorb this in negl(λ)\mathsf{negl}(\lambda).

In Hybrid 4 every component of the view is either an element of L\mathcal{L}, a ciphertext of a fixed message, a signature by the ideal functionality on a message determined by L\mathcal{L} (Residual orders and Commit roots over zero-ciphertexts), or uniform randomness. The view is therefore a function of L\mathcal{L} and independent randomness. By admissibility, L\mathcal{L} is identical for b=0b = 0 and b=1b = 1, so Hybrid 4 is identically distributed for both values of bb. Reversing Hybrids 3 through 0 with b=1b = 1 gives the factor 2 in (8.5). □\square

Theorem 8.9 is the formal statement of what the earlier sections assumed: against Achain\mathcal{A}_{\text{chain}}, Atrack\mathcal{A}_{\text{track}} and Atime\mathcal{A}_{\text{time}}, Privium leaks exactly L\mathcal{L}, and every quantitative bound in this chapter is a bound on what L\mathcal{L} says. Corruption of accounts in C\mathcal{C} is already in the game, which is why the anonymity set of Definition 8.2 counts honest accounts only.

Corollary 8.10 (Unlinkability with countermeasures). Under the assumptions of Theorem 8.9, for a denominated, delayed Exit piece of denomination class jj, any adversary’s probability of identifying its source deposit is at most

6λjμ+1m0+2(εTEE+qI εHPKE+qL εAE)+negl(λ),(8.6)\frac{6}{\lambda_j \mu} + \frac{1}{m_0} + 2\big(\varepsilon_{\text{TEE}} + q_I\,\varepsilon_{\text{HPKE}} + q_L\,\varepsilon_{\text{AE}}\big) + \mathsf{negl}(\lambda) , \tag{8.6}

and, for a Ring exit, at most the minimum of this quantity and the Ring’s own linking probability.

Proof. By Theorem 8.9 the adversary’s view is, up to the cryptographic terms, a function of L\mathcal{L}. Within L\mathcal{L} the piece’s amount identifies only its class (Theorem 8.4), and within the class Corollary 8.6 bounds timing linkage by 6/(λjμ)6/(\lambda_j\mu); Proposition 8.7 (a) shows the Residuals add no information distinguishing honest accounts with equal public records. The rewrite pattern helps only if the adversary follows the piece’s leaf from the batch that credited the deposit to the batch that debits the Exit, which by Proposition 8.7 (b) it does with probability at most 1/m01/m_0; a union bound adds that term. Lemma 8.8 gives the Ring statement. □\square

Example

This is an example with illustrative inputs; none of its figures are measurements of Privium or of Solana.

Take one denomination class of USDC in which honest deposits arrive at λj=0.05\lambda_j = 0.05 per slot, and the recommended mean delay μ=9,000\mu = 9{,}000 slots. Then λjμ=450\lambda_j \mu = 450, and (8.4) gives a timing adversary at most 6/450≈1.3%6/450 \approx 1.3\% chance of naming the source deposit of a piece, or at least log⁡275≈6.2\log_2 75 \approx 6.2 bits of average min-entropy; the rewrite term of (8.6) adds at most 1/64≈1.6%1/64 \approx 1.6\% at m0=64m_0 = 64. Doubling either the deposit rate or the mean delay adds one bit.

For contrast, suppose the same trader exits an exact, unique amount with no delay, one slot after depositing it. The amount alone singles out the deposit, so the posterior has min-entropy zero, and no Pool size helps. The same trader with denominations and the default delay receives (8.6), and routing the Exit through an anonymous Ring caps the link by the Ring’s own bound as well (Lemma 8.8). The difference between those two outcomes is a pair of defaults the trader does not have to set.

References

  1. A. Serjantov, G. Danezis, “Towards an Information Theoretic Metric for Anonymity”, Privacy Enhancing Technologies (PET), 2002. https://doi.org/10.1007/3-540-36467-6_4
  2. C. Díaz, S. Seys, J. Claessens, B. Preneel, “Towards Measuring Anonymity”, Privacy Enhancing Technologies (PET), 2002. https://doi.org/10.1007/3-540-36467-6_5
  3. G. Smith, “On the Foundations of Quantitative Information Flow”, FoSSaCS, 2009. https://doi.org/10.1007/978-3-642-00596-1_21
  4. G. Kappos, H. Yousaf, M. Maller, S. Meiklejohn, “An Empirical Analysis of Anonymity in Zcash”, USENIX Security Symposium, 2018. https://www.usenix.org/conference/usenixsecurity18/presentation/kappos
  5. Z. Wang, S. Chaliasos, K. Qin, L. Zhou, L. Gao, P. Berrang, B. Livshits, A. Gervais, “On How Zero-Knowledge Proof Blockchain Mixers Improve, and Worsen User Privacy”, ACM Web Conference (WWW), 2023. https://arxiv.org/abs/2201.09035
  6. S. Meiklejohn et al., “A Fistful of Bitcoins: Characterizing Payments Among Men with No Names”, ACM Internet Measurement Conference, 2013. https://doi.org/10.1145/2504730.2504747
  7. “Photon vs Axiom: Solana Memecoin Terminal Comparison (2026)”, MadeOnSol, 2026. https://madeonsol.com/blog/photon-vs-axiom-solana-trading-terminal
  8. J. D. C. Little, “A Proof for the Queuing Formula: L = λW”, Operations Research 9(3), 1961. https://doi.org/10.1287/opre.9.3.383
  9. “Solana Privacy Rings”, Helius, 2026. https://www.helius.dev/blog/solana-privacy-rings
  10. 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