Test rotation and hd multipath derivation

Cargo.toml

@@ -13,10 +13,11 @@ sha3 = "0.10"
 sha2 = "0.10"
 hmac = "0.12"
 rayon = "1"
-serde = "1"
-serde_derive = "1.0"
+serde = { version = "1.0.147", features = ["derive"] }
+#serde_derive = "1.0"
 itertools = "0.10"
 bit-vec = "0.6"
+typetag = "0.2.3"
 
 [dependencies.rust-gmp]
 version = "0.5.0"

src/bulletproofs/proofs/inner_product.rs

@@ -22,6 +22,7 @@ use crate::curv::cryptographic_primitives::hashing::traits::*;
 use crate::curv::elliptic::curves::traits::*;
 use crate::curv::BigInt;
 use crate::curv::{FE, GE};
+use serde::{Serialize,Deserialize};
 
 use crate::bulletproofs::Errors::{self, InnerProductError};
 

src/bulletproofs/proofs/range_proof.rs

@@ -26,6 +26,8 @@ use crate::curv::BigInt;
 use crate::curv::{FE, GE};
 use itertools::iterate;
 use std::ops::{Shl, Shr};
+use serde::{Serialize,Deserialize};
+
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct RangeProof {

src/centipede/juggling/proof_system.rs

@@ -24,6 +24,7 @@ use crate::curv::arithmetic::traits::Converter;
 use crate::bulletproofs::proofs::range_proof::{RangeProof,generate_random_point};
 use super::segmentation::Msegmentation;
 use crate::centipede::Errors::{self, ErrorProving};
+use serde::{Serialize,Deserialize};
 
 #[derive(Serialize, Deserialize)]
 pub struct Helgamal {

src/curv/arithmetic/big_gmp.rs

@@ -21,7 +21,6 @@ use super::traits::{
 };
 use gmp::mpz::Mpz;
 use rand::RngCore;
-
 use std::borrow::Borrow;
 
 pub type BigInt = Mpz;

src/curv/cryptographic_primitives/proofs/sigma_correct_homomorphic_elgamal_enc.rs

@@ -13,6 +13,7 @@ use crate::curv::elliptic::curves::traits::*;
 use crate::curv::FE;
 use crate::curv::GE;
 use zeroize::Zeroize;
+use serde::{Serialize,Deserialize};
 
 /// This is a proof of knowledge that a pair of group elements {D, E}
 /// form a valid homomorphic ElGamal encryption (”in the exponent”) using public key Y .

src/curv/cryptographic_primitives/proofs/sigma_correct_homomorphic_elgamal_encryption_of_dlog.rs

@@ -13,6 +13,7 @@ use crate::curv::elliptic::curves::traits::*;
 use crate::curv::FE;
 use crate::curv::GE;
 use zeroize::Zeroize;
+use serde::{Serialize,Deserialize};
 
 /// This is a proof of knowledge that a pair of group elements {D, E}
 /// form a valid homomorphic ElGamal encryption (”in the exponent”) using public key Y .

src/curv/cryptographic_primitives/proofs/sigma_dlog.rs

@@ -5,6 +5,8 @@
     License MIT: https://github.com/KZen-networks/curv/blob/master/LICENSE
 */
 
+use std::any::Any;
+use std::fmt::{Display, Formatter};
 use super::ProofError;
 use crate::curv::FE;
 use crate::curv::GE;
@@ -14,6 +16,8 @@ use crate::curv::elliptic::curves::traits::*;
 use crate::curv::cryptographic_primitives::hashing::hash_sha256::HSha256;
 use crate::curv::cryptographic_primitives::hashing::traits::Hash;
 use zeroize::Zeroize;
+use crate::party_one::{Value};
+use serde::{Serialize,Deserialize};
 
 /// This is implementation of Schnorr's identification protocol for elliptic curve groups or a
 /// sigma protocol for Proof of knowledge of the discrete log of an Elliptic-curve point:
@@ -31,6 +35,19 @@ pub struct DLogProof {
     pub pk_t_rand_commitment: GE,
     pub challenge_response: FE,
 }
+#[typetag::serde]
+impl Value for DLogProof {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+impl Display for DLogProof {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 
 pub trait ProveDLog {
     fn prove(sk: &FE) -> DLogProof;

src/curv/cryptographic_primitives/proofs/sigma_ec_ddh.rs

@@ -11,6 +11,7 @@ use crate::curv::cryptographic_primitives::hashing::traits::Hash;
 use crate::curv::elliptic::curves::traits::*;
 use crate::curv::{FE, GE};
 use zeroize::Zeroize;
+use serde::{Serialize,Deserialize};
 
 /// This protocol is the elliptic curve form of the protocol from :
 ///  D. Chaum, T. P. Pedersen. Transferred cash grows in size. In Advances in Cryptology, EUROCRYPT , volume 658 of Lecture Notes in Computer Science, pages 390 - 407, 1993.

src/curv/cryptographic_primitives/proofs/sigma_valid_pedersen.rs

@@ -13,6 +13,7 @@ use crate::curv::cryptographic_primitives::hashing::traits::Hash;
 use crate::curv::elliptic::curves::traits::*;
 use crate::curv::{FE, GE};
 use zeroize::Zeroize;
+use serde::{Serialize,Deserialize};
 
 /// protocol for proving that Pedersen commitment c was constructed correctly which is the same as
 /// proof of knowledge of (m,r) such that c = mG + rH.

src/curv/cryptographic_primitives/proofs/sigma_valid_pedersen_blind.rs

@@ -14,6 +14,7 @@ use crate::curv::elliptic::curves::traits::*;
 
 use crate::curv::{FE, GE};
 use zeroize::Zeroize;
+use serde::{Serialize,Deserialize};
 
 /// protocol for proving that Pedersen commitment c was constructed correctly which is the same as
 /// proof of knowledge of (r) such that c = mG + rH.

src/curv/cryptographic_primitives/twoparty/coin_flip_optimal_rounds.rs

@@ -11,6 +11,7 @@ use crate::curv::cryptographic_primitives::proofs::sigma_valid_pedersen_blind::P
 use crate::curv::cryptographic_primitives::proofs::sigma_valid_pedersen_blind::ProvePederesenBlind;
 use crate::curv::elliptic::curves::traits::*;
 use crate::curv::{FE, GE};
+use serde::{Serialize,Deserialize};
 
 /// based on How To Simulate It – A Tutorial on the Simulation
 /// Proof Technique. protocol 7.3: Multiple coin tossing. which provide simulatble constant round

src/curv/cryptographic_primitives/twoparty/dh_key_exchange.rs

@@ -12,6 +12,7 @@
 use crate::curv::elliptic::curves::traits::*;
 use crate::curv::FE;
 use crate::curv::GE;
+use serde::{Serialize,Deserialize};
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct EcKeyPair {

src/curv/cryptographic_primitives/twoparty/dh_key_exchange_variant_with_pok_comm.rs

@@ -5,6 +5,8 @@
     License MIT: <https://github.com/KZen-networks/curv/blob/master/LICENSE>
 */
 
+use std::any::Any;
+use std::fmt::{Display, Formatter};
 /// in ECDH Alice chooses at random a secret "a" and sends Bob public key A = aG
 /// Bob chooses at random a secret "b" and sends to Alice B = bG.
 /// Both parties can compute a joint secret: C =aB = bA = abG which cannot be computed by
@@ -22,22 +24,66 @@ use crate::curv::elliptic::curves::traits::*;
 use crate::curv::BigInt;
 use crate::curv::FE;
 use crate::curv::GE;
+use serde::{Serialize,Deserialize};
+use crate::party_one::Value;
+use crate::party_two::PDLFirstMessage;
 
 const SECURITY_BITS: usize = 256;
 
+
+#[typetag::serde]
+impl Value for EcKeyPairDHPoK {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+impl Display for EcKeyPairDHPoK {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct EcKeyPair {
+pub struct EcKeyPairDHPoK {
     pub public_share: GE,
     secret_share: FE,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct CommWitness {
+pub struct CommWitnessDHPoK {
     pub pk_commitment_blind_factor: BigInt,
     pub zk_pok_blind_factor: BigInt,
     pub public_share: GE,
     pub d_log_proof: DLogProof,
 }
+
+#[typetag::serde]
+impl Value for CommWitnessDHPoK {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+impl Display for CommWitnessDHPoK {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[typetag::serde]
+impl Value for Party1FirstMessage {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+impl Display for Party1FirstMessage {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Party1FirstMessage {
     pub pk_commitment: BigInt,
@@ -51,14 +97,14 @@ pub struct Party2FirstMessage {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Party1SecondMessage {
-    pub comm_witness: CommWitness,
+    pub comm_witness: CommWitnessDHPoK,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Party2SecondMessage {}
 
 impl Party1FirstMessage {
-    pub fn create_commitments() -> (Party1FirstMessage, CommWitness, EcKeyPair) {
+    pub fn create_commitments() -> (Party1FirstMessage, CommWitnessDHPoK, EcKeyPairDHPoK) {
         let base: GE = ECPoint::generator();
 
         let secret_share: FE = ECScalar::new_random();
@@ -80,7 +126,7 @@ impl Party1FirstMessage {
                 .bytes_compressed_to_big_int(),
             &zk_pok_blind_factor,
         );
-        let ec_key_pair = EcKeyPair {
+        let ec_key_pair = EcKeyPairDHPoK {
             public_share,
             secret_share,
         };
@@ -89,7 +135,7 @@ impl Party1FirstMessage {
                 pk_commitment,
                 zk_pok_commitment,
             },
-            CommWitness {
+            CommWitnessDHPoK {
                 pk_commitment_blind_factor,
                 zk_pok_blind_factor,
                 public_share: ec_key_pair.public_share,
@@ -101,7 +147,7 @@ impl Party1FirstMessage {
 
     pub fn create_commitments_with_fixed_secret_share(
         secret_share: FE,
-    ) -> (Party1FirstMessage, CommWitness, EcKeyPair) {
+    ) -> (Party1FirstMessage, CommWitnessDHPoK, EcKeyPairDHPoK) {
         let base: GE = ECPoint::generator();
         let public_share = base * secret_share;
 
@@ -121,7 +167,7 @@ impl Party1FirstMessage {
             &zk_pok_blind_factor,
         );
 
-        let ec_key_pair = EcKeyPair {
+        let ec_key_pair = EcKeyPairDHPoK {
             public_share,
             secret_share,
         };
@@ -130,7 +176,7 @@ impl Party1FirstMessage {
                 pk_commitment,
                 zk_pok_commitment,
             },
-            CommWitness {
+            CommWitnessDHPoK {
                 pk_commitment_blind_factor,
                 zk_pok_blind_factor,
                 public_share: ec_key_pair.public_share,
@@ -143,20 +189,20 @@ impl Party1FirstMessage {
 
 impl Party1SecondMessage {
     pub fn verify_and_decommit(
-        comm_witness: CommWitness,
+        comm_witness: CommWitnessDHPoK,
         proof: &DLogProof,
     ) -> Result<Party1SecondMessage, ProofError> {
         DLogProof::verify(proof)?;
         Ok(Party1SecondMessage { comm_witness })
     }
 }
 impl Party2FirstMessage {
-    pub fn create() -> (Party2FirstMessage, EcKeyPair) {
+    pub fn create() -> (Party2FirstMessage, EcKeyPairDHPoK) {
         let base: GE = ECPoint::generator();
         let secret_share: FE = ECScalar::new_random();
         let public_share = base * secret_share;
         let d_log_proof = DLogProof::prove(&secret_share);
-        let ec_key_pair = EcKeyPair {
+        let ec_key_pair = EcKeyPairDHPoK {
             public_share,
             secret_share,
         };
@@ -169,11 +215,11 @@ impl Party2FirstMessage {
         )
     }
 
-    pub fn create_with_fixed_secret_share(secret_share: FE) -> (Party2FirstMessage, EcKeyPair) {
+    pub fn create_with_fixed_secret_share(secret_share: FE) -> (Party2FirstMessage, EcKeyPairDHPoK) {
         let base: GE = ECPoint::generator();
         let public_share = base * secret_share;
         let d_log_proof = DLogProof::prove(&secret_share);
-        let ec_key_pair = EcKeyPair {
+        let ec_key_pair = EcKeyPairDHPoK {
             public_share,
             secret_share,
         };
@@ -228,7 +274,7 @@ impl Party2SecondMessage {
         Ok(Party2SecondMessage {})
     }
 }
-pub fn compute_pubkey(local_share: &EcKeyPair, other_share_public_share: &GE) -> GE {
+pub fn compute_pubkey(local_share: &EcKeyPairDHPoK, other_share_public_share: &GE) -> GE {
     other_share_public_share * &local_share.secret_share
 }