blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename ElGamalKeypair fields

This commit is contained in:
Michael Vines 2021-10-11 11:32:39 -07:00
parent c33e24de57
commit 93eb49a3e3
6 changed files with 134 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -28,10 +28,12 @@ use {
},
};
/// Handle for the (twisted) ElGamal encryption scheme
/// A (twisted) ElGamal encryption keypair.
pub struct ElGamalKeypair {
pub pk: ElGamalPubkey,
pub sk: ElGamalSecretKey,
/// The public half of this keypair.
pub public: ElGamalPubkey,
/// The secret half of this keypair.
pub secret: ElGamalSecretKey,
}
impl ElGamalKeypair {
@ -61,17 +63,17 @@ impl ElGamalKeypair {
let P = s.invert() * H;
Self {
pk: ElGamalPubkey(P),
sk: ElGamalSecretKey(s),
public: ElGamalPubkey(P),
secret: ElGamalSecretKey(s),
}
}
/// On input a public key and a message to be encrypted, the function
/// returns an ElGamal ciphertext of the message under the public key.
#[cfg(not(target_arch = "bpf"))]
pub fn encrypt<T: Into<Scalar>>(pk: &ElGamalPubkey, amount: T) -> ElGamalCiphertext {
pub fn encrypt<T: Into<Scalar>>(public: &ElGamalPubkey, amount: T) -> ElGamalCiphertext {
let (message_comm, open) = Pedersen::new(amount);
let decrypt_handle = pk.decrypt_handle(&open);
let decrypt_handle = public.decrypt_handle(&open);
ElGamalCiphertext {
message_comm,
@ -83,12 +85,12 @@ impl ElGamalKeypair {
/// returns an ElGamal ciphertext of the message under the public key using
/// the opening.
pub fn encrypt_with<T: Into<Scalar>>(
pk: &ElGamalPubkey,
public: &ElGamalPubkey,
amount: T,
open: &PedersenOpening,
) -> ElGamalCiphertext {
let message_comm = Pedersen::with(amount, open);
let decrypt_handle = pk.decrypt_handle(open);
let decrypt_handle = public.decrypt_handle(open);
ElGamalCiphertext {
message_comm,
@ -100,8 +102,8 @@ impl ElGamalKeypair {
///
/// The output of the function is of type `DiscreteLog`. The exact message
/// can be recovered via the DiscreteLog's decode method.
pub fn decrypt(sk: &ElGamalSecretKey, ct: &ElGamalCiphertext) -> DiscreteLog {
let ElGamalSecretKey(s) = sk;
pub fn decrypt(secret: &ElGamalSecretKey, ct: &ElGamalCiphertext) -> DiscreteLog {
let ElGamalSecretKey(s) = secret;
let ElGamalCiphertext {
message_comm,
decrypt_handle,
@ -115,32 +117,32 @@ impl ElGamalKeypair {
/// On input a secret key and a ciphertext, the function decrypts the
/// ciphertext for a u32 value.
pub fn decrypt_u32(sk: &ElGamalSecretKey, ct: &ElGamalCiphertext) -> Option<u32> {
let discrete_log_instance = Self::decrypt(sk, ct);
pub fn decrypt_u32(secret: &ElGamalSecretKey, ct: &ElGamalCiphertext) -> Option<u32> {
let discrete_log_instance = Self::decrypt(secret, ct);
discrete_log_instance.decode_u32()
}
/// On input a secret key, ciphertext, and hashmap, the function decrypts the
/// ciphertext for a u32 value.
pub fn decrypt_u32_online(
sk: &ElGamalSecretKey,
secret: &ElGamalSecretKey,
ct: &ElGamalCiphertext,
hashmap: &HashMap<[u8; 32], u32>,
) -> Option<u32> {
let discrete_log_instance = Self::decrypt(sk, ct);
let discrete_log_instance = Self::decrypt(secret, ct);
discrete_log_instance.decode_u32_online(hashmap)
}
pub fn to_bytes(&self) -> [u8; 64] {
let mut bytes = self.pk.to_bytes().to_vec();
bytes.extend(self.sk.to_bytes());
let mut bytes = self.public.to_bytes().to_vec();
bytes.extend(self.secret.to_bytes());
bytes.try_into().expect("incorrect length")
}
pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
Some(Self {
pk: ElGamalPubkey::from_bytes(bytes[..32].try_into().ok()?)?,
sk: ElGamalSecretKey::from_bytes(bytes[32..].try_into().ok()?)?,
public: ElGamalPubkey::from_bytes(bytes[..32].try_into().ok()?)?,
secret: ElGamalSecretKey::from_bytes(bytes[32..].try_into().ok()?)?,
})
}
@ -355,22 +357,22 @@ impl ElGamalCiphertext {
}
/// Utility method for code ergonomics.
pub fn decrypt(&self, sk: &ElGamalSecretKey) -> DiscreteLog {
ElGamalKeypair::decrypt(sk, self)
pub fn decrypt(&self, secret: &ElGamalSecretKey) -> DiscreteLog {
ElGamalKeypair::decrypt(secret, self)
}
/// Utility method for code ergonomics.
pub fn decrypt_u32(&self, sk: &ElGamalSecretKey) -> Option<u32> {
ElGamalKeypair::decrypt_u32(sk, self)
pub fn decrypt_u32(&self, secret: &ElGamalSecretKey) -> Option<u32> {
ElGamalKeypair::decrypt_u32(secret, self)
}
/// Utility method for code ergonomics.
pub fn decrypt_u32_online(
&self,
sk: &ElGamalSecretKey,
secret: &ElGamalSecretKey,
hashmap: &HashMap<[u8; 32], u32>,
) -> Option<u32> {
ElGamalKeypair::decrypt_u32_online(sk, self, hashmap)
ElGamalKeypair::decrypt_u32_online(secret, self, hashmap)
}
}
@ -458,25 +460,31 @@ mod tests {
#[test]
fn test_encrypt_decrypt_correctness() {
let ElGamalKeypair { pk, sk } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret } = ElGamalKeypair::default();
let msg: u32 = 57;
let ct = ElGamalKeypair::encrypt(&pk, msg);
let ct = ElGamalKeypair::encrypt(&public, msg);
let expected_instance = DiscreteLog {
generator: PedersenBase::default().G,
target: Scalar::from(msg) * PedersenBase::default().G,
};
assert_eq!(expected_instance, ElGamalKeypair::decrypt(&sk, &ct));
assert_eq!(expected_instance, ElGamalKeypair::decrypt(&secret, &ct));
// Commenting out for faster testing
// assert_eq!(msg, ElGamalKeypair::decrypt_u32(&sk, &ct).unwrap());
// assert_eq!(msg, ElGamalKeypair::decrypt_u32(&secret, &ct).unwrap());
}
#[test]
fn test_decrypt_handle() {
let ElGamalKeypair { pk: pk_1, sk: sk_1 } = ElGamalKeypair::default();
let ElGamalKeypair { pk: pk_2, sk: sk_2 } = ElGamalKeypair::default();
let ElGamalKeypair {
public: pk_1,
secret: sk_1,
} = ElGamalKeypair::default();
let ElGamalKeypair {
public: pk_2,
secret: sk_2,
} = ElGamalKeypair::default();
let msg: u32 = 77;
let (comm, open) = Pedersen::new(msg);
@ -502,7 +510,7 @@ mod tests {
#[test]
fn test_homomorphic_addition() {
let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret: _ } = ElGamalKeypair::default();
let msg_0: u64 = 57;
let msg_1: u64 = 77;
@ -510,24 +518,24 @@ mod tests {
let open_0 = PedersenOpening::random(&mut OsRng);
let open_1 = PedersenOpening::random(&mut OsRng);
let ct_0 = ElGamalKeypair::encrypt_with(&pk, msg_0, &open_0);
let ct_1 = ElGamalKeypair::encrypt_with(&pk, msg_1, &open_1);
let ct_0 = ElGamalKeypair::encrypt_with(&public, msg_0, &open_0);
let ct_1 = ElGamalKeypair::encrypt_with(&public, msg_1, &open_1);
let ct_sum = ElGamalKeypair::encrypt_with(&pk, msg_0 + msg_1, &(open_0 + open_1));
let ct_sum = ElGamalKeypair::encrypt_with(&public, msg_0 + msg_1, &(open_0 + open_1));
assert_eq!(ct_sum, ct_0 + ct_1);
// Add to ElGamal ciphertext
let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let ct_sum = ElGamalKeypair::encrypt_with(&pk, msg_0 + msg_1, &open);
let ct = ElGamalKeypair::encrypt_with(&public, msg_0, &open);
let ct_sum = ElGamalKeypair::encrypt_with(&public, msg_0 + msg_1, &open);
assert_eq!(ct_sum, ct.add_to_msg(msg_1));
}
#[test]
fn test_homomorphic_subtraction() {
let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret: _ } = ElGamalKeypair::default();
let msg_0: u64 = 77;
let msg_1: u64 = 55;
@ -535,58 +543,58 @@ mod tests {
let open_0 = PedersenOpening::random(&mut OsRng);
let open_1 = PedersenOpening::random(&mut OsRng);
let ct_0 = ElGamalKeypair::encrypt_with(&pk, msg_0, &open_0);
let ct_1 = ElGamalKeypair::encrypt_with(&pk, msg_1, &open_1);
let ct_0 = ElGamalKeypair::encrypt_with(&public, msg_0, &open_0);
let ct_1 = ElGamalKeypair::encrypt_with(&public, msg_1, &open_1);
let ct_sub = ElGamalKeypair::encrypt_with(&pk, msg_0 - msg_1, &(open_0 - open_1));
let ct_sub = ElGamalKeypair::encrypt_with(&public, msg_0 - msg_1, &(open_0 - open_1));
assert_eq!(ct_sub, ct_0 - ct_1);
// Subtract to ElGamal ciphertext
let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let ct_sub = ElGamalKeypair::encrypt_with(&pk, msg_0 - msg_1, &open);
let ct = ElGamalKeypair::encrypt_with(&public, msg_0, &open);
let ct_sub = ElGamalKeypair::encrypt_with(&public, msg_0 - msg_1, &open);
assert_eq!(ct_sub, ct.sub_to_msg(msg_1));
}
#[test]
fn test_homomorphic_multiplication() {
let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret: _ } = ElGamalKeypair::default();
let msg_0: u64 = 57;
let msg_1: u64 = 77;
let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let ct = ElGamalKeypair::encrypt_with(&public, msg_0, &open);
let scalar = Scalar::from(msg_1);
let ct_prod = ElGamalKeypair::encrypt_with(&pk, msg_0 * msg_1, &(open * scalar));
let ct_prod = ElGamalKeypair::encrypt_with(&public, msg_0 * msg_1, &(open * scalar));
assert_eq!(ct_prod, ct * scalar);
}
#[test]
fn test_homomorphic_division() {
let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret: _ } = ElGamalKeypair::default();
let msg_0: u64 = 55;
let msg_1: u64 = 5;
let open = PedersenOpening::random(&mut OsRng);
let ct = ElGamalKeypair::encrypt_with(&pk, msg_0, &open);
let ct = ElGamalKeypair::encrypt_with(&public, msg_0, &open);
let scalar = Scalar::from(msg_1);
let ct_div = ElGamalKeypair::encrypt_with(&pk, msg_0 / msg_1, &(open / scalar));
let ct_div = ElGamalKeypair::encrypt_with(&public, msg_0 / msg_1, &(open / scalar));
assert_eq!(ct_div, ct / scalar);
}
#[test]
fn test_serde_ciphertext() {
let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret: _ } = ElGamalKeypair::default();
let msg: u64 = 77;
let ct = pk.encrypt(msg);
let ct = public.encrypt(msg);
let encoded = bincode::serialize(&ct).unwrap();
let decoded: ElGamalCiphertext = bincode::deserialize(&encoded).unwrap();
@ -596,29 +604,29 @@ mod tests {
#[test]
fn test_serde_pubkey() {
let ElGamalKeypair { pk, sk: _ } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret: _ } = ElGamalKeypair::default();
let encoded = bincode::serialize(&pk).unwrap();
let encoded = bincode::serialize(&public).unwrap();
let decoded: ElGamalPubkey = bincode::deserialize(&encoded).unwrap();
assert_eq!(pk, decoded);
assert_eq!(public, decoded);
}
#[test]
fn test_serde_secretkey() {
let ElGamalKeypair { pk: _, sk } = ElGamalKeypair::default();
let ElGamalKeypair { public: _, secret } = ElGamalKeypair::default();
let encoded = bincode::serialize(&sk).unwrap();
let encoded = bincode::serialize(&secret).unwrap();
let decoded: ElGamalSecretKey = bincode::deserialize(&encoded).unwrap();
assert_eq!(sk, decoded);
assert_eq!(secret, decoded);
}
fn tmp_file_path(name: &str) -> String {
use std::env;
let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
let keypair = ElGamalKeypair::default();
format!("{}/tmp/{}-{}", out_dir, name, keypair.pk)
format!("{}/tmp/{}-{}", out_dir, name, keypair.public)
}
#[test]

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

@ -155,7 +155,7 @@ mod test {
let source = ElGamalKeypair::default();
// invalid ciphertexts
let balance = source.pk.encrypt(0_u64);
let balance = source.public.encrypt(0_u64);
let zeroed_comm = Pedersen::with(0_u64, &PedersenOpening::default());
let handle = balance.decrypt_handle;
@ -165,7 +165,7 @@ mod test {
decrypt_handle: handle,
};
let proof = CloseAccountProof::new(&source.sk, &zeroed_comm_ciphertext);
let proof = CloseAccountProof::new(&source.secret, &zeroed_comm_ciphertext);
assert!(proof.verify(&zeroed_comm_ciphertext).is_err());
let zeroed_handle_ciphertext = ElGamalCiphertext {
@ -173,24 +173,24 @@ mod test {
decrypt_handle: PedersenDecryptHandle::default(),
};
let proof = CloseAccountProof::new(&source.sk, &zeroed_handle_ciphertext);
let proof = CloseAccountProof::new(&source.secret, &zeroed_handle_ciphertext);
assert!(proof.verify(&zeroed_handle_ciphertext).is_err());
// valid ciphertext, but encryption of non-zero amount
let balance = source.pk.encrypt(55_u64);
let balance = source.public.encrypt(55_u64);
let proof = CloseAccountProof::new(&source.sk, &balance);
let proof = CloseAccountProof::new(&source.secret, &balance);
assert!(proof.verify(&balance).is_err());
// all-zeroed ciphertext interpretted as a valid encryption of zero
let zeroed_ct: ElGamalCiphertext = pod::ElGamalCiphertext::zeroed().try_into().unwrap();
let proof = CloseAccountProof::new(&source.sk, &zeroed_ct);
let proof = CloseAccountProof::new(&source.secret, &zeroed_ct);
assert!(proof.verify(&zeroed_ct).is_ok());
// general case: valid encryption of zero
let balance = source.pk.encrypt(0_u64);
let balance = source.public.encrypt(0_u64);
let proof = CloseAccountProof::new(&source.sk, &balance);
let proof = CloseAccountProof::new(&source.secret, &balance);
assert!(proof.verify(&balance).is_ok());
}
}

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

@ -471,11 +471,11 @@ mod test {
fn test_transfer_correctness() {
// ElGamalKeypair keys for source, destination, and auditor accounts
let ElGamalKeypair {
pk: source_pk,
sk: source_sk,
public: source_pk,
secret: source_sk,
} = ElGamalKeypair::default();
let dest_pk = ElGamalKeypair::default().pk;
let auditor_pk = ElGamalKeypair::default().pk;
let dest_pk = ElGamalKeypair::default().public;
let auditor_pk = ElGamalKeypair::default().public;
// create source account spendable ciphertext
let spendable_balance: u64 = 77;
@ -502,14 +502,14 @@ mod test {
fn test_source_dest_ciphertext() {
// ElGamalKeypair keys for source, destination, and auditor accounts
let ElGamalKeypair {
pk: source_pk,
sk: source_sk,
public: source_pk,
secret: source_sk,
} = ElGamalKeypair::default();
let ElGamalKeypair {
pk: dest_pk,
sk: dest_sk,
public: dest_pk,
secret: dest_sk,
} = ElGamalKeypair::default();
let auditor_pk = ElGamalKeypair::default().pk;
let auditor_pk = ElGamalKeypair::default().public;
// create source account spendable ciphertext
let spendable_balance: u64 = 77;

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

@ -224,16 +224,18 @@ mod test {
// If current_ct and new_ct encrypt same values, then the proof verification should succeed
let balance: u64 = 77;
let current_ct = current.pk.encrypt(balance);
let new_ct = new.pk.encrypt(balance);
let current_ct = current.public.encrypt(balance);
let new_ct = new.public.encrypt(balance);
let proof = UpdateAccountPkProof::new(balance, &current.sk, &new.sk, &current_ct, &new_ct);
let proof =
UpdateAccountPkProof::new(balance, &current.secret, &new.secret, &current_ct, &new_ct);
assert!(proof.verify(&current_ct, &new_ct).is_ok());
// If current_ct and new_ct encrypt different values, then the proof verification should fail
let new_ct = new.pk.encrypt(55_u64);
let new_ct = new.public.encrypt(55_u64);
let proof = UpdateAccountPkProof::new(balance, &current.sk, &new.sk, &current_ct, &new_ct);
let proof =
UpdateAccountPkProof::new(balance, &current.secret, &new.secret, &current_ct, &new_ct);
assert!(proof.verify(&current_ct, &new_ct).is_err());
}
@ -246,23 +248,23 @@ mod test {
let balance: u64 = 0;
let zeroed_ct_as_current_ct: ElGamalCiphertext =
pod::ElGamalCiphertext::zeroed().try_into().unwrap();
let new_ct: ElGamalCiphertext = new.pk.encrypt(balance);
let new_ct: ElGamalCiphertext = new.public.encrypt(balance);
let proof = UpdateAccountPkProof::new(
balance,
&current.sk,
&new.sk,
&current.secret,
&new.secret,
&zeroed_ct_as_current_ct,
&new_ct,
);
assert!(proof.verify(&zeroed_ct_as_current_ct, &new_ct).is_ok());
let current_ct = current.pk.encrypt(balance);
let current_ct = current.public.encrypt(balance);
let zeroed_ct_as_new_ct: ElGamalCiphertext =
pod::ElGamalCiphertext::zeroed().try_into().unwrap();
let proof = UpdateAccountPkProof::new(
balance,
&current.sk,
&new.sk,
&current.secret,
&new.secret,
&current_ct,
&zeroed_ct_as_new_ct,
);
@ -274,8 +276,8 @@ mod test {
pod::ElGamalCiphertext::zeroed().try_into().unwrap();
let proof = UpdateAccountPkProof::new(
balance,
&current.sk,
&new.sk,
&current.secret,
&new.secret,
&zeroed_ct_as_current_ct,
&zeroed_ct_as_new_ct,
);
@ -290,7 +292,7 @@ mod test {
let new = ElGamalKeypair::default();
let balance = 0_u64;
let balance_ciphertext = new.pk.encrypt(balance);
let balance_ciphertext = new.public.encrypt(balance);
let zeroed_comm = Pedersen::with(0_u64, &PedersenOpening::default());
let handle = balance_ciphertext.decrypt_handle;
@ -300,12 +302,12 @@ mod test {
message_comm: zeroed_comm,
decrypt_handle: handle,
};
let new_ct: ElGamalCiphertext = new.pk.encrypt(balance);
let new_ct: ElGamalCiphertext = new.public.encrypt(balance);
let proof = UpdateAccountPkProof::new(
balance,
&current.sk,
&new.sk,
&current.secret,
&new.secret,
&zeroed_comm_ciphertext,
&new_ct,
);
@ -318,8 +320,8 @@ mod test {
let proof = UpdateAccountPkProof::new(
balance,
&current.sk,
&new.sk,
&current.secret,
&new.secret,
&zeroed_handle_ciphertext,
&new_ct,
);
@ -330,12 +332,12 @@ mod test {
message_comm: zeroed_comm,
decrypt_handle: handle,
};
let current_ct: ElGamalCiphertext = current.pk.encrypt(balance);
let current_ct: ElGamalCiphertext = current.public.encrypt(balance);
let proof = UpdateAccountPkProof::new(
balance,
&current.sk,
&new.sk,
&current.secret,
&new.secret,
&current_ct,
&zeroed_comm_ciphertext,
);
@ -348,8 +350,8 @@ mod test {
let proof = UpdateAccountPkProof::new(
balance,
&current.sk,
&new.sk,
&current.secret,
&new.secret,
&current_ct,
&zeroed_handle_ciphertext,
);

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

@ -179,17 +179,17 @@ mod test {
#[ignore]
fn test_withdraw_correctness() {
// generate and verify proof for the proper setting
let ElGamalKeypair { pk, sk } = ElGamalKeypair::default();
let ElGamalKeypair { public, secret } = ElGamalKeypair::default();
let current_balance: u64 = 77;
let current_balance_ct = pk.encrypt(current_balance);
let current_balance_ct = public.encrypt(current_balance);
let withdraw_amount: u64 = 55;
let data = WithdrawData::new(
withdraw_amount,
pk,
&sk,
public,
&secret,
current_balance,
current_balance_ct,
);
@ -197,7 +197,13 @@ mod test {
// generate and verify proof with wrong balance
let wrong_balance: u64 = 99;
let data = WithdrawData::new(withdraw_amount, pk, &sk, wrong_balance, current_balance_ct);
let data = WithdrawData::new(
withdraw_amount,
public,
&secret,
wrong_balance,
current_balance_ct,
);
assert!(data.verify().is_err());
// TODO: test for ciphertexts that encrypt numbers outside the 0, 2^64 range

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

@ -252,21 +252,21 @@ mod tests {
// spendable_ct should be an encryption of 0 for any public key when
// `PedersenOpen::default()` is used
let pk = ElGamalKeypair::default().pk;
let public = ElGamalKeypair::default().public;
let balance: u64 = 0;
assert_eq!(
spendable_ct,
pk.encrypt_with(balance, &PedersenOpening::default())
public.encrypt_with(balance, &PedersenOpening::default())
);
// homomorphism should work like any other ciphertext
let open = PedersenOpening::random(&mut OsRng);
let transfer_amount_ct = pk.encrypt_with(55_u64, &open);
let transfer_amount_ct = public.encrypt_with(55_u64, &open);
let transfer_amount_pod: pod::ElGamalCiphertext = transfer_amount_ct.into();
let sum = ops::add(&spendable_balance, &transfer_amount_pod).unwrap();
let expected: pod::ElGamalCiphertext = pk.encrypt_with(55_u64, &open).into();
let expected: pod::ElGamalCiphertext = public.encrypt_with(55_u64, &open).into();
assert_eq!(expected, sum);
}
@ -276,9 +276,10 @@ mod tests {
let added_ct = ops::add_to(&spendable_balance, 55).unwrap();
let pk = ElGamalKeypair::default().pk;
let expected: pod::ElGamalCiphertext =
pk.encrypt_with(55_u64, &PedersenOpening::default()).into();
let public = ElGamalKeypair::default().public;
let expected: pod::ElGamalCiphertext = public
.encrypt_with(55_u64, &PedersenOpening::default())
.into();
assert_eq!(expected, added_ct);
}
@ -286,13 +287,13 @@ mod tests {
#[test]
fn test_subtract_from() {
let amount = 77_u64;
let pk = ElGamalKeypair::default().pk;
let public = ElGamalKeypair::default().public;
let open = PedersenOpening::random(&mut OsRng);
let encrypted_amount: pod::ElGamalCiphertext = pk.encrypt_with(amount, &open).into();
let encrypted_amount: pod::ElGamalCiphertext = public.encrypt_with(amount, &open).into();
let subtracted_ct = ops::subtract_from(&encrypted_amount, 55).unwrap();
let expected: pod::ElGamalCiphertext = pk.encrypt_with(22_u64, &open).into();
let expected: pod::ElGamalCiphertext = public.encrypt_with(22_u64, &open).into();
assert_eq!(expected, subtracted_ct);
}
@ -312,9 +313,9 @@ mod tests {
let (amount_lo, amount_hi) = split_u64_into_u32(transfer_amount);
// generate public keys
let source_pk = ElGamalKeypair::default().pk;
let dest_pk = ElGamalKeypair::default().pk;
let auditor_pk = ElGamalKeypair::default().pk;
let source_pk = ElGamalKeypair::default().public;
let dest_pk = ElGamalKeypair::default().public;
let auditor_pk = ElGamalKeypair::default().public;
// commitments associated with TransferRangeProof
let (comm_lo, open_lo) = Pedersen::new(amount_lo);