Privium is built from a small set of standard primitives: a prime-order group, Pedersen commitments, twisted ElGamal encryption, Fiat-Shamir sigma protocols and Bulletproofs range proofs, AES-256-GCM, HPKE, binary Merkle trees, and two signature schemes. Each one is already deployed at scale, and most of them are the same objects Solana’s ZK ElGamal proof stack verifies on chain today. This chapter fixes their exact form, states the security notions Privium uses, and proves the reductions on which the later chapters build: the confidential Ledger (Chapter 4), attestation (Chapter 5), threshold decryption and the Escape (Chapter 6), and Receipts (Chapter 11).
3.1 Conventions and hardness assumptions
Throughout, is the security parameter, an algorithm is efficient when it runs in probabilistic polynomial time (PPT) in , and a function is negligible, , when for every constant and all large enough . We write for uniform sampling and for unambiguous concatenation of fixed-length or length-prefixed encodings. Every hash call carries a distinct ASCII domain tag of the form privium/<purpose>/v1, so that no two uses of in this paper can be confused with one another.
Let be a cyclic group of prime order written additively, with scalars in where in this chapter . Privium relies on three standard problems in .
Definition 3.1 (DL, CDH, DDH). For a generator of and :
- the discrete logarithm problem is to compute from ;
- the computational Diffie-Hellman problem is to compute from ;
- the decisional Diffie-Hellman problem is to distinguish from .
The advantage of an adversary against DDH is . Each assumption states that every efficient adversary has negligible advantage. DDH implies CDH implies DL. Because has prime order, all three problems are random self-reducible: one instance can be turned into any polynomial number of independent, uniformly distributed instances at the cost of a few scalar multiplications, which we use in Chapter 4.
Where a proof uses a hash function as a random oracle, we say so. Elsewhere is only assumed collision resistant: no efficient adversary outputs with except with probability .
3.2 The group: ristretto255
Why a prime-order group
Curve25519 in its twisted Edwards form (edwards25519) has a group of order , where the cofactor introduces small-order points. Protocols written for a prime-order group can fail on such a curve: two encodings can name the same logical point, a point can be multiplied by a torsion element without changing any check that compares only the prime-order part, and a zero-knowledge proof can verify for a statement that is false modulo the torsion. Ristretto255 removes this class of problems by construction. It defines as a quotient of the edwards25519 group by its small torsion, together with a canonical 32-byte encoding that is injective on the quotient and a decoding that rejects every non-canonical string [3]. The resulting group has prime order
so every non-identity element generates and every 32-byte string either decodes to exactly one element or is rejected [3]. Equality of encodings is equality of group elements, which is the property every check in Chapters 4 and 6 needs.
Generators
Privium uses the same two generators as Solana’s ZK ElGamal SDK. is the ristretto255 base point. is obtained by hashing the compressed encoding of with SHA3-512 and mapping the 64-byte digest into with the ristretto255 one-way map [4]:
Using Solana’s unchanged means Privium commitments and ciphertexts are byte-compatible with the ZK ElGamal proof program, so any of its verifiers can check statements about Ledger values (Section 3.5).
Lemma 3.1 (Independent generators). Model as a random oracle into . Then an efficient adversary that outputs with yields an efficient algorithm for DL in with the same success probability, up to a polynomial loss in the number of oracle queries.
Proof. Given a DL instance , program the oracle so that the query on returns ; every other query returns a fresh uniform element. The adversary’s view is distributed exactly as in the real experiment, because is uniform in . If it outputs with , then is the discrete logarithm of . When the adversary may also query the oracle on other points that it later treats as generators, guess the relevant query index, which loses a factor equal to the number of queries.
No party, including Solana, the Privium developers or the Coprocessor, knows . Every binding argument below rests on this lemma.
3.3 Security definitions
This section collects the notions referred to throughout the paper. The games are standard; we fix them so that the reductions in Chapters 4 to 6 have a single reference point.
Definition 3.2 (IND-CPA and IND-CCA2). Let be a public-key encryption scheme. In the IND-CPA game the challenger samples and gives to ; outputs equal-length messages ; the challenger samples and returns ; outputs . The advantage is . In the IND-CCA2 game, additionally has a decryption oracle before and after the challenge, which it may query on any ciphertext other than . is IND-CPA (respectively IND-CCA2) secure if every efficient has negligible advantage.
Definition 3.3 (EUF-CMA and SUF-CMA). For a signature scheme , the adversary receives and a signing oracle. It wins the EUF-CMA game if it outputs with for a message it never queried. It wins the SUF-CMA game if the pair was never returned by the oracle, so that even a fresh signature on a queried message counts as a forgery.
Definition 3.4 (Commitment hiding and binding). A commitment scheme is perfectly hiding if for all the distributions of and over uniform are identical. It is computationally binding if no efficient adversary outputs with except with negligible probability.
Definition 3.5 (AEAD security). A nonce-based AEAD scheme with key , nonce , associated data and message provides IND-CPA security against nonce-respecting adversaries (no nonce is used twice under one key) and INT-CTXT: no efficient adversary with an encryption oracle produces a fresh that decrypts to a value other than . By the Bellare-Namprempre composition theorem, IND-CPA together with INT-CTXT implies IND-CCA2 for the symmetric setting [5].
Definition 3.6 (Sigma protocol). A three-move public-coin protocol for a relation is a sigma protocol if it is complete; has special soundness, meaning that from two accepting transcripts and with an efficient extractor computes a witness; and is special honest-verifier zero knowledge (SHVZK), meaning that for any given challenge a simulator outputs transcripts distributed identically to honest ones.
3.4 Pedersen commitments
Definition 3.7 (Pedersen commitment). For a value and opening ,
This is the commitment of Pedersen [6] and the one Solana’s SDK computes as a two-term multiscalar multiplication over [4].
Theorem 3.1. Pedersen commitments are perfectly hiding, and computationally binding under the DL assumption in and Lemma 3.1.
Proof. Hiding: write with (unknown to everyone, but well defined). For fixed , the map is a bijection from to , so a uniform yields a uniform commitment whatever is. Binding: suppose an adversary outputs with . Then (otherwise ), and is the discrete logarithm of to base , contradicting Lemma 3.1.
Pedersen commitments are additively homomorphic: . Chapter 4 uses this to check asset conservation over the whole Ledger with a single group equation per asset. Two facts about integer values make that check meaningful. First, Ledger balances are integers in , and any sum of at most of them is below , so equality in implies equality over the integers. Second, a range proof (Section 3.6) is what ties a commitment to an integer in rather than to an arbitrary element of .
3.5 ElGamal and twisted ElGamal
Exponential ElGamal
ElGamal encryption [7] with key pair encrypts a group element as . Encrypting a scalar “in the exponent” as makes the scheme additively homomorphic, and decryption returns , from which is recovered by a discrete logarithm search. That search is efficient only for small , which is why every confidential balance system, Solana’s included, bounds the plaintexts it must decrypt (below).
Twisted ElGamal
Twisted ElGamal, introduced for the PGC confidential payment system [8] and adopted by Solana’s confidential transfer extension [9], rearranges the ciphertext so that one component is exactly a Pedersen commitment.
Definition 3.8 (Twisted ElGamal). A secret key is and the public key is . To encrypt under , sample and output
Decryption computes and then by bounded discrete logarithm. Solana’s SDK implements exactly these formulas: the public key is the inverse of the secret times , the ciphertext is a Pedersen commitment plus a decryption handle , and decryption subtracts from the commitment [4]. The commitment is independent of the key and the handle is independent of the message [9], which is what allows proofs about Pedersen commitments to apply to ciphertexts directly.
Definition 3.9 (Grouped ciphertext). To encrypt one value to keys with a single commitment, reuse across handles: . The holder of decrypts with . Solana’s confidential transfers encrypt each transfer amount this way to the source, the destination and the optional auditor, and its proof program verifies validity of grouped ciphertexts with two and three handles [10][11].
Theorem 3.2 (IND-CPA of grouped twisted ElGamal). For every adversary against the IND-CPA security of grouped twisted ElGamal with handles there is an adversary against DDH in with essentially the same running time such that
Proof. receives with , , and either or uniform; DDH relative to the fixed generator is equivalent to DDH relative to any generator, since has prime order. samples and publishes the keys . These are distributed as honest keys: , so is uniform in and independent across . On challenge messages , picks and returns
then outputs if guesses . If , set : then and , a correctly distributed ciphertext, so outputs with exactly ‘s success probability. If for uniform , the handles depend only on , and is uniform and independent of them, so is uniform and independent of , and outputs with probability exactly . The difference of the two probabilities is .
The proof covers randomness reuse across handles, the setting analysed in general by Bellare, Boldyreva and Staddon [12]. Theorem 3.2 is what Chapter 4 invokes for the Council handle carried by each Ledger leaf, and what Chapter 6 invokes for the Council’s joint key.
How Solana deploys it
The confidential transfer extension of Token-2022 stores an account’s available balance twice: as a twisted ElGamal ciphertext, used to generate proofs, and as an AES-GCM-SIV ciphertext (decryptable_available_balance) that the owner decrypts directly in routine use [9]. Incoming credits accumulate in a separate pending balance, split into a low and a high ciphertext, until the owner applies them. Transfer amounts are restricted to 48 bits, encrypted as a 16-bit low part and a 32-bit high part, because discrete logarithm decryption cost grows exponentially with the plaintext and already takes seconds for 32-bit values [9]. Privium takes the same two-layer pattern (a homomorphic layer that proofs and the Council act on, and a symmetric layer that the owner and the Coprocessor read) and drops the need for discrete logarithm decryption entirely: in the Ledger, the plaintext always travels alongside in an AEAD ciphertext, so the ElGamal layer only ever has to confirm a claimed value by checking , never to find it (Chapter 4, Chapter 6).
The ZK ElGamal proof program, which verifies these proofs on chain, was disabled at the start of mainnet epoch 805 on 19 June 2025 after a researcher reported a soundness flaw in its Fiat-Shamir transcript [13][14]. Confidential transfers were restored on mainnet in June 2026 after a competitive audit and a patched validator release [14], and the proof program is live alongside the BN254 and BLS12-381 syscalls delivered with Agave 4.0 [15].
3.6 Sigma protocols, Fiat-Shamir and range proofs
The template
Every proof in the confidential transfer stack apart from range proofs is a sigma protocol over made non-interactive with Fiat-Shamir. Solana’s documentation lists the ones its proof program verifies: public key validity, ciphertext validity for two and three handles, zero ciphertext, ciphertext-commitment equality, ciphertext-ciphertext equality and percentage-with-cap, plus batched range proofs over 64, 128 and 256 bits [10][11]. None of them needs a trusted setup [10]. The simplest is Schnorr’s proof of knowledge of a discrete logarithm [16]; we give the ciphertext-commitment equality proof in full because the Ledger’s batched validity proof follows its template (Chapter 4, Definition 4.4).
Protocol 3.1 (Ciphertext-commitment equality). Public input: a key , a ciphertext under , and a Pedersen commitment . Witness: with , and .
- The prover samples and sends , , .
- The verifier sends .
- The prover sends , , .
The verifier accepts if
Lemma 3.2. Protocol 3.1 is a sigma protocol for its relation.
Proof. Completeness: the first and third equations are immediate. For the second, , so , and . Special soundness: from accepting transcripts with challenges and the same , subtracting the equations gives , and . Setting , and yields , and , a valid witness. SHVZK: given , sample uniformly and solve (3.6) for ; in an honest run the responses are uniform and the commitments are determined by them, so the distributions are identical.
The Chaum-Pedersen proof of discrete logarithm equality, which shows , is the one-equation special case of the same template and is what each Council member attaches to a partial decryption (Chapter 6).
Fiat-Shamir done strongly
The non-interactive form replaces by . In the random oracle model, the forking lemma of Pointcheval and Stern turns any prover that convinces the verifier with non-negligible probability into two accepting transcripts with the same first message and distinct challenges, hence into a witness by special soundness [17]. That argument needs the hash input to contain the entire statement. When it omits part of the statement (the weak Fiat-Shamir transform), a prover can choose the unhashed part after seeing the challenge and prove false statements, a failure mode documented by Bernhard, Pereira and Warinschi [18] and the same class of defect that took Solana’s proof program offline in 2025 [14]. Privium’s rule is therefore mechanical: every transcript absorbs the domain tag, the program id, every public key, every ciphertext and commitment of the statement, and every first-round message, in a fixed order, before the challenge is squeezed.
Range proofs
A range proof shows that a commitment opens to . Solana’s stack uses Bulletproofs [11], which prove the bit decomposition of with an inner-product argument and need no trusted setup [19]. An aggregated proof for values of bits each consists of group elements and scalars [19]; with 32-byte encodings its size is
For this gives 672 bytes for one value and 1,312 bytes for 1,024 values aggregated. Logarithmic growth is what lets the Ledger publish a range proof for every balance it rewrites in a Crossing at a cost of about one kilobyte per asset (Chapter 4, Section 4.9).
3.7 Authenticated encryption and HPKE
AES-256-GCM
is AES-256-GCM as specified in NIST SP 800-38D: a 256-bit key, a 96-bit nonce and a 128-bit authentication tag [20]. GCM is IND-CPA and INT-CTXT secure, hence IND-CCA2 by Definition 3.5, for every adversary that never repeats a nonce under one key [20]. The Ledger therefore never draws nonces at random. It derives each nonce from the leaf position and the leaf’s monotone version counter (Chapter 4, Section 4.8), which makes nonce uniqueness a structural invariant rather than a probabilistic one. AES-256-GCM is also the symmetric layer the Encifher coprocessor reports at more than one million operations per second [2].
HPKE for Intents
Intents are encrypted to the Coprocessor with Hybrid Public Key Encryption, RFC 9180 [21], in base mode with the suite
whose RFC identifiers are 0x0020, 0x0001 and 0x0002 [21]. The Coprocessor holds an X25519 key pair generated inside the enclave for each key epoch and bound to its measurement through the attestation report (Chapter 5); is distinct from the Ed25519 signing key . An HPKE ciphertext is the 32-byte encapsulated key followed by the AEAD output, so it is 48 bytes longer than its plaintext [21].
Theorem 3.3 (Intent confidentiality). Under the Gap Diffie-Hellman assumption on X25519, with HKDF modeled as a random oracle and AES-256-GCM IND-CPA and INT-CTXT secure, HPKE base mode with the suite above is IND-CCA2 secure [22].
This is the result of Alwen et al.’s analysis of the HPKE standard [22]; we use it as stated. Two Privium-specific choices sit on top of it. The HPKE info string binds every ciphertext to the deployment and to the attested key epoch, so that an Intent sealed for one enclave key is rejected by any other:
where is the key epoch and the attestation quote registered for it. And the plaintext has a fixed length: the Intent is serialized into fixed-width fields together with the trader’s Ed25519 signature over those fields and zero padding to 128 bytes, so every Intent ciphertext is 176 bytes and its length says nothing about the order. The signature inside the ciphertext authenticates the trader to the enclave without appearing on chain.
import { CipherSuite, DhkemX25519HkdfSha256, HkdfSha256, Aes256Gcm } from "@hpke/core";
import { ed25519 } from "@noble/curves/ed25519";
const suite = new CipherSuite({
kem: new DhkemX25519HkdfSha256(),
kdf: new HkdfSha256(),
aead: new Aes256Gcm(),
});
export const INTENT_PT_LEN = 128;
export async function sealIntent(
intent: IntentFields, // u, pair, side, size, limit, expiry, nonce
authority: Uint8Array, // trader's Ed25519 secret key
enclave: AttestedKey, // ek_C, epoch e, quote hash, from the Registry
): Promise<Uint8Array> {
const body = encodeIntent(intent); // 45 bytes, fixed width
const sig = ed25519.sign(body, authority); // 64 bytes
const pt = new Uint8Array(INTENT_PT_LEN); // zero padded
pt.set(body, 0);
pt.set(sig, body.length);
const sender = await suite.createSenderContext({
recipientPublicKey: await suite.kem.importKey("raw", enclave.ekC),
info: intentInfo(enclave.programId, enclave.epoch, enclave.quoteHash),
});
const ct = await sender.seal(pt); // 128 + 16 bytes
return concat(new Uint8Array(sender.enc), new Uint8Array(ct)); // 176 bytes
}
The listing is the SDK’s sealing routine. encodeIntent writes the trader’s record position, the two asset indices of the pair, the side, the size, the limit price as a fixed-point integer, the expiry slot and the nonce in a fixed order; Chapter 10 shows where the SDK obtains the attested key and how privium.trade(...) calls this function.
3.8 Merkle trees and inclusion proofs
The Ledger is committed on chain as the root of a binary Merkle tree [23] of fixed depth over ciphertext leaves (Chapter 4). Privium uses the domain separation of RFC 6962 [24], which prefixes leaf hashes and interior hashes with different bytes, and SHA-256 for , which Solana programs compute through a runtime syscall [25].
Definition 3.10 (Ledger tree). For a leaf encoding and children ,
An empty position holds , and an empty subtree of height hashes to . An inclusion proof for position is the list of sibling hashes ; the verifier recomputes and or according to bit of , and accepts if .
Theorem 3.4 (Position binding). If an efficient adversary outputs a root , a position , and two accepting inclusion proofs for distinct leaf encodings at , then a collision for can be computed from its output in time .
Proof. Let and be the two recomputed paths. Both follow the bits of the same , so at every level the recomputed value sits on the same side, and both end at . If , the distinct strings and collide. Otherwise let be the largest index with . Then , while the interior inputs and (in the order fixed by bit ) differ in the block holding : a collision. Both cases take one pass over the path. The prefixes make every leaf input differ from every interior input as strings, so a leaf can never be passed off as an interior node or the reverse.
With (Chapter 4 sets it), a proof is bytes and verification costs 33 hash evaluations.
pub const DEPTH: usize = 32;
pub fn leaf_hash(leaf: &[u8]) -> [u8; 32] {
hashv(&[&[0x00], leaf]).to_bytes()
}
pub fn node_hash(l: &[u8; 32], r: &[u8; 32]) -> [u8; 32] {
hashv(&[&[0x01], l, r]).to_bytes()
}
/// Recomputes the root for `leaf` at `index` from its sibling path.
pub fn root_from_path(leaf: &[u8], index: u32, path: &[[u8; 32]; DEPTH]) -> [u8; 32] {
let mut h = leaf_hash(leaf);
for (j, sib) in path.iter().enumerate() {
h = if (index >> j) & 1 == 0 { node_hash(&h, sib) } else { node_hash(sib, &h) };
}
h
}
hashv is the Solana SHA-256 helper over a list of slices, which lowers to the sol_sha256 syscall on chain [25]; the same function runs in the Coprocessor and in the SDK, so the root that the enclave signs, the root that a trader checks and the root that the Escape verifies are computed by one piece of code.
3.9 Signatures: Ed25519 and ECDSA-P256
Two signature schemes appear in Privium, each where its ecosystem already uses it.
Ed25519 (RFC 8032 [26]) signs every Commit with and every Intent with the trader’s authority key. Brendel et al. prove that Ed25519 with the verification rules of RFC 8032 is SUF-CMA in the random oracle model under the DL assumption on edwards25519, provided the verifier rejects non-canonical encodings of the signature scalar, which is the setting that rules out signature malleability [27]. Privium needs strong unforgeability because the Commit signature is the only thing that authorizes a new Ledger root: a second valid signature on an old message must not be usable as a fresh authorization, and in Privium it cannot be, because the signed message includes the Crossing index (Chapter 4, Section 4.8). Solana verifies Ed25519 signatures through its native precompile; Chapter 5 gives the verification pattern and Chapter 9 the instruction layout.
ECDSA over P-256 (FIPS 186-5 [28]) signs the attestation material produced by trusted execution hardware. Privium does not choose it; it inherits it from the hardware vendor’s chain of trust, and verifies it once per enclave key registration, not per Commit (Chapter 5). ECDSA is EUF-CMA in the generic group model, and it is malleable: and verify together. Registration is keyed on the signed content, never on the signature bytes, so malleability changes nothing.
Every signed message in the protocol starts with its own domain tag and the program id, so a signature produced for one purpose cannot be replayed for another, and a signature produced for one Privium deployment cannot be replayed on another. Formally, the tags make the message spaces of distinct purposes disjoint, so an adversary that wins one game against a tagged message family wins EUF-CMA (or SUF-CMA) against the underlying scheme with the same advantage.
3.10 What each guarantee rests on
The table states, for every cryptographic guarantee the later chapters use, the primitive that provides it and the assumption under which it holds. Trust in the enclave and in the Council is treated in Chapters 5 and 6; here we list only what the mathematics guarantees.
| Guarantee | Primitive | Rests on | Used in |
|---|---|---|---|
| Ledger amounts hidden from observers | twisted ElGamal, AES-256-GCM | DDH in ristretto255 (Thm 3.2); GCM IND-CPA with unique nonces | Ch. 4 |
| Committed balances cannot be reopened to other values | Pedersen | DL in ristretto255 (Thm 3.1, Lemma 3.1) | Ch. 4, 6 |
| Per-asset conservation check is sound | Pedersen homomorphism, range proofs | DL; Bulletproofs soundness | Ch. 4 |
| Intents readable only by the attested enclave | HPKE base mode | Gap-DH on X25519, ROM (Thm 3.3) | Ch. 7, 10 |
| A root names exactly one leaf per position | Merkle tree | collision resistance of SHA-256 (Thm 3.4) | Ch. 4, 6 |
| Only the attested enclave advances the Ledger | Ed25519 | DL on edwards25519, ROM, SUF-CMA [27] | Ch. 4, 5, 9 |
| Enclave key bound to its measurement | ECDSA-P256 | EUF-CMA of ECDSA; vendor root of trust | Ch. 5 |
| Council decrypts only correct shares | Chaum-Pedersen | special soundness, ROM (Lemma 3.2) | Ch. 6 |
| Rewritten leaves are well-formed ciphertexts of in-range balances | sigma protocols, range proofs | DL, ROM | Ch. 4, 6 |
Each row is a standard reduction; none relies on a new assumption. The composition that matters most, conservation of every asset at every committed root, is proved in Chapter 4 from Theorem 3.1, Theorem 3.4 and the range proofs of Section 3.6.
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
- H. de Valence, J. Grigg, M. Hamburg, I. Lovecruft, G. Tankersley, F. Valsorda, “The ristretto255 and decaf448 Groups”, RFC 9496, IRTF CFRG, December 2023. https://www.rfc-editor.org/rfc/rfc9496
- Solana Program,
zk-elgamal-proofrepository,zk-sdk/src/encryption/pedersen.rsandelgamal.rs, accessed 2026-11-16. https://github.com/solana-program/zk-elgamal-proof - M. Bellare, C. Namprempre, “Authenticated Encryption: Relations among Notions and Analysis of the Generic Composition Paradigm”, ASIACRYPT 2000. https://eprint.iacr.org/2000/025
- T. P. Pedersen, “Non-Interactive and Information-Theoretic Secure Verifiable Secret Sharing”, CRYPTO 1991. https://doi.org/10.1007/3-540-46766-1_9
- T. ElGamal, “A Public Key Cryptosystem and a Signature Scheme Based on Discrete Logarithms”, IEEE Transactions on Information Theory, 1985. https://doi.org/10.1109/TIT.1985.1057074
- Y. Chen, X. Ma, C. Tang, M. H. Au, “PGC: Decentralized Confidential Payment System with Auditability”, IACR ePrint 2019/319, 2019. https://eprint.iacr.org/2019/319
- Solana Program, “Confidential Balances: Encryption”, accessed 2026-11-16. https://www.solana-program.com/docs/confidential-balances/encryption
- Solana Program, “Confidential Balances: Zero-Knowledge Proofs”, accessed 2026-11-16. https://www.solana-program.com/docs/confidential-balances/zkps
- Anza, “ZK ElGamal Proof Program”, Agave documentation, accessed 2026-11-16. https://docs.anza.xyz/runtime/zk-elgamal-proof
- M. Bellare, A. Boldyreva, J. Staddon, “Randomness Re-use in Multi-recipient Encryption Schemes”, PKC 2003. https://doi.org/10.1007/3-540-36288-6_7
- Solana Foundation, “Post-mortem: June 25, 2025”, June 2025. https://solana.com/news/post-mortem-june-25-2025
- Solana Compass, “Confidential Transfers Return to Solana Mainnet After Year-Long Security Pause”, 18 June 2026. https://solanacompass.com/news/confidential-transfers-return-to-solana-mainnet-after-year-long-security-pause
- Solana Compass, “Solana Activates BN254, BLS12-381 and ZK ElGamal: Three Cryptographic Primitives Now Live”, 7 August 2026. https://solanacompass.com/news/solana-activates-bn254-bls12-381-and-zk-elgamal-three-cryptographic-primitives-now-live
- C. P. Schnorr, “Efficient Signature Generation by Smart Cards”, Journal of Cryptology, 1991. https://doi.org/10.1007/BF00196725
- D. Pointcheval, J. Stern, “Security Arguments for Digital Signatures and Blind Signatures”, Journal of Cryptology, 2000. https://doi.org/10.1007/s001450010003
- D. Bernhard, O. Pereira, B. Warinschi, “How Not to Prove Yourself: Pitfalls of the Fiat-Shamir Heuristic and Applications to Helios”, ASIACRYPT 2012. https://eprint.iacr.org/2016/771
- 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
- M. Dworkin, “Recommendation for Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC”, NIST SP 800-38D, November 2007. https://csrc.nist.gov/pubs/sp/800/38/d/final
- R. Barnes, K. Bhargavan, B. Lipp, C. Wood, “Hybrid Public Key Encryption”, RFC 9180, February 2022. https://www.rfc-editor.org/rfc/rfc9180
- J. Alwen, B. Blanchet, E. Hauck, E. Kiltz, B. Lipp, D. Riepel, “Analysing the HPKE Standard”, EUROCRYPT 2021. https://eprint.iacr.org/2020/1499
- R. C. Merkle, “A Digital Signature Based on a Conventional Encryption Function”, CRYPTO 1987. https://doi.org/10.1007/3-540-48184-2_32
- B. Laurie, A. Langley, E. Kasper, “Certificate Transparency”, RFC 6962, June 2013. https://www.rfc-editor.org/rfc/rfc6962
- Anza,
solana-sha256-hashercrate documentation, accessed 2026-11-16. https://docs.rs/solana-sha256-hasher - S. Josefsson, I. Liusvaara, “Edwards-Curve Digital Signature Algorithm (EdDSA)”, RFC 8032, January 2017. https://www.rfc-editor.org/rfc/rfc8032
- J. Brendel, C. Cremers, D. Jackson, M. Zhao, “The Provable Security of Ed25519: Theory and Practice”, IEEE S&P 2021. https://eprint.iacr.org/2020/823
- NIST, “Digital Signature Standard (DSS)”, FIPS 186-5, February 2023. https://csrc.nist.gov/pubs/fips/186-5/final