The Ledger is Privium’s book of accounts: one balance per trader per asset, held as ciphertext, committed on chain as a single Merkle root, and advanced once per Crossing by a Commit. This chapter defines its leaves, its state transition function and its Commit, and proves the property everything else depends on: at every committed root, for every asset, the balances in the Ledger add up exactly to what the Pool’s vaults hold for traders. The proof uses the Pedersen layer of each leaf and the integer bounds of Chapter 3, so conservation is checked on chain by the program, not taken on trust from the Coprocessor. The chapter closes with data availability, replay and nonce discipline, and the growth of the Ledger in bytes.
4.1 From ciphertext handles to a Ledger
Encifher introduced the model the Ledger follows [2]. On-chain programs hold only 128-bit ciphertext handles; ciphertexts live in a public data availability layer; an enclave fetches them, decrypts, computes on plaintext, re-encrypts and commits attested, Merkle-anchored results; and Solana’s declared read and write sets serve as the dependency graph, so confidential computation is ordered correctly without a scheduler of its own [2]. In the Encifher implementation each fresh encrypted value receives a 16-byte handle from a cryptographically secure generator, result handles are derived deterministically from the operation and its inputs, and each batch’s outputs are packaged into a Merkle tree whose root the enclave signs and submits on chain with a reference to the data availability layer [3].
Privium runs one program over one state shape, so it specializes the model rather than generalizing it.
| Encifher, general coprocessor [2][3] | Privium Ledger | |
|---|---|---|
| Unit of state | any encrypted value, named by a handle | a balance leaf or a trader record at a fixed tree position |
| Handle | 16 random bytes, or derived from an operation | : 128 bits derived from position and version |
| On-chain state | handles in each program’s accounts | one root , a Crossing index , per-asset accumulators |
| Ciphertext location | external data availability layer | Solana transactions, hash-chained by the program (Section 4.7) |
| What the program checks | enclave signature over the batch root | enclave signature, root chaining, data availability digest, asset conservation |
The handle of the leaf at position in version is
which keeps Encifher’s 128-bit width and its deterministic derivation for results, and makes every handle unique across the Ledger’s history. Indexers and the Coprocessor’s ciphertext store key their records by (Chapter 10).
4.2 Leaves
Each leaf is encrypted for three readers at once, each through the layer suited to it: the Coprocessor reads an AEAD ciphertext under the Ledger data key, the owner reads an AEAD ciphertext under a key only the owner and the enclave hold, and the Council decrypts through a twisted ElGamal handle under its joint key, which is the path the Escape takes (Chapter 6). A Pedersen commitment shared by all three is what the program and every watcher compute with.
The keys are: the Ledger data key , the AES-256-GCM key that enclaves hold and that the Council releases to each admitted enclave (Chapter 5); the owner leaf key , derived from the trader’s asset key in the Viewing key hierarchy of Chapter 11 (equation 11.2), so that the trader and anyone they hand or can read the leaf; and the Council’s joint twisted ElGamal key , whose secret exists only as shares (Chapter 6). Each trader also holds an authority key (Ed25519), which signs Intents, an escape key , which claims an Escape payout, and a 32-byte salt ; the SDK derives all of them from one wallet signature (Chapter 10).
Definition 4.1 (Trader record). The record of trader is the leaf
where is the leaf’s version, is the trader’s nonce watermark (Section 4.8), is the trader’s viewing root (Chapter 11), is the AEAD nonce of Section 4.8 and is the leaf’s public part together with and . Institutional accounts add a policy record of kind 3 in the same form, carrying the policy of Chapter 11.
Definition 4.2 (Ledger leaf). The balance of trader in asset is the leaf
with
where is the asset’s 4-byte index in the Registry, is the position of ‘s record, is fresh at every write, and .
is a twisted ElGamal ciphertext of under (Definition 3.8), and alone is a Pedersen commitment to it. The Council decrypts it with , which is the Escape’s only use of the Council (Chapter 6); there is no separate escape ciphertext. Both AEAD layers carry the opening along with the balance, which gives the owner something the Token-2022 decryptable balance does not need to give: the owner can check locally and so verify that the public commitment matches the balance they read. The owner tag is a hiding commitment to the owner’s escape key; because it includes the version, it changes at every write, so two versions of one leaf, and the leaves of one trader in different assets, carry unrelated tags. It is opened only in an Escape request, where the claimant reveals and later proves knowledge of (Chapter 6). The asset index is public, since each asset’s leaves are summed against that asset’s vault; owner, amount and history are not. Chapter 8 measures what an observer learns from the remaining public fields.
pub const LEAF_LEN: usize = 225;
pub const RECORD_LEN: usize = 161;
#[repr(C)]
pub struct LedgerLeaf {
pub kind: u8, // 2
pub asset: u32, // Registry index alpha(a)
pub version: u64, // index k of the Crossing that wrote it
pub owner_tag: [u8; 32], // psi_{u,a}, fresh at every write
pub commitment: [u8; 32], // C = b G + r H (ristretto255)
pub council_handle: [u8; 32], // D = r P_C
pub ct_ledger: [u8; 60], // AES-256-GCM(k_L): record pos 4 | b 8 | r 32 | tag 16
pub ct_owner: [u8; 56], // AES-256-GCM(k_{u,a}): b 8 | r 32 | tag 16
}
impl LedgerLeaf {
/// Public part bound into both AEAD ciphertexts as associated data.
pub fn ad(&self, program: &Pubkey, index: u32) -> [u8; 145] {
let mut ad = [0u8; 145];
ad[0..32].copy_from_slice(program.as_ref());
ad[32..36].copy_from_slice(&index.to_le_bytes());
ad[36] = self.kind;
ad[37..41].copy_from_slice(&self.asset.to_le_bytes());
ad[41..49].copy_from_slice(&self.version.to_le_bytes());
ad[49..81].copy_from_slice(&self.owner_tag);
ad[81..113].copy_from_slice(&self.commitment);
ad[113..145].copy_from_slice(&self.council_handle);
ad
}
/// AEAD nonce: position and version, 96 bits, never repeated under one key.
pub fn nonce(index: u32, version: u64) -> [u8; 12] {
let mut n = [0u8; 12];
n[0..4].copy_from_slice(&index.to_be_bytes());
n[4..12].copy_from_slice(&version.to_be_bytes());
n
}
}
The listing is the leaf as the Coprocessor, the SDK and the indexer share it. Field widths add up to 225 bytes for a balance leaf; a trader record is 1 + 8 + 152 = 161 bytes (a 136-byte plaintext plus the GCM tag). Because and sit in the associated data, neither AEAD ciphertext can be moved to another leaf, another position, another version or another deployment without failing authentication.
4.3 The tree and its root
The Ledger is a sparse binary Merkle tree of depth in the form of Definition 3.10, with
because positions hold every record and balance leaf the product can reach, and a 1,024-byte inclusion proof fits in one v1 Solana transaction, whose limit is 4,096 bytes [4], which is the size the Escape claim needs (Chapter 6). Every write places the leaf at a position drawn by the Coprocessor uniformly at random among free positions and empties the position it held before, so a position carries no information about arrival order or about the leaf’s earlier versions (Chapter 8 builds on this relocation). The Ledger state after Crossing is the map , and its root is the tree hash of . The plaintext view of is the balance vector .
4.4 The state transition function
A Crossing consumes four kinds of input. Deposits are public Pool instructions that move tokens into a vault and append an entry to one of the asset’s deposit queue shards (Chapter 9), carrying a note sealed to the enclave’s HPKE key that names the trader’s record; the Commit states the vector of per-shard cuts it absorbs. Intents are HPKE ciphertexts (Section 3.7) collected by the Coprocessor. Exit requests are Intents of a dedicated kind that name an asset, an amount and a destination address. Route fills are the vault flows of the Crossing’s Residual swaps, which execute from the Pool in route_residual transactions after open_crossing and before the Commit, and which the program records in the Crossing’s state account (Chapters 7 and 9). Only one Crossing is open at a time, since open_crossing for requires the stored index , so every recorded fill belongs to the Crossing that the next Commit closes.
For asset and Crossing , let be the deposits absorbed (queue entries between the cuts and ), the signed net flow of asset into the vaults from the Crossing’s recorded fills, the total of the Exits the Commit lists, and the protocol fees the Crossing charges in . All four are public on chain and recorded by the program.
Definition 4.3 (Ledger transition). Given and the inputs of Crossing , the Coprocessor decrypts every Intent, runs the Crossing engine of Chapter 7 on the valid ones, and obtains a delta vector . The transition is valid when:
- (V1) Authorization. Every negative delta of is covered by an Intent or exit request of that carries a valid signature, an unexpired and a fresh nonce .
- (V2) Solvency. for every .
- (V3) Balance. For every asset ,
Fees leave the Ledger and the Pool together: the Commit attests and pays it in the same instruction from vault shard 0 to the fee recipient named in the Pool configuration, the token’s launch wallet (Chapters 9 and 12). Each trader’s fee is rounded down to whole base units and is the exact sum of those fees, and every proportional split of the Crossing uses the largest-remainder rule, so (4.4) holds exactly in integers with no remainder left over. The new state rewrites the leaf of every with a nonzero delta, the record of every trader whose watermark moved, and a decoy set of further leaves that are re-randomized without a value change; Chapter 8 sets the decoy count. Re-randomizing a leaf replaces by for fresh , recomputes the owner tag for the new version, re-encrypts both AEAD layers, and moves the leaf to a fresh position (Section 4.3), so a rewritten leaf reveals nothing about whether its value changed (Theorem 4.3) or where it was before.
An Intent that fails any check is dropped inside the enclave; nothing about it reaches the chain.
4.5 The Commit
The Commit for Crossing carries the new root, the per-shard deposit cuts , the root of the Exits it lists, the data availability digest (Section 4.7), the hashes of the mids and fills recorded on chain for Crossing , and for each asset in the set of assets it carries, the attested total , the Crossing’s Exits and fees , the commitment delta and the aggregate opening
where is the set of asset- leaves rewritten in Crossing (a new leaf counts with , a vacated position contributes ). The Coprocessor signs with the Commit message
where is the signing key’s epoch (Chapter 5) and holds every other field above, in the byte layout of Equation 9.1. The program accepts the Commit only if all of the following hold.
- (C1) Order. No Escape is active, equals the stored index plus one, and equals the stored root.
- (C2) Authority. An Ed25519 signature on is present in the transaction, under a that the Registry admits for epoch with a validity interval containing the current slot, and that opened Crossing (Chapter 5 for the key, Chapter 9 for the precompile pattern).
- (C3) Availability and binding. equals the data availability accumulator in the Crossing’s state account, which is then sealed; the mids and fills hashes equal what
open_crossingandroute_residualrecorded; and the deposit digest matches the queue entries at the cuts. - (C4) Conservation. For every , the attested total satisfies the vault equation (9.2) of Chapter 9, which states that, once the Commit has paid out, the vault holds exactly , the committed Exits not yet released and the deposits not yet credited. With stored accumulators , the weights satisfy
- (C5) Exits. The program adds each to the asset’s committed, unreleased Exits and stores ; each Exit is then paid by a permissionless
release_exitthat proves its inclusion under (Chapter 9).
On success the program stores , , , and the slot of the Commit, from which the Escape measures the liveness window (Chapter 6). Check (4.7) is a single multiscalar multiplication of ristretto255 points, which programs compute with Solana’s curve25519 syscalls [5]. The listing is the per-asset body of check (C4) that the Commit handler of Chapter 9 calls for each carried asset.
/// Check C4 for one asset: pay the fee, Equation 9.2 in base units, then the terms of (4.7).
pub fn conserve(
a: &AssetEntry, group: &[AccountInfo], pool: &PoolConfig, authority: &AccountInfo,
chain: &mut Vec<[u8; 32]>, acc: &mut ConserveAcc,
) -> Result<()> {
let mut st = load_asset_state(&group[0], &a.mint)?;
let (mint, vaults, queues) = (&group[1], &group[2..4], &group[4..6]);
let (recipient, token_program) = (&group[6], &group[7]);
require_keys_eq!(*recipient.key, fee_recipient_ata(pool, &st), PriviumError::Accounts);
if a.fees > 0 { // the Crossing's fees leave shard 0
pay_from_vault(token_program, &vaults[0], mint, recipient, authority, a.fees, &st)?;
}
let (mut held, mut uncredited) = (0u128, 0u128);
for j in 0..SHARDS {
let v = vault_account(&vaults[j], &a.mint, &pool.authority)?;
let q = queue_account(&queues[j], &a.mint, j)?;
require!(a.cut[j] >= st.consumed[j] && a.cut[j] <= q.head, PriviumError::Cut);
let last = q.entry(a.cut[j] - 1)?; // last credited entry
chain.push(last.chain_hash);
held += v.amount as u128;
uncredited += (q.cum_amount - last.cum_amount) as u128;
st.consumed[j] = a.cut[j];
}
st.pending_exits = st.pending_exits.checked_add(a.exits).ok_or(PriviumError::Math)?;
let owed = a.total as u128 + st.pending_exits as u128;
require!(owed + uncredited == held, PriviumError::Conservation); // Equation 9.2
let gamma = st.gamma.add(&a.delta_gamma)?; // canonical ristretto decode
acc.push(&a.mint, a.total, &gamma, &a.r_agg); // z_a and the terms of (4.7)
st.ledger_total = a.total;
st.gamma = gamma;
Ok(())
}
ConserveAcc derives each weight from and evaluates (4.7) as one multiscalar multiplication after the last asset. The state writes take effect only if every check of the transaction passes, since any failure aborts it. Chapter 9 gives the account layouts, the deposit queue shards, the fill register in the Crossing’s state account and the compute budget.
4.6 Conservation
The program measures each vault by its own accounting: every token movement into or out of a vault passes through a Pool instruction that records it. The pending amount is the part of that balance the Ledger does not owe traders at Commit : committed Exits not yet released and deposits queued after the cuts . The Crossing’s fees are not part of it: the Commit pays them out of the vault before the check. No route flow is pending at a committed root, because routes run only for the open Crossing and its Commit absorbs every recorded fill. Check (C4) through Equation 9.2 gives at every accepted Commit.
Theorem 4.1 (Conservation of the Ledger). If every transition is valid in the sense of Definition 4.3, then after every Commit and for every asset ,
Proof. By induction on . At genesis all balances, vaults and pending amounts are zero. Assume (4.8) for , so . By (V2) and (V3),
and by check (C4) and Equation 9.2, since the vault gains and the pending amount gains at Commit .
Theorem 4.1 is a statement about the plaintext balances and holds whenever the enclave computes the transition it is attested to compute. The stronger statement is that the program’s check (C4), together with data any watcher holds, enforces the same equality on the committed values, so that what an Escape can pay out is bounded by the vault whatever the plaintext layers say.
Lemma 4.1 (Batched check). Model as a random oracle and let . If for some , an adversary making oracle queries gets a Commit accepted with probability at most .
Proof. Every is fixed by and the program’s state before the weights are computed, and each is an oracle output on an input containing , and . Fix any candidate and the weights for . Because has prime order and , the equation has at most one solution , which a fresh oracle output hits with probability . A union bound over the queries the adversary can try gives .
With and the bound is below .
Theorem 4.2 (Committed conservation). Suppose (i) every rewritten leaf carries a valid range proof for and a valid batched ciphertext validity proof in the diff of its Crossing (Section 4.7), and (ii) each published equals the sum (4.5) over the leaves in the diff, a check any watcher runs from data the program certified as published. Then, under the DL assumption in ristretto255 and the soundness of Bulletproofs, for every accepted Commit and asset , every opening of the asset- commitments in with satisfies
except with negligible probability. Moreover, the Council decryption of every such leaf, the integer with , equals .
Proof. By (ii) and induction from , the stored accumulator is the sum of the current commitments: . By Lemma 4.1, acceptance implies , so . By (i) and the knowledge soundness of Bulletproofs in the random oracle model [6], each has an extractable opening with . Then gives two openings of one point. By Theorem 3.1 they agree, so , or else the adversary yields . Both sides are non-negative integers below : the left is a sum of at most terms below , hence below , and . Congruence modulo is therefore equality. Any other in-range opening of the same commitments that an Escape claimant presents equals the extracted one by binding, so (4.9) holds for every opening, not only the extracted one. For the decryptions, the validity proof of Definition 4.4 is a sigma proof of knowledge of with and for , where is a random-oracle output on the whole diff. Binding gives and , so . If some , the polynomial is nonzero of degree below and vanishes at with probability at most per oracle query.
Corollary 4.1 (Escape solvency). Under the hypotheses of Theorem 4.2, the Council decryptions of the asset- leaves under a committed root sum to exactly . An Escape pays each leaf its Council decryption (Chapter 6), so the claims it can establish against total and no more, whatever the AEAD layers say.
The on-chain check publishes , the sum of all openings of an asset. That sum reveals the asset’s total, which the vault already shows, and nothing more.
Theorem 4.3 (Aggregate openings reveal only totals). Let choose two balance vectors and for the leaves of one asset with , and receive the public parts of the leaves for one of them, chosen at random, together with . Then ‘s advantage in telling which vector was used is at most for an adversary of comparable running time.
Proof. The reduction samples uniformly and sets for a uniform ; this is the honest joint distribution of . From one DDH instance , random self-reducibility gives instances with independent , all real or all random together. As in Theorem 3.2, set and, for , and , which is the honest form with when the instances are real. Set and , which are the honest values of the last leaf in the real case, since then and . In the random case each for is uniform and independent of , and is a function of , and the first leaves. The view then depends on the balances only through their sum, which is equal for both vectors. The real and random views differ by at most , which with the factor of Definition 3.2 gives the bound. The AEAD layers are replaced by encryptions of zeros beforehand, at the cost of the IND-CPA advantage of AES-256-GCM under unique nonces.
4.7 Data availability of ciphertexts
A root is useful only if the leaves under it can be retrieved: owners need their leaf to read their balance, watchers need every rewritten leaf to run check (ii), and an Escape needs the leaf and its inclusion proof. Encifher publishes each batch tree to an external data availability service and references the submission on chain [3]. Privium keeps the ciphertexts on Solana itself.
Definition 4.4 (Crossing diff). The diff is the byte string consisting of a header ; the list of rewritten positions with their new leaves, sorted by position; and for each the tuple , where is one aggregated Bulletproof (Section 3.6) over the commitments of all asset- leaves rewritten in Crossing and is a 128-byte sigma proof, in the template of Protocol 3.1, that the random combination of those leaves is a well-formed twisted ElGamal ciphertext; and the owner and auditor entry records of the Crossing (Chapter 11).
Before signing the Commit, the Coprocessor splits into chunks and submits each as a log_diff(k, j, chunk) instruction. The program keeps the accumulator in the Crossing’s state account and updates it in chunk order,
rejecting any chunk whose index is not the next one. Check (C3) compares the final value with the inside the signed message and seals the accumulator.
Theorem 4.4 (Availability). If Commit is accepted, then except with probability negligible under the collision resistance of , the diff the Coprocessor signed is the in-order concatenation of the instruction data of successful Solana transactions invoking log_diff for Crossing .
Proof. The accumulator changes only through log_diff, whose instruction data is recorded in the transaction that carried it, and the chunk index rule forces the order. If the signed equals the accumulator but the signed diff differs from the logged chunks, walk the chain (4.10) back from the final value: the first index at which the inputs differ while the outputs agree is a collision of , by the same argument as Theorem 3.4.
Corollary 4.2 (Reconstruction). is obtained from by applying in order, so every committed Ledger state, every root and every inclusion proof can be recomputed by anyone from Solana’s transaction history, without the Coprocessor and without its ciphertext store.
Recomputing from and is how a watcher confirms root integrity, and summing commitment deltas from the same diff is check (ii) of Theorem 4.2. Root integrity thus holds under the integrity of the enclave and is auditable by anyone after every Commit. Chapter 10 describes the store that serves leaves and paths quickly; Corollary 4.2 is what makes that store a cache rather than a source of truth.
4.8 Replay, ordering and nonce discipline
Commits
Check (C1) makes the accepted Commits a single chain: each names its predecessor’s root and the next index, the program stores exactly one root at a time, and a transaction carrying an old fails (C1) because the stored index has moved past . A second signature on the same , which SUF-CMA forbids anyway, would also fail (C1). Every Commit writes the Ledger root account, so Sealevel’s write lock executes Commits one at a time, while deposits, which write the deposit queue and the vaults but not the root account, proceed in parallel with each other. This is the read and write set scheduling that Encifher identifies as Solana’s native dependency graph [2], and the Ledger needs nothing beyond it.
Deposits
Each deposit receives a sequence number in its queue shard from the program. A Commit absorbs exactly the entries of each shard between the stored cut and its new cut, conserve rejects a cut below the stored one, and (C1) orders the Commits, so every deposit is credited in exactly one Crossing.
Intents
Each trader’s record holds a watermark , the largest Intent nonce applied so far. The enclave processes a trader’s valid Intents in a Crossing in increasing order of , applies an Intent only if and the Crossing’s slot does not exceed , and sets after each applied Intent. The SDK draws from a per-trader counter, so concurrent orders from one trader simply carry consecutive nonces.
Lemma 4.2 (No replay). Under the integrity of the enclave and the SUF-CMA security of Ed25519, every Intent is applied at most once, and no Intent is applied that its trader did not sign.
Proof. Authenticity: an applied Intent carries a valid signature over its fields, so an Intent the trader never signed is an Ed25519 forgery. Uniqueness: when an Intent with nonce is applied, becomes at least and never decreases, since the record is rewritten only by the enclave with the maximum. Any later presentation of the same Intent, in the same Crossing after sorting or in any later Crossing, has and is rejected. An Intent sealed for an earlier key epoch fails to open under the current HPKE info (3.8), so epoch changes do not reopen old ciphertexts.
AEAD nonces
Lemma 4.3 (Nonce uniqueness). No AES-256-GCM key in the Ledger is ever used twice with the same nonce.
Proof. Every leaf ciphertext at position in version uses , a 96-bit string. The version of a leaf is the index of the Crossing that wrote it, public and part of the authenticated data; a Crossing writes each position at most once, and Crossing indices strictly increase, so no (position, version) pair recurs, even when a relocation empties a position and a later Crossing fills it again. Distinct pairs give distinct nonces. Within one leaf the two ciphertexts use the same nonce under two different keys, and , and no owner leaf key is shared between traders, between assets or with the Ledger data key.
Deterministic nonces remove the birthday bound that random 96-bit GCM nonces carry, and make Lemma 4.3 a property of the data structure that any watcher can check from the diffs.
4.9 Ledger growth
Let be the number of balance leaves and the number of trader records. The Ledger’s on-chain footprint does not depend on either: it is the root account plus a fixed-size state per asset holding and , and the state account of the open Crossing, which carries the data availability accumulator and is closed after its Commit (Chapter 9). Everything that grows lives in Solana’s transaction history and in caches built from it.
Full state. The leaves occupy bytes. A sparse tree with randomly placed leaves in depth shares its top levels and has paths of about unshared nodes per leaf below that, so its interior nodes take about bytes.
Per Crossing. With balance leaves and records rewritten, decoys included, and of the balance leaves in asset , the diff has
from an 80-byte header, a 4-byte position per leaf, 196 bytes per asset for and the range proof size (3.7), with the entry records of Chapter 11 adding their own bytes. Each log_diff transaction carries about 3,800 bytes of chunk data (est.: the 4,096-byte v1 limit [4] less one signature, three account keys, the blockhash and the instruction header). The Ledger takes one diff per Crossing. A Crossing runs only when it settles something, at most once per batch interval of Chapter 7, and an idle Ledger takes one heartbeat diff every 750 slots, with no asset (Chapter 10); its daily count lies between those two rates at the slot time Chapter 9 cites.
The table evaluates these formulas for an illustrative load; the counts are inputs to the formulas, not measurements.
| Quantity | Example input | Result (est.) |
|---|---|---|
| Diff per Crossing | over assets of each, | 217,308 bytes |
log_diff transactions per Crossing |
same | 58 |
| Range proof per asset | 1,056 bytes | |
| Escape inclusion proof | 1,024 bytes | |
| Leaves, full state | traders, | 1.06 GB |
| Interior nodes, full state | , | about 1.9 GB |
| Positions available | 4,294,967,296 |
The per-Crossing figure follows from (4.11): bytes, and rounds up to 58 transactions. Eleven assets of 64 leaves each is the largest Commit of Chapter 9 at the decoy floor of Chapter 8. The range proof term grows with the logarithm of the number of rewritten leaves, so batching more traders into a Crossing lowers the proof bytes per leaf: one 64-bit proof costs 672 bytes on its own and 16.5 bytes per leaf inside a batch of 64. The state figures show the Ledger fitting in the memory of a single enclave host at a million traders, with Corollary 4.2 guaranteeing that any party can rebuild it from the chain.
References
- “Solana Privacy Rings”, Helius, 2026. https://www.helius.dev/blog/solana-privacy-rings
- 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
- Encifher, “Encifher core documentation: crates and coprocessor components”, accessed 2026-11-16. https://encifher-core-docs.vercel.app/docs/crates
- Solana Foundation, “Larger Transaction Sizes” (SIMD-0296, v1 transactions of up to 4,096 bytes, live on mainnet from epoch 1035), 2026. https://solana.com/upgrades/larger-transaction-sizes
- Anza,
solana-curve25519crate documentation (syscall operations for curve25519 and ristretto255), accessed 2026-11-16. https://docs.rs/solana-curve25519 - B. Bünz, J. Bootle, D. Boneh, A. Poelstra, P. Wuille, G. Maxwell, “Bulletproofs: Short Proofs for Confidential Transactions and More”, IEEE S&P 2018. https://eprint.iacr.org/2017/1066