refactor(naming): rename SchnorrProof to SchnorrProtocol

nougzarm · nougzarm · commit 6d486438fdfd · 2025-05-17T17:40:15.000+02:00
- refactor: change structure name from 'SchnorrProof' to 'SchnorrProtocol' to better reflect its actual function and purpose
diff --git a/src/proof_builder.rs b/src/proof_builder.rs
@@ -3,7 +3,7 @@
 //! This module defines the [`ProofBuilder`] struct, a high-level utility that simplifies
 //! the construction and interaction with zero-knowledge proofs based on Sigma protocols.
 //!
-//! It abstracts over the underlying Schnorr proof, Fiat-Shamir transformation,
+//! It abstracts over the underlying Schnorr protocol, Fiat-Shamir transformation,
 //! and serialization concerns, making it easier to create proofs from linear
 //! relations over cryptographic groups.
 //!
@@ -18,12 +18,12 @@ use rand::{CryptoRng, RngCore};
 
 use crate::{
     codec::ShakeCodec, serialisation::GroupSerialisation, GroupMorphismPreimage, NISigmaProtocol,
-    PointVar, ProofError, ScalarVar, SchnorrProof,
+    PointVar, ProofError, ScalarVar, SchnorrProtocol,
 };
 
 /// A builder that helps construct Sigma proofs for linear group relations.
 ///
-/// This struct wraps a [`SchnorrProof`] over a [`GroupMorphismPreimage`] and applies
+/// This struct wraps a [`SchnorrProtocol`] over a [`GroupMorphismPreimage`] and applies
 /// the Fiat-Shamir transform via [`NISigmaProtocol`]. It provides a user-friendly API
 /// for allocating variables, defining statements, and generating proofs.
 ///
@@ -34,7 +34,7 @@ where
     G: Group + GroupSerialisation,
 {
     /// The underlying Sigma protocol instance with Fiat-Shamir transformation applied.
-    pub protocol: NISigmaProtocol<SchnorrProof<G>, ShakeCodec<G>, G>,
+    pub protocol: NISigmaProtocol<SchnorrProtocol<G>, ShakeCodec<G>, G>,
 }
 
 impl<G> ProofBuilder<G>
@@ -44,9 +44,9 @@ where
 {
     /// Creates a new proof builder with a Schnorr protocol instance using the given domain separator.
     pub fn new(domain_sep: &[u8]) -> Self {
-        let schnorr_proof = SchnorrProof(GroupMorphismPreimage::<G>::new());
+        let schnorr_proof = SchnorrProtocol(GroupMorphismPreimage::<G>::new());
         let protocol =
-            NISigmaProtocol::<SchnorrProof<G>, ShakeCodec<G>, G>::new(domain_sep, schnorr_proof);
+            NISigmaProtocol::<SchnorrProtocol<G>, ShakeCodec<G>, G>::new(domain_sep, schnorr_proof);
         Self { protocol }
     }
 
diff --git a/src/schnorr_proof.rs b/src/schnorr_proof.rs
@@ -1,6 +1,6 @@
 //! Implementation of the generic Schnorr Sigma Protocol over a group `G`.
 //!
-//! This module defines the [`SchnorrProof`] structure, which implements
+//! This module defines the [`SchnorrProtocol`] structure, which implements
 //! a Sigma protocol proving different types of discrete logarithm relations (eg. Schnorr, Pedersen's commitments)
 //! through a group morphism abstraction (see Maurer09).
 
@@ -16,11 +16,11 @@ use rand::{CryptoRng, Rng};
 /// A Schnorr protocol proving knowledge some discrete logarithm relation.
 ///
 /// The specific proof instance is defined by a [`GroupMorphismPreimage`] over a group `G`.
-pub struct SchnorrProof<G: Group + GroupEncoding + GroupSerialisation>(
+pub struct SchnorrProtocol<G: Group + GroupEncoding + GroupSerialisation>(
     pub GroupMorphismPreimage<G>,
 );
 
-impl<G> SigmaProtocol for SchnorrProof<G>
+impl<G> SigmaProtocol for SchnorrProtocol<G>
 where
     G: Group + GroupEncoding + GroupSerialisation,
 {
@@ -147,7 +147,7 @@ where
     }
 }
 
-impl<G> CompactProtocol for SchnorrProof<G>
+impl<G> CompactProtocol for SchnorrProtocol<G>
 where
     G: Group + GroupEncoding + GroupSerialisation,
 {
diff --git a/tests/morphism_test.rs b/tests/morphism_test.rs
@@ -6,7 +6,7 @@ use rand::{
 };
 
 use sigma_rs::{
-    codec::ShakeCodec, group_morphism::msm_pr, GroupMorphismPreimage, NISigmaProtocol, SchnorrProof,
+    codec::ShakeCodec, group_morphism::msm_pr, GroupMorphismPreimage, NISigmaProtocol, SchnorrProtocol,
 };
 
 type G = G1Projective;
@@ -222,18 +222,18 @@ fn test_bbs_blind_commitment_computation() {
 }
 
 /// This part tests the implementation of the SigmaProtocol trait for the
-/// SchnorrProof structure as well as the Fiat-Shamir NISigmaProtocol transform
+/// SchnorrProtocol structure as well as the Fiat-Shamir NISigmaProtocol transform
 #[allow(non_snake_case)]
 #[test]
 fn NI_discrete_logarithm() {
     let mut rng = OsRng;
     let (morphismp, witness) = discrete_logarithm::<G>(&mut rng);
 
     // The SigmaProtocol induced by morphismp
-    let protocol = SchnorrProof(morphismp);
+    let protocol = SchnorrProtocol(morphismp);
     // Fiat-Shamir wrapper
     let domain_sep = b"test-fiat-shamir-schnorr";
-    let mut nizk = NISigmaProtocol::<SchnorrProof<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
+    let mut nizk = NISigmaProtocol::<SchnorrProtocol<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
 
     // Batchable and compact proofs
     let proof_batchable_bytes = nizk.prove_batchable(&witness, &mut rng);
@@ -258,10 +258,10 @@ fn NI_dleq() {
     let (morphismp, witness) = dleq::<G>(&mut rng);
 
     // The SigmaProtocol induced by morphismp
-    let protocol = SchnorrProof(morphismp);
+    let protocol = SchnorrProtocol(morphismp);
     // Fiat-Shamir wrapper
     let domain_sep = b"test-fiat-shamir-DLEQ";
-    let mut nizk = NISigmaProtocol::<SchnorrProof<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
+    let mut nizk = NISigmaProtocol::<SchnorrProtocol<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
 
     // Batchable and compact proofs
     let proof_batchable_bytes = nizk.prove_batchable(&witness, &mut rng);
@@ -286,10 +286,10 @@ fn NI_pedersen_commitment() {
     let (morphismp, witness) = pedersen_commitment::<G>(&mut rng);
 
     // The SigmaProtocol induced by morphismp
-    let protocol = SchnorrProof(morphismp);
+    let protocol = SchnorrProtocol(morphismp);
     // Fiat-Shamir wrapper
     let domain_sep = b"test-fiat-shamir-pedersen-commitment";
-    let mut nizk = NISigmaProtocol::<SchnorrProof<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
+    let mut nizk = NISigmaProtocol::<SchnorrProtocol<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
 
     // Batchable and compact proofs
     let proof_batchable_bytes = nizk.prove_batchable(&witness, &mut rng);
@@ -314,10 +314,10 @@ fn NI_pedersen_commitment_dleq() {
     let (morphismp, witness) = pedersen_commitment_dleq::<G>(&mut rng);
 
     // The SigmaProtocol induced by morphismp
-    let protocol = SchnorrProof(morphismp);
+    let protocol = SchnorrProtocol(morphismp);
     // Fiat-Shamir wrapper
     let domain_sep = b"test-fiat-shamir-pedersen-commitment-DLEQ";
-    let mut nizk = NISigmaProtocol::<SchnorrProof<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
+    let mut nizk = NISigmaProtocol::<SchnorrProtocol<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
 
     // Batchable and compact proofs
     let proof_batchable_bytes = nizk.prove_batchable(&witness, &mut rng);
@@ -342,10 +342,10 @@ fn NI_bbs_blind_commitment_computation() {
     let (morphismp, witness) = bbs_blind_commitment_computation::<G>(&mut rng);
 
     // The SigmaProtocol induced by morphismp
-    let protocol = SchnorrProof(morphismp);
+    let protocol = SchnorrProtocol(morphismp);
     // Fiat-Shamir wrapper
     let domain_sep = b"test-fiat-shamir-bbs-blind-commitment-computation";
-    let mut nizk = NISigmaProtocol::<SchnorrProof<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
+    let mut nizk = NISigmaProtocol::<SchnorrProtocol<G>, ShakeCodec<G>, G>::new(domain_sep, protocol);
 
     // Batchable and compact proofs
     let proof_batchable_bytes = nizk.prove_batchable(&witness, &mut rng);
diff --git a/tests/spec/custom_schnorr_proof.rs b/tests/spec/custom_schnorr_proof.rs
@@ -8,14 +8,14 @@ use sigma_rs::{
 
 use crate::random::SRandom;
 
-pub struct SchnorrProofCustom<G>
+pub struct SchnorrProtocolCustom<G>
 where
     G: SRandom + GroupEncoding + GroupSerialisation,
 {
     pub morphismp: GroupMorphismPreimage<G>,
 }
 
-impl<G> SigmaProtocol for SchnorrProofCustom<G>
+impl<G> SigmaProtocol for SchnorrProtocolCustom<G>
 where
     G: SRandom + GroupEncoding + GroupSerialisation,
 {
diff --git a/tests/spec/sage_test_vectors.rs b/tests/spec/sage_test_vectors.rs
@@ -9,13 +9,13 @@ use sigma_rs::{
     GroupMorphismPreimage, NISigmaProtocol,
 };
 
-use crate::{custom_schnorr_proof::SchnorrProofCustom, random::SRandom, test_drng::TestDRNG};
+use crate::{custom_schnorr_proof::SchnorrProtocolCustom, random::SRandom, test_drng::TestDRNG};
 
 type Preimage<G> = GroupMorphismPreimage<G>;
 
 type Gp = G1Projective;
 type Codec = ByteSchnorrCodec<Gp, KeccakDuplexSponge>;
-type SigmaP = SchnorrProofCustom<Gp>;
+type SigmaP = SchnorrProtocolCustom<Gp>;
 type NISigmaP = NISigmaProtocol<SigmaP, Codec, Gp>;
 
 #[allow(non_snake_case)]
@@ -192,13 +192,13 @@ fn bbs_blind_commitment_computation<G: Group + GroupEncoding + SRandom>(
 }
 
 /// This part tests the implementation of the SigmaProtocol trait for the
-/// SchnorrProof structure as well as the Fiat-Shamir NISigmaProtocol transform
+/// SchnorrProtocol structure as well as the Fiat-Shamir NISigmaProtocol transform
 #[allow(non_snake_case)]
 fn NI_discrete_logarithm(seed: &[u8], context: &[u8]) -> (Vec<Scalar>, Vec<u8>) {
     let mut rng = TestDRNG::new(seed);
     let (morphismp, witness) = discrete_logarithm::<Gp>(&mut rng);
 
-    let protocol = SchnorrProofCustom { morphismp };
+    let protocol = SchnorrProtocolCustom { morphismp };
     let domain_sep: Vec<u8> = context.to_vec();
     let mut nizk = NISigmaP::new(&domain_sep, protocol);
 
@@ -213,7 +213,7 @@ fn NI_dleq(seed: &[u8], context: &[u8]) -> (Vec<Scalar>, Vec<u8>) {
     let mut rng = TestDRNG::new(seed);
     let (morphismp, witness) = dleq::<Gp>(&mut rng);
 
-    let protocol = SchnorrProofCustom { morphismp };
+    let protocol = SchnorrProtocolCustom { morphismp };
     let domain_sep: Vec<u8> = context.to_vec();
     let mut nizk = NISigmaP::new(&domain_sep, protocol);
 
@@ -228,7 +228,7 @@ fn NI_pedersen_commitment(seed: &[u8], context: &[u8]) -> (Vec<Scalar>, Vec<u8>)
     let mut rng = TestDRNG::new(seed);
     let (morphismp, witness) = pedersen_commitment::<Gp>(&mut rng);
 
-    let protocol = SchnorrProofCustom { morphismp };
+    let protocol = SchnorrProtocolCustom { morphismp };
     let domain_sep: Vec<u8> = context.to_vec();
     let mut nizk = NISigmaP::new(&domain_sep, protocol);
 
@@ -243,7 +243,7 @@ fn NI_pedersen_commitment_dleq(seed: &[u8], context: &[u8]) -> (Vec<Scalar>, Vec
     let mut rng = TestDRNG::new(seed);
     let (morphismp, witness) = pedersen_commitment_dleq::<Gp>(&mut rng);
 
-    let protocol = SchnorrProofCustom { morphismp };
+    let protocol = SchnorrProtocolCustom { morphismp };
     let domain_sep: Vec<u8> = context.to_vec();
     let mut nizk = NISigmaP::new(&domain_sep, protocol);
 
@@ -258,7 +258,7 @@ fn NI_bbs_blind_commitment_computation(seed: &[u8], context: &[u8]) -> (Vec<Scal
     let mut rng = TestDRNG::new(seed);
     let (morphismp, witness) = bbs_blind_commitment_computation::<Gp>(&mut rng);
 
-    let protocol = SchnorrProofCustom { morphismp };
+    let protocol = SchnorrProtocolCustom { morphismp };
     let domain_sep: Vec<u8> = context.to_vec();
     let mut nizk = NISigmaP::new(&domain_sep, protocol);
 

Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,14 @@ use sigma_rs::{`
`8`	`8`
`9`	`9`	`use crate::random::SRandom;`
`10`	`10`
`11`		`-pub struct SchnorrProofCustom<G>`
	`11`	`+pub struct SchnorrProtocolCustom<G>`
`12`	`12`	`where`
`13`	`13`	`G: SRandom + GroupEncoding + GroupSerialisation,`
`14`	`14`	`{`
`15`	`15`	`pub morphismp: GroupMorphismPreimage<G>,`
`16`	`16`	`}`
`17`	`17`
`18`		`-impl<G> SigmaProtocol for SchnorrProofCustom<G>`
	`18`	`+impl<G> SigmaProtocol for SchnorrProtocolCustom<G>`
`19`	`19`	`where`
`20`	`20`	`G: SRandom + GroupEncoding + GroupSerialisation,`
`21`	`21`	`{`