12Economics and $PRV
  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 12

Economics and $PRV

Privium charges one fee, a rate ϕ\phi on the notional of every fill, and its economics come down to a comparison the trader makes on each order: what this trade costs through the Pool against what it costs as a swap from the trader’s own wallet. This chapter writes that comparison as math. It separates the three ways a unit of an order can be executed (crossed inside the Pool, routed as part of the Residual, or swapped directly), derives the crossing rate as a function of the flow a Crossing sees, and shows how the cost of trading through Privium falls as that flow grows. It then follows the fee out of the Ledger to the token’s launch wallet, through a market buyback of $PRV and a burn, and describes how the token launched. It closes with the build plan as milestones.

The fee

One rate on every fill

Every fill a trader receives in a Crossing pays

fee(x,p)=ϕ x p(12.1)\mathrm{fee}(x, p) = \phi \, x \, p \tag{12.1}

in the quote asset qq, where xx is the filled size in base units and pp the fill price: the clearing price pπ(k)p^{(k)}_\pi for a crossed fill and the executed Residual price for a routed one (Chapter 7 defines both). The rate is the same on both kinds of fill. A trader never needs to know in advance how much of an order will cross, and the Receipt’s fee line (Chapter 11) is the plain sum of (12.1) over the trader’s fills.

Privium sets ϕ\phi at 0.10% (10 bps). Every result below is stated for a general ϕ\phi, and the inequalities that compare Privium with a direct swap state the range of ϕ\phi for which they hold; at 10 bps a fully crossed order is cheaper than a direct swap whenever the venue fee, impact and ordering cost it avoids exceed 0.10% (Corollary 12.2).

Both sides of a crossed fill pay the fee, because both receive a fill. The Pool earns 2ϕ x p2\phi\,x\,p on a crossed quantity xx and ϕ x p\phi\,x\,p on each routed unit, so per unit of matched flow the protocol earns the same rate whether the counterparty was another trader or the market.

Where the fee is taken

The fee is computed inside the Coprocessor as part of the Crossing’s state transition and debited from each trader’s encrypted quote balance bu,q(k)b^{(k)}_{u,q} in the same step as the fill. It leaves the Ledger and the Pool in the same Commit: the Commit attests the Crossing’s fees Fq(k)F^{(k)}_q and pays them from the quote vault to the fee recipient that the Pool configuration names (Chapter 9). The Residual is routed through Jupiter with no integrator fee attached: Jupiter’s documentation states that “By default, there are zero protocol fees on Jupiter Swap,” and that an integrator may add one with platformFeeBps and a feeAccount [1]. Privium leaves both unset and takes its rate in the Ledger, so the routed leg pays exactly what the public route charges and the fee arithmetic lives in one place.

Because the Commit pays the fee out before it checks conservation (Chapter 4), no fee term remains in the vault identity. For the quote asset at every committed root,

∑u∈Ubu,q(k)  +  Xqpend  +  Pqdep  =  Vq(k),(12.2)\sum_{u \in \mathcal{U}} b^{(k)}_{u,q} \;+\; X^{\mathrm{pend}}_q \;+\; P^{\mathrm{dep}}_q \;=\; V^{(k)}_q , \tag{12.2}

with XqpendX^{\mathrm{pend}}_q the committed Exits not yet released and PqdepP^{\mathrm{dep}}_q the deposits not yet credited (Equation 9.2). Each trader’s fee is rounded down to whole units of qq, and Fq(k)F^{(k)}_q is the exact sum of those fees, so the vaults back trader balances to the last unit and the fee recipient receives exactly the fees the Commit attests.

Network costs

Each Crossing lands at least one Commit transaction and one Residual swap per routed pair, and their network fees are paid by the Coprocessor’s fee payer. Those costs are per Crossing, not per trader, so they fall per unit of traded notional as the batch grows. Write cnetc_{\mathrm{net}} for the network cost of one Crossing in qq and V(k)\mathcal{V}^{(k)} for its total filled notional; the amortized network cost per unit is cnet/V(k)c_{\mathrm{net}} / \mathcal{V}^{(k)}. For scale, Encifher settles a confidential swap in a single Solana transaction at 157,000 compute units [2]; Chapter 9 gives Privium’s own compute budget per instruction (est.). The analysis below folds cnetc_{\mathrm{net}} into the operator’s side of the ledger and keeps the trader’s cost to ϕ\phi plus execution.

The cost of a trade, three ways

Execution cost relative to the mid

Measure every cost as a fraction of notional, relative to the oracle mid m=mπ(k)m = m^{(k)}_\pi at the time the order is executed. For a pair π\pi on public liquidity, define:

  • fDf_D: the liquidity provider fee rate charged by the venues Jupiter routes through, as a fraction of notional.
  • I(x)I(x): the per-unit price impact and spread of swapping xx on public liquidity, so that a buy of xx pays m (1+I(x))m\,(1 + I(x)) per unit on average before fees. II is nondecreasing, I(0)=0I(0) = 0.
  • ξ(x)\xi(x): the expected per-unit value extracted from a public swap of xx by ordering (sandwiching and back-running), bounded above by the slippage tolerance the swap carries.

These are properties of Solana’s public liquidity at a given moment, not of Privium; Privium’s costs are expressed in the same terms so the two can be compared.

Direct swap

A trader who swaps xx from their own wallet pays

Cdir(x)=fD+I(x)+ξ(x).(12.3)C_{\mathrm{dir}}(x) = f_D + I(x) + \xi(x). \tag{12.3}

The third term is the one a public order exposes. A swap of size xx from a known wallet is visible as it is forwarded to the leader and in the wallet’s history before and after; Chapter 8 treats the information it leaks and Chapter 7 the ordering value it offers.

Crossed fill

A unit that crosses inside the Pool is filled at the clearing price, which Chapter 7 sets at the oracle mid subject to the limits of the intents involved. It touches no venue, so it pays no liquidity fee and has no impact, and it is never a public transaction of its own, so it offers nothing to order against. Its cost is the fee alone:

Ccross=ϕ.(12.4)C_{\mathrm{cross}} = \phi. \tag{12.4}

Routed fill

A unit that is not crossed is part of the Residual R=Rπ(k)R = R^{(k)}_\pi, the net quantity the Pool swaps on the trader’s side of the book. The Residual pays the public costs of a swap of size ∣R∣|R|, shared pro rata among the units it carries, plus the fee. Its ordering exposure is bounded by the slippage bound β=βπ(k)\beta = \beta^{(k)}_\pi that the enclave signs into the routed swap (Chapter 7):

Croute(R)=ϕ+fD+I(∣R∣)+ξR,ξR≤β.(12.5)C_{\mathrm{route}}(R) = \phi + f_D + I(|R|) + \xi_R, \qquad \xi_R \le \beta. \tag{12.5}

An order’s expected cost

Under the allocation rule of Chapter 7, an intent on side ss of pair π\pi has a crossed fraction θs\theta_s and a routed fraction 1−θs1 - \theta_s. With pro rata allocation, if X+X_{+} and X−X_{-} are the total active buy and sell sizes in the Crossing (Q+Q^+ and Q−Q^- of Chapter 7),

θs=min⁡ ⁣(1, X−sXs),(12.6)\theta_s = \min\!\left(1,\ \frac{X_{-s}}{X_{s}}\right), \tag{12.6}

so the smaller side crosses entirely and the larger side crosses in proportion. The intent’s cost per unit is

CP(θ,R)=ϕ+(1−θ)(fD+I(∣R∣)+ξR).(12.7)C_{\mathrm{P}}(\theta, R) = \phi + (1 - \theta)\big(f_D + I(|R|) + \xi_R\big). \tag{12.7}

Theorem 12.1 (When the Pool is cheaper). An order of size xx costs less through Privium than as a direct swap if and only if

ϕ  <  Γ(x,θ,R)  :=  θ (fD+I(x)+ξ(x))  +  (1−θ)(I(x)−I(∣R∣)+ξ(x)−ξR).(12.8)\phi \;<\; \Gamma(x, \theta, R) \;:=\; \theta\,\big(f_D + I(x) + \xi(x)\big) \;+\; (1 - \theta)\big(I(x) - I(|R|) + \xi(x) - \xi_R\big). \tag{12.8}

Proof. Subtract (12.7) from (12.3) and regroup: Cdir−CP=fD+I(x)+ξ(x)−ϕ−(1−θ)(fD+I(∣R∣)+ξR)C_{\mathrm{dir}} - C_{\mathrm{P}} = f_D + I(x) + \xi(x) - \phi - (1-\theta)(f_D + I(|R|) + \xi_R). Writing fD+I(x)+ξ(x)=θ(fD+I(x)+ξ(x))+(1−θ)(fD+I(x)+ξ(x))f_D + I(x) + \xi(x) = \theta(f_D + I(x) + \xi(x)) + (1-\theta)(f_D + I(x) + \xi(x)) and cancelling (1−θ)fD(1-\theta) f_D gives Cdir−CP=Γ−ϕC_{\mathrm{dir}} - C_{\mathrm{P}} = \Gamma - \phi. □\square

Γ\Gamma is the gross saving the Pool produces before its fee, and Theorem 12.1 says the fee is paid out of it. The two terms have clear readings. The first is everything a crossed unit avoids. The second is what a routed unit gains from being routed as part of a batch rather than alone: the difference in impact between the trader’s own size and the Residual, and the difference between the ordering exposure of a public wallet swap and that of a Pool swap bounded by β\beta.

Corollary 12.2 (Full crossing). For a fully crossed order (θ=1\theta = 1), Privium is cheaper whenever ϕ<fD+I(x)+ξ(x)\phi < f_D + I(x) + \xi(x), the whole cost of the direct swap.

Corollary 12.3 (Small orders in a large Residual). For an order with θ<1\theta < 1, if the Residual is no larger than the order, ∣R∣≤x|R| \le x, then I(∣R∣)≤I(x)I(|R|) \le I(x) and the second term of Γ\Gamma is at least (1−θ)(ξ(x)−ξR)(1-\theta)(\xi(x) - \xi_R), so the routed part costs no more in impact than the direct swap would have.

The group view

Theorem 12.1 is the view of one order. The same comparison summed over everyone in a Crossing shows where the saving comes from. Let the Crossing on pair π\pi hold buy intents of sizes x1,…,xn+x_1, \dots, x_{n_+} and sell intents of sizes y1,…,yn−y_1, \dots, y_{n_-}, with totals X+X_+ and X−X_-, and let R=X+−X−R = X_+ - X_-.

Proposition 12.4 (Group saving on liquidity fees). If each intent had instead been sent as its own public swap, the group would have paid liquidity fees of fD m (X++X−)f_D\,m\,(X_+ + X_-). Through the Pool it pays fD m ∣R∣f_D\,m\,|R|. The saving on liquidity fees alone is

fD m (X++X−−∣R∣)  =  2fD mmin⁡(X+,X−),(12.9)f_D\, m\,\big(X_+ + X_- - |R|\big) \;=\; 2 f_D\, m \min(X_+, X_-), \tag{12.9}

which is fDf_D times the crossed notional.

Proof. X++X−−∣X+−X−∣=2min⁡(X+,X−)X_+ + X_- - |X_+ - X_-| = 2\min(X_+, X_-), and only the Residual reaches a venue. □\square

The impact side of the group view depends on how public liquidity behaves between swaps. When arbitrage returns a pool to the external price between consecutive public swaps, each of the n++n−n_+ + n_- swaps pays its own impact, ∑ixiI(xi)+∑jyjI(yj)\sum_i x_i I(x_i) + \sum_j y_j I(y_j), against the Pool’s single ∣R∣ I(∣R∣)|R|\, I(|R|); the Pool’s impact is lower whenever

∣R∣ I(∣R∣)  ≤  ∑ixiI(xi)+∑jyjI(yj).(12.10)|R|\, I(|R|) \;\le\; \sum_i x_i I(x_i) + \sum_j y_j I(y_j). \tag{12.10}

When no arbitrage intervenes, a constant-product pool’s state depends only on the net quantity swapped, so the group’s total impact is the same either way and the Pool’s saving is (12.9) plus the ordering value. In both regimes the Pool removes the ordering exposure of every crossed unit and bounds that of every routed unit by β\beta.

Waiting for the batch

An intent waits for the next cutoff: Δ\Delta slots after the Commit in flight lands, or at once in an idle Pool (Chapter 7). Under the standard model in which the oracle mid is a martingale over the interval, the expected price change during the wait is zero, and the expected cost of waiting is zero; what the wait adds is variance, which a limit price ℓ\ell bounds (Chapter 7 sets Δ\Delta and treats limits). Expected cost (12.7) is therefore the complete expected cost of an intent under that model.

The crossing rate

Definition

The quantity that drives (12.7) across all traders is the share of filled volume that crosses, the crossing rate γπ\gamma_\pi of Chapter 7. For one pair in Crossing kk,

γπ(k)=2min⁡(X+,X−)X++X−=1−∣Rπ(k)∣X++X−.(12.11)\gamma^{(k)}_\pi = \frac{2\min(X_+, X_-)}{X_+ + X_-} = 1 - \frac{|R^{(k)}_\pi|}{X_+ + X_-}. \tag{12.11}

Averaged over traders by volume, the expected cost per unit of notional traded through Privium is

CˉP=ϕ+(1−γ)(fD+IˉR+ξˉR),(12.12)\bar C_{\mathrm{P}} = \phi + (1 - \gamma)\big(f_D + \bar I_R + \bar\xi_R\big), \tag{12.12}

where IˉR\bar I_R and ξˉR\bar\xi_R are the impact and ordering terms of the Residual. Equation (12.12) follows from (12.7) by weighting each intent’s routed fraction by its size: the routed volume is exactly ∣R∣|R|, which is (1−γ)(1-\gamma) of the total.

A model of flow

To see how γ\gamma moves with activity, model the intents on pair π\pi arriving in a Crossing as a Poisson number NN with mean Λ=λΔ\Lambda = \lambda \Delta, where λ\lambda is the arrival rate of intents per slot. Each intent independently is a buy with probability 12(1+η)\tfrac{1}{2}(1 + \eta) and a sell otherwise, where η∈[−1,1]\eta \in [-1, 1] is the flow imbalance, and has size drawn independently from a distribution with mean xˉ\bar x and coefficient of variation cxc_x, so E[x2]=xˉ2(1+cx2)\mathbb{E}[x^2] = \bar x^2 (1 + c_x^2).

The net quantity D=X+−X−D = X_+ - X_- is then a compound Poisson sum of signed sizes, with

E[D]=η Λ xˉ,Var[D]=Λ E[x2]=Λ xˉ2(1+cx2),E[X++X−]=Λ xˉ.(12.13)\mathbb{E}[D] = \eta\, \Lambda\, \bar x, \qquad \mathrm{Var}[D] = \Lambda\, \mathbb{E}[x^2] = \Lambda\, \bar x^2 (1 + c_x^2), \qquad \mathbb{E}[X_+ + X_-] = \Lambda\, \bar x. \tag{12.13}

The variance follows from the compound Poisson identity Var[∑i≤NZi]=E[N] E[Z2]\mathrm{Var}[\sum_{i \le N} Z_i] = \mathbb{E}[N]\,\mathbb{E}[Z^2] with Z=±xZ = \pm x, since Z2=x2Z^2 = x^2 regardless of sign.

For large Λ\Lambda, DD is approximately normal with these moments, and E∣D∣\mathbb{E}|D| is the mean of a folded normal. Writing μD=ηΛxˉ\mu_D = \eta \Lambda \bar x and sD=xˉΛ(1+cx2)s_D = \bar x \sqrt{\Lambda (1 + c_x^2)},

E∣D∣=sD2π e−μD2/(2sD2)+μD(1−2Φ(−μD/sD)),(12.14)\mathbb{E}|D| = s_D \sqrt{\tfrac{2}{\pi}}\, e^{-\mu_D^2 / (2 s_D^2)} + \mu_D \big(1 - 2\Phi(-\mu_D / s_D)\big), \tag{12.14}

with Φ\Phi the standard normal distribution function. Taking the ratio of expectations as the rate at large Λ\Lambda, the expected crossing rate is

γ(Λ,η)≈1−E∣D∣Λ xˉ.(12.15)\gamma(\Lambda, \eta) \approx 1 - \frac{\mathbb{E}|D|}{\Lambda\, \bar x}. \tag{12.15}

Proposition 12.5 (Balanced flow). With η=0\eta = 0,

γ(Λ,0)≈1−2(1+cx2)π Λ,(12.16)\gamma(\Lambda, 0) \approx 1 - \sqrt{\frac{2(1 + c_x^2)}{\pi\, \Lambda}}, \tag{12.16}

which increases in Λ\Lambda and tends to 11 at rate Λ−1/2\Lambda^{-1/2}.

Proof. With μD=0\mu_D = 0, (12.14) reduces to sD2/πs_D\sqrt{2/\pi}; divide by Λxˉ\Lambda \bar x. The expression is increasing in Λ\Lambda because Λ−1/2\Lambda^{-1/2} is decreasing. □\square

Proposition 12.6 (Imbalanced flow). With η≠0\eta \ne 0, γ(Λ,η)≤1−∣η∣\gamma(\Lambda, \eta) \le 1 - |\eta| for every Λ\Lambda, and γ(Λ,η)→1−∣η∣\gamma(\Lambda, \eta) \to 1 - |\eta| as Λ→∞\Lambda \to \infty.

Proof. By Jensen’s inequality E∣D∣≥∣ED∣=∣η∣Λxˉ\mathbb{E}|D| \ge |\mathbb{E}D| = |\eta|\Lambda\bar x, which gives the bound. As Λ\Lambda grows, μD/sD=ηΛ/(1+cx2)\mu_D / s_D = \eta \sqrt{\Lambda / (1 + c_x^2)} grows without bound in absolute value, the exponential term of (12.14) vanishes and 1−2Φ(−μD/sD)→sign⁡(η)1 - 2\Phi(-\mu_D/s_D) \to \operatorname{sign}(\eta), so E∣D∣/(Λxˉ)→∣η∣\mathbb{E}|D| / (\Lambda \bar x) \to |\eta|. □\square

The two propositions say what the crossing rate depends on. Randomness in who arrives on which side costs a term that shrinks as Λ−1/2\Lambda^{-1/2}, and so disappears with activity. Persistent one-sidedness costs ∣η∣|\eta|, which no amount of activity removes, and which is exactly the flow that has to reach the market: if more traders want to buy than sell, the difference is the Residual.

A worked example

The following figures are an example of the model, not measurements. Take balanced flow, η=0\eta = 0, and sizes with cx=1c_x = 1 (an exponential-like spread of order sizes). Then (12.16) gives γ≈1−4/(πΛ)\gamma \approx 1 - \sqrt{4 / (\pi \Lambda)}:

Intents per Crossing on the pair, Λ\Lambda 4/(πΛ)\sqrt{4/(\pi\Lambda)} Crossing rate γ\gamma
25 0.226 0.77
100 0.113 0.89
400 0.056 0.94
1,600 0.028 0.97

Each fourfold increase in Λ\Lambda halves the routed share. With η=0.2\eta = 0.2 the limit is γ→0.8\gamma \to 0.8, and the table’s values approach it from below.

Activity lowers everyone’s cost

Equation (12.12) together with Proposition 12.5 links the cost of trading through Privium to the activity the Pool sees:

∂CˉP∂Λ=−∂γ∂Λ(fD+IˉR+ξˉR)  <  0for η=0,(12.17)\frac{\partial \bar C_{\mathrm{P}}}{\partial \Lambda} = -\frac{\partial \gamma}{\partial \Lambda}\big(f_D + \bar I_R + \bar \xi_R\big) \;<\; 0 \quad\text{for } \eta = 0, \tag{12.17}

holding the Residual’s per-unit costs fixed. The same holds at any η\eta until γ\gamma reaches its limit 1−∣η∣1 - |\eta|. Λ=λΔ\Lambda = \lambda\Delta rises in two ways. More traders in the Pool raise λ\lambda, and every new trader lowers the expected cost for every existing one. A longer batch interval raises Δ\Delta, which trades crossing rate against waiting; Chapter 7 sets Δ\Delta with that trade in view. Because Λ\Lambda counts intents per pair, the crossing rate is highest on the pairs that carry the most flow, which are also the pairs where a trader’s orders are most watched.

Fee flow

The fee recipient

The Pool configuration names a fee recipient, the token’s launch wallet LL. Each Commit pays the Crossing’s fees Fq(k)F^{(k)}_q from the quote asset’s vault shard 0 to LL‘s associated token account for qq, in the instruction that attests them. The Pool authority signs the transfer: a program-derived address, for which no private key exists, so only the Pool program signs for it, through invoke_signed [3]. The program derives LL‘s token account from LL, the token program and the mint, so a Commit pays no other account (Chapter 9). The fee therefore never rests in an account of the Pool, and every fee payment is a token transfer inside a Commit transaction that anyone can read on chain. Only the admin key the configuration names changes LL.

Buyback and burn

A crank on Privium’s keeper signs as LL. On each interval it swaps the quote balance LL has received from Commits for $PRV through Jupiter, and burns exactly what each swap delivered. Each swap spends an amount AA of the quote asset, capped by a per-run limit Amax⁡A_{\max} (parameter: the cap keeps each purchase small against the token’s public liquidity so the buyback pays little impact, and repeated runs spread purchases over time), and requires the output to meet a minimum

outmin⁡=AP^ (1−βB),(12.19)\mathit{out}_{\min} = \frac{A}{\hat P}\,(1 - \beta_B), \tag{12.19}

where P^\hat P is the price of $PRV in qq that the crank’s Jupiter quote gives and βB\beta_B is the buyback slippage bound (parameter: the same role β\beta plays for the Residual, bounding what the swap can lose to ordering). The crank reads LL‘s $PRV balance before and after the swap and burns the increase with the SPL Token Burn instruction, signed by LL. The burn amount is the measured delivery, not the route’s claim, so it is exactly what the fees bought: the developer’s own first buy at launch, held in the same wallet, is never part of it.

The program carries no buyback instruction. It pays the fee to LL and stops there, and the buyback runs as LL‘s own transactions, each a Jupiter swap followed by a burn of its measured output.

Supply over time

Let S0=1,000,000,000S_0 = 1{,}000{,}000{,}000 be the fixed supply at launch. Over a period jj the protocol accrues fees Fj=ϕ Vj\mathcal{F}_j = \phi\,\mathcal{V}_j in qq, where Vj\mathcal{V}_j is the period’s total filled notional counted once per fill as in (12.1). If the period’s buybacks execute at an average price Pˉj\bar P_j, the tokens burned in the period and the supply after JJ periods are

Bj=ϕ VjPˉj,SJ=S0−∑j=1Jϕ VjPˉj.(12.20)\mathcal{B}_j = \frac{\phi\, \mathcal{V}_j}{\bar P_j}, \qquad S_J = S_0 - \sum_{j=1}^{J} \frac{\phi\, \mathcal{V}_j}{\bar P_j}. \tag{12.20}

Each unit of notional traded through Privium removes ϕ/Pˉj\phi / \bar P_j tokens from supply. By (12.1) and the two-sided fee on crossed fills, a crossed unit of base asset contributes 2ϕ p2\phi\,p to Fj\mathcal{F}_j and a routed unit ϕ p\phi\,p, so for a pair with crossing rate γ\gamma the fee per unit of net market demand ∣R∣|R| is

Fm ∣R∣=ϕ X++X−∣R∣=ϕ1−γ,(12.21)\frac{\mathcal{F}}{m\,|R|} = \phi\,\frac{X_+ + X_-}{|R|} = \frac{\phi}{1 - \gamma}, \tag{12.21}

up to the difference between fill prices and the mid. The higher the crossing rate, the more fee each unit of flow that reaches the market carries with it, which is the protocol’s side of the same activity that lowers each trader’s cost in (12.17).

Proposition 12.7 (Monotone supply). SJS_J is nonincreasing in JJ, and every token removed is removed by an on-chain burn signed by LL for the output of a buyback swap.

Proof. Fj≥0\mathcal{F}_j \ge 0 and Pˉj>0\bar P_j > 0, so each Bj≥0\mathcal{B}_j \ge 0. The mint and freeze authorities of $PRV are revoked, so no instruction can increase supply, and a burn only decreases it. □\square

$PRV

$PRV is the token of the protocol, ticker PRV, mint 9FSjffoh8Yk8jdpr9EEEuxTD6mphYayfboxZMKWVPRV, with a fixed supply of 1,000,000,000 at 6 decimals. It launched as a fair launch: the whole supply went to the public launch, where everyone bought on the same terms. Its mint and freeze authorities are revoked, which fixes the supply for good, and its metadata is immutable. The developer allocation is the developer’s own first buy at launch, made on the same terms as every other buyer. $PRV trades on a Raydium CPMM pool against ZEC, 7PscVHXMuzSDK1Abz2rP3BrunEjNYdJtc5aNxS1htnDQ.

The token’s role is the one the previous section describes in full. Every Commit pays the protocol’s fee share in qq to the launch wallet, and the crank turns it into market purchases of $PRV, each followed by a burn of exactly what it bought. Anyone can check this flow: each Commit’s fee transfer to LL, each swap LL signs and the burn after it, and the mint’s supply are all public transactions and accounts on Solana, and (12.20) reconciles them period by period against the filled notional the Commits record.

The fee rate that drives this is ϕ\phi, 0.10%. Equation (12.20) is linear in ϕ\phi and in Vj\mathcal{V}_j, and Theorem 12.1 bounds ϕ\phi by the saving the Pool produces, so the fee flow that reaches the token grows with the volume that finds Privium cheaper than a direct swap.

The build plan

Privium is built in two stages: the first build, a mainnet system that carries the complete custody and trading loop on two assets, and then the full product. Each milestone below lists what ships and the check that marks it done.

First build

Milestone 1 (Pool and Ledger). The Pool program with per-asset vaults for SOL and USDC, the Ledger root account, the Registry and the Council configuration (Chapter 9); the Coprocessor service with encrypted balances in the Ledger (Chapter 4) and an attested signing key registered on chain (Chapter 5). Done when a deposit credits an encrypted balance, a Commit lands with a verified enclave signature, and the conservation check of Chapter 4 passes at every root.

Milestone 2 (Crossings). Market-order Intents encrypted to the Coprocessor, Crossings at interval Δ\Delta with internal netting at the oracle mid, the Residual routed via Jupiter with a signed slippage bound (Chapter 7), and the fee of (12.1) paid to the fee recipient at every Commit. Done when a Crossing with opposing intents settles both at the mid, routes only ∣R∣|R|, and the fee recipient’s receipts match the fees the Commits attested.

Milestone 3 (Exit and Escape). Exits to any address, the Council’s distributed key generation, and the Escape path with liveness window WW (Chapter 6). Done when an Exit releases tokens to a fresh address and an Escape rehearsal with Commits halted pays every owner their last committed balance.

Milestone 4 (Mainnet). The first build on mainnet with SOL and USDC, the TypeScript SDK with privium.trade(...) and the indexer (Chapter 10), and the reproducible enclave build whose measurement matches the registered one. Done when traders deposit, trade and exit on mainnet and the measurement published with the build reproduces from source.

Full product

Milestone 5 (Token universe and limits). Every token Jupiter routes as a tradable asset against the quote, Token-2022 mints included (Chapter 9), and limit orders with expiry. Done when a limit Intent on a long-tail pair rests across Crossings, fills when its limit is met, and expires at τ\tau.

Milestone 6 (Disclosure). Viewing keys with the asset and period hierarchy, single-entry disclosure, and Receipts with exact and predicate claims, with the SDK’s disclose, receipt and receipts.verify (Chapter 11). Done when a Receipt verifies in a browser from public chain data alone.

Milestone 7 (Ring exits). Exits through a Helius Ring, default and Custom (Chapter 8). Done when an Exit lands as a Ring deposit and the trader withdraws it from the Ring.

Milestone 8 (Institutional accounts). Policy records with auditor keys, Exit allowlists, counter-signatures, instrument sets, position limits and screening hooks (Chapter 11). Done when an auditor reads every entry of a policy account with its own key and a policy-blocked Exit appears in the auditor’s trail.

Milestone 9 (Buyback). The buyback crank, signing as the launch wallet, with Amax⁡A_{\max}, βB\beta_B and its interval in the keeper’s configuration. Done when the first run swaps the fees LL received through Jupiter, burns the measured output and the mint’s supply falls by that amount.

Milestone 10 (Council and enclave breadth). Proactive resharing across Council rotations (Chapter 6) and a second enclave platform registered by its own attestation path (Chapter 5). Done when a rotation completes with the Ledger’s threshold key unchanged and Commits from both platforms verify against the Registry.

The milestones are ordered by dependency. Milestones 1 to 4 are the loop a trader needs: in, trade, out, and a guaranteed way out. Milestones 5 to 10 widen what the account holds, who can read it, where it can exit to, and what its fees do, each on the foundation the first build lays.

References

  1. “Add Fees To Swap”, Jupiter Developer Docs, Jupiter. https://developers.jup.ag/docs/swap-api/add-fees-to-swap
  2. 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
  3. “Program Derived Address (PDA)”, Solana Documentation, Solana Foundation. https://solana.com/docs/core/pda