Integrate new accumulator in proof_system and remove unneccessary macro

Signed-off-by: lovesh <lovesh.bond@gmail.com>

Author: lovesh

bbs_plus/src/setup.rs

@@ -54,9 +54,9 @@ use ark_ff::{
     PrimeField,
 };
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
-use ark_std::{cfg_iter, fmt::Debug, io::Write, rand::RngCore, vec::Vec, UniformRand};
+use ark_std::{cfg_iter, fmt::Debug, rand::RngCore, vec::Vec, UniformRand};
 use digest::{Digest, DynDigest};
-use schnorr_pok::{error::SchnorrError, impl_proof_of_knowledge_of_discrete_log};
+
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
 use core::iter::once;
@@ -434,8 +434,6 @@ impl_public_key!(PublicKeyG2, G2Affine, SignatureParamsG1);
 impl_public_key!(PublicKeyG1, G1Affine, SignatureParamsG2);
 impl_keypair!(KeypairG2, G2Projective, PublicKeyG2, SignatureParamsG1);
 impl_keypair!(KeypairG1, G1Projective, PublicKeyG1, SignatureParamsG2);
-impl_proof_of_knowledge_of_discrete_log!(PoKSecretKeyInPublicKeyG2, PoKSecretKeyInPublicKeyG2Proof);
-impl_proof_of_knowledge_of_discrete_log!(PoKSecretKeyInPublicKeyG1, PoKSecretKeyInPublicKeyG1Proof);
 
 #[serde_as]
 #[derive(
@@ -603,7 +601,10 @@ mod tests {
     use ark_bls12_381::Bls12_381;
     use ark_std::rand::{rngs::StdRng, SeedableRng};
     use blake2::Blake2b512;
-    use schnorr_pok::compute_random_oracle_challenge;
+    use schnorr_pok::{
+        compute_random_oracle_challenge,
+        discrete_log::{PokDiscreteLog, PokDiscreteLogProtocol},
+    };
 
     type Fr = <Bls12_381 as Pairing>::ScalarField;
 
@@ -731,7 +732,7 @@ mod tests {
     #[test]
     fn proof_of_knowledge_of_public_key() {
         macro_rules! check {
-            ($group_affine:ident, $protocol_name:ident, $proof_name:ident, $public_key:ident, $params:ident) => {
+            ($group_affine:ident, $public_key:ident, $params:ident) => {
                 let mut rng = StdRng::seed_from_u64(0u64);
                 let params = $params::<Bls12_381>::new::<Blake2b512>("test".as_bytes(), 5);
                 let seed = [0, 1, 2, 10, 11];
@@ -742,17 +743,18 @@ mod tests {
                 let witness = sk.0.clone();
                 let blinding = Fr::rand(&mut rng);
 
-                let protocol = $protocol_name::<<Bls12_381 as Pairing>::$group_affine>::init(
-                    witness, blinding, base,
-                );
+                let protocol =
+                    PokDiscreteLogProtocol::<<Bls12_381 as Pairing>::$group_affine>::init(
+                        witness, blinding, base,
+                    );
 
                 let mut chal_contrib_prover = vec![];
                 protocol
                     .challenge_contribution(base, &pk.0, &mut chal_contrib_prover)
                     .unwrap();
 
                 test_serialization!(
-                    $protocol_name<<Bls12_381 as Pairing>::$group_affine>,
+                    PokDiscreteLogProtocol<<Bls12_381 as Pairing>::$group_affine>,
                     protocol
                 );
 
@@ -771,23 +773,11 @@ mod tests {
                 assert_eq!(chal_contrib_prover, chal_contrib_verifier);
                 assert_eq!(challenge_prover, challenge_verifier);
 
-                test_serialization!($proof_name<<Bls12_381 as Pairing>::$group_affine>, proof);
+                test_serialization!(PokDiscreteLog<<Bls12_381 as Pairing>::$group_affine>, proof);
             };
         }
 
-        check!(
-            G2Affine,
-            PoKSecretKeyInPublicKeyG2,
-            PoKSecretKeyInPublicKeyG2Proof,
-            PublicKeyG2,
-            SignatureParamsG1
-        );
-        check!(
-            G1Affine,
-            PoKSecretKeyInPublicKeyG1,
-            PoKSecretKeyInPublicKeyG1Proof,
-            PublicKeyG1,
-            SignatureParamsG2
-        );
+        check!(G2Affine, PublicKeyG2, SignatureParamsG1);
+        check!(G1Affine, PublicKeyG1, SignatureParamsG2);
     }
 }

bbs_plus/src/threshold/base_ot_phase.rs

@@ -14,11 +14,11 @@ use digest::Digest;
 use oblivious_transfer_protocols::{
     base_ot::simplest_ot::{
         Challenges, HashedKey, OneOfTwoROTSenderKeys, ROTReceiverKeys, ROTSenderSetup,
-        ReceiverPubKeys, Responses, SecretKnowledgeProof, SenderPubKey, VSROTChallenger,
-        VSROTResponder,
+        ReceiverPubKeys, Responses, SenderPubKey, VSROTChallenger, VSROTResponder,
     },
     Bit, ParticipantId,
 };
+use schnorr_pok::discrete_log::PokDiscreteLog;
 use serde::{Deserialize, Serialize};
 
 /// The participant runs an independent base OT with each participant and stores each OT's state. If
@@ -54,7 +54,7 @@ pub struct BaseOTPhaseOutput {
     Clone, Debug, PartialEq, CanonicalSerialize, CanonicalDeserialize, Serialize, Deserialize,
 )]
 #[serde(bound = "")]
-pub struct SenderPubKeyAndProof<G: AffineRepr>(SenderPubKey<G>, SecretKnowledgeProof<G>);
+pub struct SenderPubKeyAndProof<G: AffineRepr>(SenderPubKey<G>, PokDiscreteLog<G>);
 
 impl<G: AffineRepr> BaseOTPhase<G> {
     pub fn init<R: RngCore, D: Digest>(

benches/benches/schnorr_protocol.rs

@@ -1,47 +1,40 @@
 use ark_bls12_381::Bls12_381;
 use ark_ec::{pairing::Pairing, AffineRepr, CurveGroup, VariableBaseMSM};
 use ark_ff::PrimeField;
-use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::{
-    io::Write,
     rand::{rngs::StdRng, SeedableRng},
     UniformRand,
 };
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
-use dock_crypto_utils::serde_utils::*;
-use schnorr_pok::{
-    error::SchnorrError, impl_proof_of_knowledge_of_discrete_log, SchnorrCommitment,
-};
-use serde::{Deserialize, Serialize};
-use serde_with::serde_as;
-use zeroize::{Zeroize, ZeroizeOnDrop};
+use schnorr_pok::{discrete_log::PokDiscreteLogProtocol, SchnorrCommitment};
 
 type Fr = <Bls12_381 as Pairing>::ScalarField;
 
 macro_rules! bench_single {
     ($group_affine:ident, $group_projective:ident, $c: ident) => {
         let mut rng = StdRng::seed_from_u64(0u64);
-        impl_proof_of_knowledge_of_discrete_log!(Protocol, Proof);
         let base = <Bls12_381 as Pairing>::$group_projective::rand(&mut rng).into_affine();
         let witness = Fr::rand(&mut rng);
 
         $c.bench_function("Generate proof", |b| {
             b.iter(|| {
                 let blinding = Fr::rand(&mut rng);
-                let protocol = Protocol::<<Bls12_381 as Pairing>::$group_affine>::init(
-                    black_box(witness),
-                    blinding,
-                    black_box(&base),
-                );
+                let protocol =
+                    PokDiscreteLogProtocol::<<Bls12_381 as Pairing>::$group_affine>::init(
+                        black_box(witness),
+                        blinding,
+                        black_box(&base),
+                    );
                 let challenge = Fr::rand(&mut rng);
                 protocol.gen_proof(&challenge);
             })
         });
 
         let y = base.mul_bigint(witness.into_bigint()).into_affine();
         let blinding = Fr::rand(&mut rng);
-        let protocol =
-            Protocol::<<Bls12_381 as Pairing>::$group_affine>::init(witness, blinding, &base);
+        let protocol = PokDiscreteLogProtocol::<<Bls12_381 as Pairing>::$group_affine>::init(
+            witness, blinding, &base,
+        );
         // Not benchmarking challenge contribution as that is just serialization
         let challenge = Fr::rand(&mut rng);
         let proof = protocol.gen_proof(&challenge);

delegatable_credentials/src/msbm/issuance.rs

@@ -7,12 +7,13 @@ use crate::{
             PreparedRootIssuerPublicKey, RootIssuerSecretKey, UpdateKey, UserPublicKey,
             UserSecretKey,
         },
-        sps_eq_uc_sig::{RandCommitmentProof, Signature},
+        sps_eq_uc_sig::Signature,
     },
     set_commitment::{SetCommitment, SetCommitmentOpening, SetCommitmentSRS},
 };
 use ark_ec::pairing::Pairing;
 use ark_std::{rand::RngCore, vec::Vec, UniformRand};
+use schnorr_pok::discrete_log::PokDiscreteLog;
 
 /// Credential issued by a root or delegated issuer when it knows the randomness for set commitments
 /// of attributes
@@ -454,7 +455,7 @@ impl<E: Pairing> CredentialWithoutOpenings<E> {
         rng: &mut R,
         trapdoor: &E::ScalarField,
         commitment_to_randomness: Vec<E::G1Affine>,
-        commitment_to_randomness_proof: Vec<RandCommitmentProof<E::G1Affine>>,
+        commitment_to_randomness_proof: Vec<PokDiscreteLog<E::G1Affine>>,
         challenge: &E::ScalarField,
         attributes: Vec<Vec<E::ScalarField>>,
         user_public_key: &UserPublicKey<E>,
@@ -502,16 +503,13 @@ impl<E: Pairing> CredentialWithoutOpenings<E> {
 #[cfg(test)]
 pub mod tests {
     use super::*;
-    use crate::msbm::{
-        keys::{RootIssuerPublicKey, UserSecretKey},
-        sps_eq_uc_sig::RandCommitmentProtocol,
-    };
+    use crate::msbm::keys::{RootIssuerPublicKey, UserSecretKey};
     use ark_bls12_381::Bls12_381;
     use ark_ec::{AffineRepr, CurveGroup};
     use ark_ff::PrimeField;
     use ark_std::rand::{rngs::StdRng, SeedableRng};
     use blake2::Blake2b512;
-    use schnorr_pok::compute_random_oracle_challenge;
+    use schnorr_pok::{compute_random_oracle_challenge, discrete_log::PokDiscreteLogProtocol};
 
     type Fr = <Bls12_381 as Pairing>::ScalarField;
 
@@ -608,7 +606,7 @@ pub mod tests {
 
             for i in 0..l {
                 commit_to_rands.push(P1.mul_bigint(randoms[i].into_bigint()).into_affine());
-                protocols.push(RandCommitmentProtocol::init(randoms[i], blindings[i], P1));
+                protocols.push(PokDiscreteLogProtocol::init(randoms[i], blindings[i], P1));
                 protocols[i]
                     .challenge_contribution(P1, &commit_to_rands[i], &mut challenge_bytes)
                     .unwrap();

delegatable_credentials/src/msbm/show.rs

@@ -1,16 +1,11 @@
 //! Credential show and verification from Fig. 3 of the paper
 
-use ark_ec::{pairing::Pairing, AffineRepr, CurveGroup};
-use ark_ff::PrimeField;
-use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use ark_ec::pairing::Pairing;
+
 use ark_std::{collections::BTreeSet, io::Write, rand::RngCore, vec::Vec, UniformRand};
 use digest::Digest;
-use serde::{Deserialize, Serialize};
-use serde_with::serde_as;
-use zeroize::{Zeroize, ZeroizeOnDrop};
 
-use dock_crypto_utils::serde_utils::ArkObjectBytes;
-use schnorr_pok::{error::SchnorrError, impl_proof_of_knowledge_of_discrete_log};
+use schnorr_pok::discrete_log::{PokDiscreteLog, PokDiscreteLogProtocol};
 
 use crate::{
     error::DelegationError,
@@ -24,8 +19,6 @@ use crate::{
     },
 };
 
-impl_proof_of_knowledge_of_discrete_log!(NymOwnershipProtocol, NymOwnership);
-
 #[derive(Clone, Debug)]
 pub struct CredentialShow<E: Pairing> {
     /// Commitment to each attribute set
@@ -36,7 +29,7 @@ pub struct CredentialShow<E: Pairing> {
     pub disclosed_attributes_witness: AggregateSubsetWitness<E>,
     pub pseudonym: UserPublicKey<E>,
     /// Schnorr proof of knowledge of secret key corresponding to the pseudonym.
-    pub schnorr: NymOwnership<E::G1Affine>,
+    pub schnorr: PokDiscreteLog<E::G1Affine>,
 }
 
 /// Protocol to create `CredentialShow`
@@ -47,7 +40,7 @@ pub struct CredentialShowProtocol<E: Pairing> {
     pub disclosed_attributes_witness: AggregateSubsetWitness<E>,
     pub pseudonym: UserPublicKey<E>,
     pub pseudonym_secret: UserSecretKey<E>,
-    pub schnorr: NymOwnershipProtocol<E::G1Affine>,
+    pub schnorr: PokDiscreteLogProtocol<E::G1Affine>,
 }
 
 impl<E: Pairing> CredentialShowProtocol<E> {
@@ -94,7 +87,7 @@ impl<E: Pairing> CredentialShowProtocol<E> {
         )?;
 
         let blinding = E::ScalarField::rand(rng);
-        let schnorr = NymOwnershipProtocol::init(new_usk.0, blinding, set_comm_srs.get_P1());
+        let schnorr = PokDiscreteLogProtocol::init(new_usk.0, blinding, set_comm_srs.get_P1());
         Ok(Self {
             commitments: rand_cred.commitments.clone(),
             signature: rand_cred.signature,

delegatable_credentials/src/msbm/sps_eq_uc_sig.rs

@@ -8,7 +8,6 @@ use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::{
     cfg_into_iter, cfg_iter,
     collections::BTreeSet,
-    io::Write,
     ops::{Add, Mul, Neg},
     rand::RngCore,
     vec::Vec,
@@ -17,10 +16,11 @@ use ark_std::{
 use digest::Digest;
 
 use dock_crypto_utils::serde_utils::ArkObjectBytes;
-use schnorr_pok::{error::SchnorrError, impl_proof_of_knowledge_of_discrete_log};
+
+use schnorr_pok::discrete_log::PokDiscreteLog;
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
-use zeroize::{Zeroize, ZeroizeOnDrop};
+use zeroize::Zeroize;
 
 use crate::{
     mercurial_sig::Signature as MercurialSig,
@@ -36,8 +36,6 @@ use crate::{
 #[cfg(feature = "parallel")]
 use rayon::prelude::*;
 
-impl_proof_of_knowledge_of_discrete_log!(RandCommitmentProtocol, RandCommitmentProof);
-
 #[serde_as]
 #[derive(
     Clone,
@@ -130,7 +128,7 @@ impl<E: Pairing> Signature<E> {
         rng: &mut R,
         trapdoor_set_comm_srs: &E::ScalarField,
         commitment_to_randomness: Vec<E::G1Affine>,
-        commitment_to_randomness_proof: Vec<RandCommitmentProof<E::G1Affine>>,
+        commitment_to_randomness_proof: Vec<PokDiscreteLog<E::G1Affine>>,
         challenge: &E::ScalarField,
         messages: Vec<Vec<E::ScalarField>>,
         user_public_key: &UserPublicKey<E>,