The Council is the second root of Privium’s trust and the only one custody rests on. It holds a single secret , split -of- among its members so that no coalition below the threshold learns anything about it. The Council has two duties. It releases the Ledger data key to enclaves the Registry has admitted (Chapter 5), and it runs the Escape: if no Commit lands within the liveness window , it re-encrypts each owner’s last committed balance to that owner alone, and the Pool program pays the owner out on a proof that never touches an enclave. This chapter builds the Council’s key from first principles: Shamir sharing, Feldman and Pedersen verifiable sharing, distributed key generation, threshold decryption with proofs of correct decryption, re-encryption to a verified key, and proactive resharing as membership changes. It then specifies the Escape step by step and proves its safety and liveness. Group and proof preliminaries are in Chapter 3; the Ledger leaf whose Council handle the Escape decrypts is in Chapter 4.
6.1 What the Council holds
Encifher places decryption keys with a threshold committee so that no single enclave holds a master key [11]; Privium’s Council is that committee with a second duty, the Escape. The Council’s public key is the twisted ElGamal key of Definition 3.8, so that . Member holds a share and has a public verification key ; both and every are stored in the Council account on chain. Two objects are encrypted under :
- the wrapped Ledger data key (Chapter 5, equation 5.5);
- the Council handle of every Ledger leaf (Definition 4.2), which decrypts as
The leaf’s owner tag commits to the owner’s escape key (Chapter 4). The SDK derives deterministically from the trader’s wallet (Chapter 10), so a trader who keeps their wallet keeps their escape key.
The Council never computes (6.1) in public. It only re-encrypts, either to an admitted enclave’s key or to an owner’s key . The guarantees are:
| Property | Rests on |
|---|---|
| No coalition of fewer than members learns , or any balance | perfect secrecy of Shamir sharing, hiding of Pedersen VSS, DDH in |
| No Escape payout goes to anyone but the owner, or exceeds the committed balance | Merkle binding, soundness of the share and claim proofs, Commit authenticity (Theorem 5.2), the proofs of Theorem 4.2; this holds against a fully corrupt Council |
| Every owner completes the Escape | honest members live on chain |
Parameters. , (parameter): confidentiality tolerates four colluding members and the Escape completes with four offline; is the honest-majority setting in which the key generation of Section 6.4 is proven secure [4], and means any two quorums intersect.
6.2 Shamir sharing
To share with threshold , the dealer samples , sets , and gives member the share [1]. For any set of members, the Lagrange coefficients
satisfy , and because the map is linear the same coefficients work in the exponent of any base : . The member indices are distinct and nonzero modulo the prime , so every denominator is invertible.
Lemma 6.1 (Perfect secrecy). For any set of members and any two secrets , the distributions of under and under are identical.
Proof. Fix the share values . Polynomial interpolation through the points gives exactly one polynomial of degree at most , hence exactly one coefficient vector . The map from coefficients to the shares in is therefore a bijection for each fixed secret, and with uniform coefficients the shares are uniform on whatever the secret.
6.3 Verifiable secret sharing
Plain Shamir trusts the dealer. Members must be able to check their shares against public data, and in a distributed key generation every member is a dealer.
Feldman VSS
The dealer publishes for with [2]. Member accepts if and only if
Anyone can compute every verification key from the commitments alone. The cost is that is public, which is exactly what a public key should be, but it also means the dealer’s commitments reveal for every coefficient.
Pedersen VSS
The dealer samples a second polynomial , publishes , and sends [3]. Member accepts if and only if
The generator is derived by hashing to ristretto255 [10], so nobody knows .
Lemma 6.2. Pedersen VSS commitments are perfectly hiding: is independent of . Two different accepted share vectors for the same commitments, consistent with different secrets, yield .
Proof. Each with uniform is a uniform group element independent of . For binding, suppose two openings of (6.4) for the same interpolate to different ; interpolating both openings at in the exponent gives with , so . The denominator is nonzero because otherwise .
6.4 Distributed key generation
The Council’s key is generated without any party ever holding . Running parallel Feldman sharings and summing them (Joint-Feldman) is not enough: a rushing adversary who sees honest commitments before choosing its own can bias the resulting public key, which breaks the uniformity that security reductions for threshold ElGamal assume [4]. Privium uses the protocol of Gennaro, Jarecki, Krawczyk and Rabin, which first fixes the qualified set with hiding commitments and only then reveals the public key [4].
- Deal. Each member runs Pedersen VSS with a random secret : it posts to the Council account and sends to each member , encrypted with HPKE to ‘s registered key (Chapter 3) and posted on chain so delivery is publicly verifiable.
- Complain. Member checks (6.4) for every dealer and posts a complaint against each failure. A dealer answers a complaint by revealing that share pair in the clear; anyone checks it against (6.4). Dealers with an unanswered or failed complaint are removed. The remaining dealers form .
- Reveal. Each posts Feldman commitments . Member checks ; on failure it posts the share pair it received, which is valid under (6.4) and so proves the dealer’s misbehavior, and the other members reconstruct from their Pedersen shares to recompute in public.
- Output. , , and the Feldman keys and .
- Twist. The members run steps 1 to 4 again for a secret with Feldman commitments on base , giving shares and , and once more for a sharing of zero of degree with commitments . Each member posts with a Chaum-Pedersen proof that . The lie on a polynomial of degree , so the posted values interpolate to , and the program sets . Each member then posts with a proof that .
Theorem 6.1 (Secure DKG [4]). If at most members are corrupt and , steps 1 to 4 output shares of a secret such that every honest member’s share satisfies the Feldman relation for , can be reconstructed from any shares, is uniformly distributed in , and the adversary learns nothing about beyond .
The twist adds only uniform values to that view. The masked product polynomial is uniform among polynomials of degree with constant term , and is uniform and independent of because is; so the transcript is simulatable from and , and is uniform in . The twist runs once, at genesis, with all members posting; every later change of membership preserves and therefore (Section 6.6).
The Council account acts as the broadcast channel: every commitment, encrypted share and complaint is a Solana transaction, so the transcript is public and ordered, and step boundaries are slot deadlines rather than synchronized clocks.
6.5 Threshold decryption with proofs
Chaum-Pedersen proofs
The basic tool is a proof that two group elements share a discrete logarithm. For bases and targets , the relation is . The prover samples , sends , receives and answers ; the verifier checks for [6]. The protocol is complete, special-sound (two accepting answers for one commitment and distinct challenges give ), and honest-verifier zero-knowledge. Privium makes it non-interactive with Fiat-Shamir [7], hashing the whole statement into the challenge,
where separates proof types and binds the proof to its use (program ID, Council epoch, request). Omitting statement elements from the hash lets an adversary choose them after the challenge and forge proofs; the strong form in (6.5) is the one that yields a sound non-interactive proof in the random-oracle model [8].
Threshold decryption. A member’s decryption share for a handle is with a Chaum-Pedersen proof on bases and targets . Any valid shares combine to and the plaintext point is , as in (6.1). This is the scheme analysed by Shoup and Gennaro, whose proofs of correct decryption are what make the combination robust: an invalid share is rejected individually, so honest members always suffice regardless of what corrupt members post [9].
Re-encryption to a verified key
Privium never needs the plaintext point in public. It needs the handle moved from to a recipient key (an enclave’s or an owner’s ). Member samples and posts
with a proof of knowledge of such that , and . is the two-witness sigma protocol with commitments , responses , , challenge as in (6.5) over the full statement , and checks
Combining any valid shares,
Lemma 6.3 (Re-encryption correctness). For a leaf and , the pair is an ElGamal ciphertext of under : .
Proof. , and .
Lemma 6.4 (Share soundness). If (6.7) holds for two challenges on the same commitments, then satisfies and satisfies and . Hence, in the random-oracle model, a member who posts an accepted different from for its registered succeeds with negligible probability.
Proof. Subtracting the two instances of each equation in (6.7) gives , and . Divide by . The forking lemma turns a prover that convinces with non-negligible probability into one that produces such a pair.
Lemma 6.5 (Re-encryption privacy). Under DDH in , the shares of any set of members, together with any secret shares, reveal nothing about to a party that does not know .
Proof sketch. Each with ; the pair is a Diffie-Hellman tuple over , indistinguishable from with uniform. Replacing every mask by an independent uniform element (one hybrid per share) makes each uniform and independent of . What remains is and shares of , which by Lemma 6.1 and Theorem 3.2 reveal nothing about .
The listing below is the check that the Pool program and every recipient run on each share, followed by the combination (6.8).
use curve25519_dalek::{constants::RISTRETTO_BASEPOINT_POINT as G, ristretto::RistrettoPoint as P, Scalar};
pub struct ReEncShare { pub member: u8, pub a: P, pub b: P, pub r: [P; 3], pub z1: Scalar, pub z2: Scalar }
/// Checks (6.7) for one share: `pc` is P_C, `sj` the member's S_j, `d` the handle, `y` the recipient key.
pub fn verify_share(s: &ReEncShare, pc: &P, sj: &P, d: &P, y: &P, ctx: &[u8]) -> bool {
let eps = challenge(b"privium/reenc/v1", &[pc, &G, d, y, sj, &s.a, &s.b, &s.r[0], &s.r[1], &s.r[2]], ctx);
s.z1 * pc == s.r[0] + eps * sj
&& s.z2 * G == s.r[1] + eps * s.a
&& s.z1 * d + s.z2 * y == s.r[2] + eps * s.b
}
/// Lagrange coefficient (6.2) of `j` in the quorum `q`.
fn gamma(j: u8, q: &[u8]) -> Scalar {
let (mut num, mut den) = (Scalar::ONE, Scalar::ONE);
for &m in q.iter().filter(|&&m| m != j) {
num *= Scalar::from(m as u64);
den *= Scalar::from(m as u64) - Scalar::from(j as u64);
}
num * den.invert()
}
/// Combines t verified shares into (A, B) as in (6.8).
pub fn combine(shares: &[ReEncShare]) -> (P, P) {
let q: Vec<u8> = shares.iter().map(|s| s.member).collect();
shares.iter().fold((P::identity(), P::identity()), |(a, b), s| {
let g = gamma(s.member, &q);
(a + g * s.a, b + g * s.b)
})
}
On chain the same equations run through Solana’s curve25519 syscalls for ristretto255 group operations and multiscalar multiplication [12]; each share verification is a fixed number of group operations, and Chapter 9 accounts for its compute budget.
6.6 Council membership and proactive resharing
Members change, and shares held for long periods accumulate exposure. Privium reshares the same secret to a new committee at every membership change and at least once every slots, recommended (parameter): an adversary who corrupts members over time must collect shares within one period, because shares from different periods do not combine [5].
Protocol. Let be a set of current members. Each acts as a Feldman dealer of its own share on base : it samples , posts with , and sends to each new member , encrypted as in Section 6.4. The program and every new member check , the dealer’s registered verification key, which forces each dealer to reshare its real share. New member verifies its sub-shares by (6.3) with in place of and sets
Old members erase their shares once the new committee’s verification keys are recorded.
Lemma 6.6 (Resharing preserves the key). The new shares are a -of- Shamir sharing of the same , so is unchanged and the new verification keys interpolate to .
Proof. Let . It has degree at most , , and by (6.2). In the exponent, .
Because is unchanged, nothing encrypted under it needs to be touched: every leaf’s Council handle and remain valid across any number of membership changes. A dealer whose sub-shares fail (6.3) is excluded and the protocol reruns with a different ; since honest old members exist, a valid always exists. The resharing transcript lives in the Council account, and the program switches to the new verification keys only after new members have posted acknowledgements of valid sub-shares.
6.7 The Escape
The Escape is the path by which every owner leaves with their last committed balance when the Coprocessor stops committing, using only the chain, the Council and the owner’s own key.
State at trigger
Let be the slot of the last accepted Commit, with root . The Coprocessor commits each Crossing that settles something and, with nothing to settle, sends a heartbeat Commit 750 slots after the last (Chapter 10), so a live enclave keeps the gap to 750 slots plus the heartbeat’s own landing, and the gap measures enclave liveness rather than trading activity. The Pool holds two public queues: deposits received but not yet credited by a Commit, and Exits listed in a committed exits root but not yet released. It may also hold the recorded fills of the open Crossing : Residual legs execute in their own transactions before the Commit that absorbs them (Chapter 9), each leg with input asset , output asset and measured amounts , and the program caps the legs of one Crossing so that , the committed total of the input asset.
The Escape settles those legs over the committed holders of each input asset, in proportion to committed balance. With the frozen total of asset , a claim of units of pays
When no Crossing is open, or none of its legs spent , (6.10) pays units of . Each leg’s rate is its executed price, which the enclave’s signed bound keeps within of the oracle mid (Chapter 7), so every claimant receives their committed balance in value at that price.
Parameter. slots (parameter): it spans twelve heartbeat intervals and exceeds by a wide margin the few transactions a Coprocessor failover needs (attestation in Section 5.5, key release in Section 6.5, first Commit) and the lease of Chapter 10, so neither an idle Pool nor a routine failover triggers it, while still bounding how long a halted Ledger holds funds. Chapter 9 gives the slot time that converts it to minutes.
Steps
- Trigger. When the current slot exceeds , any account may call
trigger_escape. The program sets the Pool to Escape mode, freezes and the totals , copies the open Crossing’s recorded fills intoEscapeState, and rejects every later Commit, open, route and deposit. Intents not yet in a committed root carry no tokens and simply lapse. - Queues. Anyone may crank the queues: each pending deposit is refunded to the source token account its queue entry records, and each pending Exit is paid to its recorded destination.
- Request. Owner posts, for asset , the leaf index, the leaf’s pair , the opening of its owner tag (Definition 4.2) and a Merkle path to ; the AEAD layers are passed as their hash, so the request reveals nothing beyond what is already public except the escape key. The program recomputes from the opening, the leaf’s asset and its version, verifies the path, and opens an
EscapeRequestaccount. - Respond. Council members post shares (6.6) toward for the handle , with proofs and . The program verifies each with (6.7) against the registered and, after valid shares, stores by (6.8). Members may batch shares for many requests in one transaction.
- Claim. The owner computes by Lemma 6.3. The owner takes the candidate from their own leaf, decrypted with (Chapter 4), or from the SDK’s record, and checks it against . They post , a destination (a fresh address, or a Ring deposit as in Chapter 8), and a Chaum-Pedersen proof that with , whose context includes , and the request address.
- Pay. The program recomputes , verifies the proof, creates the
EscapeRecordfor the leaf and asset, and transfers the amounts of (6.10) from the vaults to ‘s token accounts.
pub fn escape_claim(ctx: Context<EscapeClaim>, amount: u64, proof: DleqProof) -> Result<()> {
require!(ctx.accounts.ledger.load()?.escape_from_slot != 0, PrivErr::NotEscape);
let req = &mut ctx.accounts.request;
require!(req.combined && !req.claimed, PrivErr::RequestState);
// `EscapeRecord` is created with `init` for (leaf, mint): a second claim fails there.
// Z = bG - (C - B); the proof shows log_G(Y_u) = log_A(Z).
let (c, a, big_b) = (req.commitment.decompress(), req.a.decompress(), req.b.decompress());
let z = Scalar::from(amount) * G - (c - big_b);
let dest = ctx.accounts.destination.key();
let claim_ctx = claim_context(&crate::ID, &req.key(), &req.mint, &dest);
require!(
proof.verify(&G, &req.owner_key.decompress(), &a, &z, &claim_ctx),
PrivErr::ClaimProof
);
req.claimed = true;
// Settlement rule (6.10): the leaf's asset, plus output assets of open legs that spent it.
let total = ctx.accounts.asset.load()?.ledger_total;
for (mint, units) in ctx.accounts.escape.load()?.settle(&req.mint, amount, total)? {
transfer_from_vault(&ctx, &mint, &dest, units)?;
}
emit!(Escaped { request: req.key(), mint: req.mint, amount });
Ok(())
}
G is the ristretto255 base point; decompress rejects non-canonical encodings, so every point the program uses is a valid group element. The request account holds , and the leaf index exactly as verified against in step 3, and the claim context binds the proof to this request, mint and destination, so the proof cannot be lifted onto a different payout or redirected by whoever submits the transaction.
6.8 Safety and liveness of the Escape
For each asset , write for the frozen committed total, for the pending deposit queue, and for the pending Exit queue at trigger. Fees are not among them: each Commit paid its Crossing’s fees out of the vaults to the fee recipient. By the conservation check at committed roots (Equation 9.2 and Theorem 4.1) and the recorded fills of the open Crossing, the vault at trigger holds
Theorem 6.2 (Escape safety). Assume Commit authenticity (Theorem 5.2), collision resistance of , the discrete-logarithm assumption in , and the random-oracle model for (6.5). Then, against any set of corrupt Council members (including all ) and any number of corrupt relayers, except with negligible probability in :
- (Exactness) every Escape claim for entry is for the leaf’s Council decryption , defined by , which equals , and is paid by (6.10);
- (Exclusivity) every Escape payout for is to a destination chosen by the holder of ;
- (Uniqueness) each entry is paid at most once;
- (Solvency) under the hypotheses of Theorem 4.2, the total paid in asset during the Escape is at most , so every claim, refund and queued Exit is payable.
Proof. (1) The request’s and owner-tag opening are bound to by the Merkle path, so substituting other values requires a collision in . Each share in passed (6.7) against a registered , so by Lemma 6.4 each satisfies with for the true share ; hence (6.8) gives and for some , even if every member is corrupt, since corrupt members can choose but not . Then . An accepted claim proof yields, by special soundness, with and , so and because has prime order and balances are below . By Theorem 5.2, was signed by an admitted enclave, which writes for the opening of , so ; Theorem 4.2 gives the same equality from the published proofs alone.
(2) The extractor from (1) outputs . A claimant who does not hold and produces an accepted proof therefore solves a discrete logarithm. A relayer who copies an honest owner’s proof cannot change , because is in the hashed context and a changed context gives an independent challenge.
(3) The EscapeRecord for (leaf, ) is created in the same transaction as the payout and its existence aborts any later claim, and a leaf index determines a unique position in .
(4) By (1), (3) and Corollary 4.1, claims in asset are for decryptions that sum to at most , so by (6.10) they pay at most units of , and claims in the input assets of legs with pay at most units of , since the floors only round down. Refunds pay exactly and queued Exits exactly , each entry once. The sum is at most by (6.11), and in Escape mode no Commit, Residual or new Exit moves the vault.
The theorem holds with every Council member corrupt: a corrupt Council can withhold shares, but it cannot direct a payout, inflate one, or pay twice. Custody therefore rests on the chain, the Merkle root, the published proofs and the owner’s key; the Council contributes availability.
Theorem 6.3 (Escape liveness). If at least Council members are honest and each lands its share transactions on chain, then every owner who posts a valid request for receives , settled by (6.10), at a destination of their choice.
Proof. Honest members respond to every valid request by (6.6), and by completeness of the sigma protocol their shares pass (6.7). Shares that fail verification are discarded individually, so honest shares suffice regardless of other posts, and (6.8) produces with . By Lemma 6.3 the owner computes , matches it against their leaf or balance record, and produces an honest claim proof that passes verification. The vaults hold enough by Theorem 6.2 (4), and no EscapeRecord exists for the entry, because only a claim by the holder of can create it.
Confidentiality during the Escape. By Lemma 6.5, the shares posted for owner reveal nothing about to anyone without , and requests reveal only leaf fields that were already committed in ciphertext, together with the escape key. Owners who never claim keep their balances confidential at the level of the honest threshold of the Council. A claimed amount becomes visible on chain as a vault transfer, exactly as a normal Exit does, and the destination may be a Ring deposit to unlink it (Chapter 8).
The Escape gives the Council a narrow role: it holds a key no fewer than members can use, it re-encrypts only toward keys the chain has verified, and every share it posts comes with a proof the program checks. The Coprocessor of Chapter 5 provides confidentiality and authentic Commits; the Council and the Escape guarantee that a trader’s last committed balance remains theirs whether or not the Coprocessor ever commits again.
References
- A. Shamir, “How to share a secret”, Communications of the ACM 22(11), November 1979. https://doi.org/10.1145/359168.359176
- P. Feldman, “A practical scheme for non-interactive verifiable secret sharing”, 28th IEEE Symposium on Foundations of Computer Science (FOCS), 1987. https://doi.org/10.1109/SFCS.1987.4
- T. P. Pedersen, “Non-interactive and information-theoretic secure verifiable secret sharing”, CRYPTO 1991, LNCS 576. https://doi.org/10.1007/3-540-46766-1_9
- R. Gennaro, S. Jarecki, H. Krawczyk, T. Rabin, “Secure distributed key generation for discrete-log based cryptosystems”, Journal of Cryptology 20(1), 2007. https://doi.org/10.1007/s00145-006-0347-3
- A. Herzberg, S. Jarecki, H. Krawczyk, M. Yung, “Proactive secret sharing or: how to cope with perpetual leakage”, CRYPTO 1995, LNCS 963. https://doi.org/10.1007/3-540-44750-4_27
- D. Chaum, T. P. Pedersen, “Wallet databases with observers”, CRYPTO 1992, LNCS 740. https://doi.org/10.1007/3-540-48071-4_7
- A. Fiat, A. Shamir, “How to prove yourself: practical solutions to identification and signature problems”, CRYPTO 1986, LNCS 263. https://doi.org/10.1007/3-540-47721-7_12
- D. Bernhard, O. Pereira, B. Warinschi, “How not to prove yourself: pitfalls of the Fiat-Shamir heuristic and applications to Helios”, ASIACRYPT 2012, LNCS 7658. https://doi.org/10.1007/978-3-642-34961-4_38
- V. Shoup, R. Gennaro, “Securing threshold cryptosystems against chosen ciphertext attack”, Journal of Cryptology 15(2), 2002. https://doi.org/10.1007/s00145-001-0020-9
- H. de Valence, J. Grigg, M. Hamburg, I. Lovecruft, G. Tankersley, F. Valsorda, “The ristretto255 and decaf448 Groups”, RFC 9496, IETF, December 2023. https://www.rfc-editor.org/rfc/rfc9496
- N. Lokhande, R. Gupta, R. Chahar, A. Jangra, A. Prajapati, M. Kumari, “Encifher: A Trusted-Execution Coprocessor for Confidential Computation on Solana”, IACR ePrint 2026/1504, July 2026. https://eprint.iacr.org/2026/1504
solana-curve25519crate documentation (ristretto255 and edwards25519 syscall wrappers), Anza, 2025. https://docs.rs/solana-curve25519/latest/solana_curve25519/