gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename ElGamal to ElGamalKeypair

Browse Source
This commit is contained in:
Michael Vines
2021-10-11 11:25:16 -07:00
parent f272c025bd
commit c33e24de57
7 changed files with 82 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
zk-token-sdk/src/encryption/elgamal.rs
View File

@ -29,12 +29,12 @@ use {
}; };
/// Handle for the (twisted) ElGamal encryption scheme /// Handle for the (twisted) ElGamal encryption scheme
pub struct ElGamal { pub struct ElGamalKeypair {
pub pk: ElGamalPubkey, pub pk: ElGamalPubkey,
pub sk: ElGamalSecretKey, pub sk: ElGamalSecretKey,
} }
impl ElGamal { impl ElGamalKeypair {
/// Generates the public and secret keys for ElGamal encryption. /// Generates the public and secret keys for ElGamal encryption.
#[cfg(not(target_arch = "bpf"))] #[cfg(not(target_arch = "bpf"))]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
@ -148,7 +148,7 @@ impl ElGamal {
pub fn read_json<R: Read>(reader: &mut R) -> Result<Self, Box<dyn std::error::Error>> { pub fn read_json<R: Read>(reader: &mut R) -> Result<Self, Box<dyn std::error::Error>> {
let bytes: Vec<u8> = serde_json::from_reader(reader)?; let bytes: Vec<u8> = serde_json::from_reader(reader)?;
Self::from_bytes(&bytes).ok_or_else(|| { Self::from_bytes(&bytes).ok_or_else(|| {
std::io::Error::new(std::io::ErrorKind::Other, "Invalid ElGamal keypair").into() std::io::Error::new(std::io::ErrorKind::Other, "Invalid ElGamalKeypair").into()
}) })
} }
@ -222,7 +222,7 @@ impl ElGamalPubkey {
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
#[cfg(not(target_arch = "bpf"))] #[cfg(not(target_arch = "bpf"))]
pub fn encrypt<T: Into<Scalar>>(&self, msg: T) -> ElGamalCiphertext { pub fn encrypt<T: Into<Scalar>>(&self, msg: T) -> ElGamalCiphertext {
ElGamal::encrypt(self, msg) ElGamalKeypair::encrypt(self, msg)
} }
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
@ -231,7 +231,7 @@ impl ElGamalPubkey {
msg: T, msg: T,
open: &PedersenOpening, open: &PedersenOpening,
) -> ElGamalCiphertext { ) -> ElGamalCiphertext {
ElGamal::encrypt_with(self, msg, open) ElGamalKeypair::encrypt_with(self, msg, open)
} }
/// Generate a decryption token from an ElGamal public key and a Pedersen /// Generate a decryption token from an ElGamal public key and a Pedersen
@ -264,12 +264,12 @@ impl ElGamalSecretKey {
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
pub fn decrypt(&self, ct: &ElGamalCiphertext) -> DiscreteLog { pub fn decrypt(&self, ct: &ElGamalCiphertext) -> DiscreteLog {
ElGamal::decrypt(self, ct) ElGamalKeypair::decrypt(self, ct)
} }
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
pub fn decrypt_u32(&self, ct: &ElGamalCiphertext) -> Option<u32> { pub fn decrypt_u32(&self, ct: &ElGamalCiphertext) -> Option<u32> {
ElGamal::decrypt_u32(self, ct) ElGamalKeypair::decrypt_u32(self, ct)
} }
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
@ -278,7 +278,7 @@ impl ElGamalSecretKey {
ct: &ElGamalCiphertext, ct: &ElGamalCiphertext,
hashmap: &HashMap<[u8; 32], u32>, hashmap: &HashMap<[u8; 32], u32>,
) -> Option<u32> { ) -> Option<u32> {
ElGamal::decrypt_u32_online(self, ct, hashmap) ElGamalKeypair::decrypt_u32_online(self, ct, hashmap)
} }
pub fn to_bytes(&self) -> [u8; 32] { pub fn to_bytes(&self) -> [u8; 32] {
@ -356,12 +356,12 @@ impl ElGamalCiphertext {
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
pub fn decrypt(&self, sk: &ElGamalSecretKey) -> DiscreteLog { pub fn decrypt(&self, sk: &ElGamalSecretKey) -> DiscreteLog {
ElGamal::decrypt(sk, self) ElGamalKeypair::decrypt(sk, self)
} }
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
pub fn decrypt_u32(&self, sk: &ElGamalSecretKey) -> Option<u32> { pub fn decrypt_u32(&self, sk: &ElGamalSecretKey) -> Option<u32> {
ElGamal::decrypt_u32(sk, self) ElGamalKeypair::decrypt_u32(sk, self)
} }
/// Utility method for code ergonomics. /// Utility method for code ergonomics.
@ -370,7 +370,7 @@ impl ElGamalCiphertext {
sk: &ElGamalSecretKey, sk: &ElGamalSecretKey,
hashmap: &HashMap<[u8; 32], u32>, hashmap: &HashMap<[u8; 32], u32>,
) -> Option<u32> { ) -> Option<u32> {
ElGamal::decrypt_u32_online(sk, self, hashmap) ElGamalKeypair::decrypt_u32_online(sk, self, hashmap)
} }
} }
@ -458,25 +458,25 @@ mod tests {
#[test] #[test]
fn test_encrypt_decrypt_correctness() { fn test_encrypt_decrypt_correctness() {
let ElGamal { pk, sk } = ElGamal::default(); let ElGamalKeypair { pk, sk } = ElGamalKeypair::default();
let msg: u32 = 57; let msg: u32 = 57;
let ct = ElGamal::encrypt(&pk, msg); let ct = ElGamalKeypair::encrypt(&pk, msg);
let expected_instance = DiscreteLog { let expected_instance = DiscreteLog {
generator: PedersenBase::default().G, generator: PedersenBase::default().G,
target: Scalar::from(msg) * PedersenBase::default().G, target: Scalar::from(msg) * PedersenBase::default().G,
}; };
assert_eq!(expected_instance, ElGamal::decrypt(&sk, &ct)); assert_eq!(expected_instance, ElGamalKeypair::decrypt(&sk, &ct));
// Commenting out for faster testing // Commenting out for faster testing
// assert_eq!(msg, ElGamal::decrypt_u32(&sk, &ct).unwrap()); // assert_eq!(msg, ElGamalKeypair::decrypt_u32(&sk, &ct).unwrap());
} }
#[test] #[test]
fn test_decrypt_handle() { fn test_decrypt_handle() {
let ElGamal { pk: pk_1, sk: sk_1 } = ElGamal::default(); let ElGamalKeypair { pk: pk_1, sk: sk_1 } = ElGamalKeypair::default();
let ElGamal { pk: pk_2, sk: sk_2 } = ElGamal::default(); let ElGamalKeypair { pk: pk_2, sk: sk_2 } = ElGamalKeypair::default();
let msg: u32 = 77; let msg: u32 = 77;
let (comm, open) = Pedersen::new(msg); let (comm, open) = Pedersen::new(msg);
@ -502,7 +502,7 @@ mod tests {
#[test] #[test]
fn test_homomorphic_addition() { fn test_homomorphic_addition() {
let ElGamal { pk, sk: _ } = ElGamal::default(); let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let msg_0: u64 = 57; let msg_0: u64 = 57;
let msg_1: u64 = 77; let msg_1: u64 = 77;
@ -510,24 +510,24 @@ mod tests {
let open_0 = PedersenOpening::random(&mut OsRng); let open_0 = PedersenOpening::random(&mut OsRng);
let open_1 = PedersenOpening::random(&mut OsRng); let open_1 = PedersenOpening::random(&mut OsRng);
let ct_0 = ElGamal::encrypt_with(&pk, msg_0, &open_0); let ct_0 = ElGamalKeypair::encrypt_with(&pk, msg_0, &open_0);
let ct_1 = ElGamal::encrypt_with(&pk, msg_1, &open_1); let ct_1 = ElGamalKeypair::encrypt_with(&pk, msg_1, &open_1);
let ct_sum = ElGamal::encrypt_with(&pk, msg_0 + msg_1, &(open_0 + open_1)); let ct_sum = ElGamalKeypair::encrypt_with(&pk, msg_0 + msg_1, &(open_0 + open_1));
assert_eq!(ct_sum, ct_0 + ct_1); assert_eq!(ct_sum, ct_0 + ct_1);
// Add to ElGamal ciphertext // Add to ElGamal ciphertext
let open = PedersenOpening::random(&mut OsRng); let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamal::encrypt_with(&pk, msg_0, &open); let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let ct_sum = ElGamal::encrypt_with(&pk, msg_0 + msg_1, &open); let ct_sum = ElGamalKeypair::encrypt_with(&pk, msg_0 + msg_1, &open);
assert_eq!(ct_sum, ct.add_to_msg(msg_1)); assert_eq!(ct_sum, ct.add_to_msg(msg_1));
} }
#[test] #[test]
fn test_homomorphic_subtraction() { fn test_homomorphic_subtraction() {
let ElGamal { pk, sk: _ } = ElGamal::default(); let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let msg_0: u64 = 77; let msg_0: u64 = 77;
let msg_1: u64 = 55; let msg_1: u64 = 55;
@ -535,56 +535,56 @@ mod tests {
let open_0 = PedersenOpening::random(&mut OsRng); let open_0 = PedersenOpening::random(&mut OsRng);
let open_1 = PedersenOpening::random(&mut OsRng); let open_1 = PedersenOpening::random(&mut OsRng);
let ct_0 = ElGamal::encrypt_with(&pk, msg_0, &open_0); let ct_0 = ElGamalKeypair::encrypt_with(&pk, msg_0, &open_0);
let ct_1 = ElGamal::encrypt_with(&pk, msg_1, &open_1); let ct_1 = ElGamalKeypair::encrypt_with(&pk, msg_1, &open_1);
let ct_sub = ElGamal::encrypt_with(&pk, msg_0 - msg_1, &(open_0 - open_1)); let ct_sub = ElGamalKeypair::encrypt_with(&pk, msg_0 - msg_1, &(open_0 - open_1));
assert_eq!(ct_sub, ct_0 - ct_1); assert_eq!(ct_sub, ct_0 - ct_1);
// Subtract to ElGamal ciphertext // Subtract to ElGamal ciphertext
let open = PedersenOpening::random(&mut OsRng); let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamal::encrypt_with(&pk, msg_0, &open); let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let ct_sub = ElGamal::encrypt_with(&pk, msg_0 - msg_1, &open); let ct_sub = ElGamalKeypair::encrypt_with(&pk, msg_0 - msg_1, &open);
assert_eq!(ct_sub, ct.sub_to_msg(msg_1)); assert_eq!(ct_sub, ct.sub_to_msg(msg_1));
} }
#[test] #[test]
fn test_homomorphic_multiplication() { fn test_homomorphic_multiplication() {
let ElGamal { pk, sk: _ } = ElGamal::default(); let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let msg_0: u64 = 57; let msg_0: u64 = 57;
let msg_1: u64 = 77; let msg_1: u64 = 77;
let open = PedersenOpening::random(&mut OsRng); let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamal::encrypt_with(&pk, msg_0, &open); let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let scalar = Scalar::from(msg_1); let scalar = Scalar::from(msg_1);
let ct_prod = ElGamal::encrypt_with(&pk, msg_0 * msg_1, &(open * scalar)); let ct_prod = ElGamalKeypair::encrypt_with(&pk, msg_0 * msg_1, &(open * scalar));
assert_eq!(ct_prod, ct * scalar); assert_eq!(ct_prod, ct * scalar);
} }
#[test] #[test]
fn test_homomorphic_division() { fn test_homomorphic_division() {
let ElGamal { pk, sk: _ } = ElGamal::default(); let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let msg_0: u64 = 55; let msg_0: u64 = 55;
let msg_1: u64 = 5; let msg_1: u64 = 5;
let open = PedersenOpening::random(&mut OsRng); let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamal::encrypt_with(&pk, msg_0, &open); let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let scalar = Scalar::from(msg_1); let scalar = Scalar::from(msg_1);
let ct_div = ElGamal::encrypt_with(&pk, msg_0 / msg_1, &(open / scalar)); let ct_div = ElGamalKeypair::encrypt_with(&pk, msg_0 / msg_1, &(open / scalar));
assert_eq!(ct_div, ct / scalar); assert_eq!(ct_div, ct / scalar);
} }
#[test] #[test]
fn test_serde_ciphertext() { fn test_serde_ciphertext() {
let ElGamal { pk, sk: _ } = ElGamal::default(); let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let msg: u64 = 77; let msg: u64 = 77;
let ct = pk.encrypt(msg); let ct = pk.encrypt(msg);
@ -596,7 +596,7 @@ mod tests {
#[test] #[test]
fn test_serde_pubkey() { fn test_serde_pubkey() {
let ElGamal { pk, sk: _ } = ElGamal::default(); let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let encoded = bincode::serialize(&pk).unwrap(); let encoded = bincode::serialize(&pk).unwrap();
let decoded: ElGamalPubkey = bincode::deserialize(&encoded).unwrap(); let decoded: ElGamalPubkey = bincode::deserialize(&encoded).unwrap();
@ -606,7 +606,7 @@ mod tests {
#[test] #[test]
fn test_serde_secretkey() { fn test_serde_secretkey() {
let ElGamal { pk: _, sk } = ElGamal::default(); let ElGamalKeypair { pk: _, sk } = ElGamalKeypair::default();
let encoded = bincode::serialize(&sk).unwrap(); let encoded = bincode::serialize(&sk).unwrap();
let decoded: ElGamalSecretKey = bincode::deserialize(&encoded).unwrap(); let decoded: ElGamalSecretKey = bincode::deserialize(&encoded).unwrap();
@ -617,19 +617,19 @@ mod tests {
fn tmp_file_path(name: &str) -> String { fn tmp_file_path(name: &str) -> String {
use std::env; use std::env;
let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string()); let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
let keypair = ElGamal::default(); let keypair = ElGamalKeypair::default();
format!("{}/tmp/{}-{}", out_dir, name, keypair.pk) format!("{}/tmp/{}-{}", out_dir, name, keypair.pk)
} }
#[test] #[test]
fn test_write_keypair_file() { fn test_write_keypair_file() {
let outfile = tmp_file_path("test_write_keypair_file.json"); let outfile = tmp_file_path("test_write_keypair_file.json");
let serialized_keypair = ElGamal::default().write_json_file(&outfile).unwrap(); let serialized_keypair = ElGamalKeypair::default().write_json_file(&outfile).unwrap();
let keypair_vec: Vec<u8> = serde_json::from_str(&serialized_keypair).unwrap(); let keypair_vec: Vec<u8> = serde_json::from_str(&serialized_keypair).unwrap();
assert!(Path::new(&outfile).exists()); assert!(Path::new(&outfile).exists());
assert_eq!( assert_eq!(
keypair_vec, keypair_vec,
ElGamal::read_json_file(&outfile) ElGamalKeypair::read_json_file(&outfile)
.unwrap() .unwrap()
.to_bytes() .to_bytes()
.to_vec() .to_vec()
@ -656,16 +656,16 @@ mod tests {
fn test_write_keypair_file_overwrite_ok() { fn test_write_keypair_file_overwrite_ok() {
let outfile = tmp_file_path("test_write_keypair_file_overwrite_ok.json"); let outfile = tmp_file_path("test_write_keypair_file_overwrite_ok.json");
ElGamal::default().write_json_file(&outfile).unwrap(); ElGamalKeypair::default().write_json_file(&outfile).unwrap();
ElGamal::default().write_json_file(&outfile).unwrap(); ElGamalKeypair::default().write_json_file(&outfile).unwrap();
} }
#[test] #[test]
fn test_write_keypair_file_truncate() { fn test_write_keypair_file_truncate() {
let outfile = tmp_file_path("test_write_keypair_file_truncate.json"); let outfile = tmp_file_path("test_write_keypair_file_truncate.json");
ElGamal::default().write_json_file(&outfile).unwrap(); ElGamalKeypair::default().write_json_file(&outfile).unwrap();
ElGamal::read_json_file(&outfile).unwrap(); ElGamalKeypair::read_json_file(&outfile).unwrap();
// Ensure outfile is truncated // Ensure outfile is truncated
{ {
@ -673,7 +673,7 @@ mod tests {
f.write_all(String::from_utf8([b'a'; 2048].to_vec()).unwrap().as_bytes()) f.write_all(String::from_utf8([b'a'; 2048].to_vec()).unwrap().as_bytes())
.unwrap(); .unwrap();
} }
ElGamal::default().write_json_file(&outfile).unwrap(); ElGamalKeypair::default().write_json_file(&outfile).unwrap();
ElGamal::read_json_file(&outfile).unwrap(); ElGamalKeypair::read_json_file(&outfile).unwrap();
} }
} }

4
zk-token-sdk/src/instruction/close_account.rs
View File

@ -147,12 +147,12 @@ impl CloseAccountProof {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use super::*;
use crate::encryption::elgamal::ElGamal; use crate::encryption::elgamal::ElGamalKeypair;
use crate::encryption::pedersen::{Pedersen, PedersenDecryptHandle, PedersenOpening}; use crate::encryption::pedersen::{Pedersen, PedersenDecryptHandle, PedersenOpening};
#[test] #[test]
fn test_close_account_correctness() { fn test_close_account_correctness() {
let source = ElGamal::default(); let source = ElGamalKeypair::default();
// invalid ciphertexts // invalid ciphertexts
let balance = source.pk.encrypt(0_u64); let balance = source.pk.encrypt(0_u64);

28
zk-token-sdk/src/instruction/transfer.rs
View File

@ -61,7 +61,7 @@ impl TransferData {
) -> Self { ) -> Self {
// split and encrypt transfer amount // split and encrypt transfer amount
// //
// encryption is a bit more involved since we are generating each components of an ElGamal // encryption is a bit more involved since we are generating each components of an ElGamalKeypair
// ciphertext separately. // ciphertext separately.
let (amount_lo, amount_hi) = split_u64_into_u32(transfer_amount); let (amount_lo, amount_hi) = split_u64_into_u32(transfer_amount);
@ -463,17 +463,19 @@ pub fn combine_u32_ciphertexts(ct_lo: ElGamalCiphertext, ct_hi: ElGamalCiphertex
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use super::*;
use crate::encryption::{discrete_log::decode_u32_precomputation_for_G, elgamal::ElGamal}; use crate::encryption::{
discrete_log::decode_u32_precomputation_for_G, elgamal::ElGamalKeypair,
};
#[test] #[test]
fn test_transfer_correctness() { fn test_transfer_correctness() {
// ElGamal keys for source, destination, and auditor accounts // ElGamalKeypair keys for source, destination, and auditor accounts
let ElGamal { let ElGamalKeypair {
pk: source_pk, pk: source_pk,
sk: source_sk, sk: source_sk,
} = ElGamal::default(); } = ElGamalKeypair::default();
let dest_pk = ElGamal::default().pk; let dest_pk = ElGamalKeypair::default().pk;
let auditor_pk = ElGamal::default().pk; let auditor_pk = ElGamalKeypair::default().pk;
// create source account spendable ciphertext // create source account spendable ciphertext
let spendable_balance: u64 = 77; let spendable_balance: u64 = 77;
@ -498,16 +500,16 @@ mod test {
#[test] #[test]
fn test_source_dest_ciphertext() { fn test_source_dest_ciphertext() {
// ElGamal keys for source, destination, and auditor accounts // ElGamalKeypair keys for source, destination, and auditor accounts
let ElGamal { let ElGamalKeypair {
pk: source_pk, pk: source_pk,
sk: source_sk, sk: source_sk,
} = ElGamal::default(); } = ElGamalKeypair::default();
let ElGamal { let ElGamalKeypair {
pk: dest_pk, pk: dest_pk,
sk: dest_sk, sk: dest_sk,
} = ElGamal::default(); } = ElGamalKeypair::default();
let auditor_pk = ElGamal::default().pk; let auditor_pk = ElGamalKeypair::default().pk;
// create source account spendable ciphertext // create source account spendable ciphertext
let spendable_balance: u64 = 77; let spendable_balance: u64 = 77;

14
zk-token-sdk/src/instruction/update_account_pk.rs
View File

@ -214,13 +214,13 @@ impl UpdateAccountPkProof {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use super::*;
use crate::encryption::elgamal::ElGamal; use crate::encryption::elgamal::ElGamalKeypair;
use crate::encryption::pedersen::{Pedersen, PedersenDecryptHandle, PedersenOpening}; use crate::encryption::pedersen::{Pedersen, PedersenDecryptHandle, PedersenOpening};
#[test] #[test]
fn test_update_account_public_key_general_cases() { fn test_update_account_public_key_general_cases() {
let current = ElGamal::default(); let current = ElGamalKeypair::default();
let new = ElGamal::default(); let new = ElGamalKeypair::default();
// If current_ct and new_ct encrypt same values, then the proof verification should succeed // If current_ct and new_ct encrypt same values, then the proof verification should succeed
let balance: u64 = 77; let balance: u64 = 77;
@ -239,8 +239,8 @@ mod test {
#[test] #[test]
fn test_update_account_public_key_zeroed_ciphertexts() { fn test_update_account_public_key_zeroed_ciphertexts() {
let current = ElGamal::default(); let current = ElGamalKeypair::default();
let new = ElGamal::default(); let new = ElGamalKeypair::default();
// A zeroed cipehrtext should be considered as an account balance of 0 // A zeroed cipehrtext should be considered as an account balance of 0
let balance: u64 = 0; let balance: u64 = 0;
@ -286,8 +286,8 @@ mod test {
#[test] #[test]
fn test_update_account_public_key_partially_zeroed_ciphertexts() { fn test_update_account_public_key_partially_zeroed_ciphertexts() {
let current = ElGamal::default(); let current = ElGamalKeypair::default();
let new = ElGamal::default(); let new = ElGamalKeypair::default();
let balance = 0_u64; let balance = 0_u64;
let balance_ciphertext = new.pk.encrypt(balance); let balance_ciphertext = new.pk.encrypt(balance);

4
zk-token-sdk/src/instruction/withdraw.rs
View File

@ -173,13 +173,13 @@ impl WithdrawProof {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use super::*;
use crate::encryption::elgamal::ElGamal; use crate::encryption::elgamal::ElGamalKeypair;
#[test] #[test]
#[ignore] #[ignore]
fn test_withdraw_correctness() { fn test_withdraw_correctness() {
// generate and verify proof for the proper setting // generate and verify proof for the proper setting
let ElGamal { pk, sk } = ElGamal::default(); let ElGamalKeypair { pk, sk } = ElGamalKeypair::default();
let current_balance: u64 = 77; let current_balance: u64 = 77;
let current_balance_ct = pk.encrypt(current_balance); let current_balance_ct = pk.encrypt(current_balance);

4
zk-token-sdk/src/transcript.rs
View File

@ -7,11 +7,11 @@ use merlin::Transcript;
use crate::errors::ProofError; use crate::errors::ProofError;
pub trait TranscriptProtocol { pub trait TranscriptProtocol {
/// Append a domain separator for an `n`-bit rangeproof for ElGamal /// Append a domain separator for an `n`-bit rangeproof for ElGamalKeypair
/// ciphertext using a decryption key /// ciphertext using a decryption key
fn rangeproof_from_key_domain_sep(&mut self, n: u64); fn rangeproof_from_key_domain_sep(&mut self, n: u64);
/// Append a domain separator for an `n`-bit rangeproof for ElGamal /// Append a domain separator for an `n`-bit rangeproof for ElGamalKeypair
/// ciphertext using an opening /// ciphertext using an opening
fn rangeproof_from_opening_domain_sep(&mut self, n: u64); fn rangeproof_from_opening_domain_sep(&mut self, n: u64);

14
zk-token-sdk/src/zk_token_elgamal/ops.rs
View File

@ -234,7 +234,7 @@ mod tests {
use { use {
crate::{ crate::{
encryption::{ encryption::{
elgamal::{ElGamal, ElGamalCiphertext}, elgamal::{ElGamalCiphertext, ElGamalKeypair},
pedersen::{Pedersen, PedersenOpening}, pedersen::{Pedersen, PedersenOpening},
}, },
zk_token_elgamal::{ops, pod}, zk_token_elgamal::{ops, pod},
@ -252,7 +252,7 @@ mod tests {
// spendable_ct should be an encryption of 0 for any public key when // spendable_ct should be an encryption of 0 for any public key when
// `PedersenOpen::default()` is used // `PedersenOpen::default()` is used
let pk = ElGamal::default().pk; let pk = ElGamalKeypair::default().pk;
let balance: u64 = 0; let balance: u64 = 0;
assert_eq!( assert_eq!(
spendable_ct, spendable_ct,
@ -276,7 +276,7 @@ mod tests {
let added_ct = ops::add_to(&spendable_balance, 55).unwrap(); let added_ct = ops::add_to(&spendable_balance, 55).unwrap();
let pk = ElGamal::default().pk; let pk = ElGamalKeypair::default().pk;
let expected: pod::ElGamalCiphertext = let expected: pod::ElGamalCiphertext =
pk.encrypt_with(55_u64, &PedersenOpening::default()).into(); pk.encrypt_with(55_u64, &PedersenOpening::default()).into();
@ -286,7 +286,7 @@ mod tests {
#[test] #[test]
fn test_subtract_from() { fn test_subtract_from() {
let amount = 77_u64; let amount = 77_u64;
let pk = ElGamal::default().pk; let pk = ElGamalKeypair::default().pk;
let open = PedersenOpening::random(&mut OsRng); let open = PedersenOpening::random(&mut OsRng);
let encrypted_amount: pod::ElGamalCiphertext = pk.encrypt_with(amount, &open).into(); let encrypted_amount: pod::ElGamalCiphertext = pk.encrypt_with(amount, &open).into();
@ -312,9 +312,9 @@ mod tests {
let (amount_lo, amount_hi) = split_u64_into_u32(transfer_amount); let (amount_lo, amount_hi) = split_u64_into_u32(transfer_amount);
// generate public keys // generate public keys
let source_pk = ElGamal::default().pk; let source_pk = ElGamalKeypair::default().pk;
let dest_pk = ElGamal::default().pk; let dest_pk = ElGamalKeypair::default().pk;
let auditor_pk = ElGamal::default().pk; let auditor_pk = ElGamalKeypair::default().pk;
// commitments associated with TransferRangeProof // commitments associated with TransferRangeProof
let (comm_lo, open_lo) = Pedersen::new(amount_lo); let (comm_lo, open_lo) = Pedersen::new(amount_lo);