refactor(trait): simplify HasGroupMorphism trait and implement for Protocol

- refactor: simplify HasGroupMorphism trait interface and implementation
- feat: add HasGroupMorphism trait implementation for Protocol structure

Author: nougzarm

src/fiat_shamir.rs

@@ -14,10 +14,8 @@
 
 use crate::codec::Codec;
 use crate::errors::Error;
-use crate::group_morphism::HasGroupMorphism;
 use crate::traits::{CompactProtocol, SigmaProtocol};
 
-use group::{Group, GroupEncoding};
 use rand::{CryptoRng, RngCore};
 
 pub trait FiatShamir<C: Codec>: SigmaProtocol {
@@ -26,6 +24,13 @@ pub trait FiatShamir<C: Codec>: SigmaProtocol {
     fn get_challenge(&self, codec: &mut C) -> Result<Self::Challenge, Error>;
 }
 
+/// Trait for accessing the underlying group morphism in a Sigma protocol.
+pub trait HasGroupMorphism {
+    /// Absorbs the morphism structure into a codec.
+    /// Only compatible with 64-bit platforms
+    fn absorb_morphism_structure<C: Codec>(&self, codec: &mut C) -> Result<(), Error>;
+}
+
 type Transcript<P> = (
     <P as SigmaProtocol>::Commitment,
     <P as SigmaProtocol>::Challenge,
@@ -249,13 +254,12 @@ where
 
 impl<P, C> NISigmaProtocol<P, C>
 where
-    P: SigmaProtocol<Challenge = <P::Group as Group>::Scalar> + HasGroupMorphism + FiatShamir<C>,
+    P: SigmaProtocol + HasGroupMorphism + FiatShamir<C>,
     P::Challenge: PartialEq,
-    P::Group: Group + GroupEncoding,
     C: Codec<Challenge = P::Challenge> + Clone,
 {
     /// Absorbs the morphism structure into the transcript codec.
     pub fn absorb_morphism(&self, codec: &mut C) -> Result<(), Error> {
-        self.sigmap.absorb_morphism_structure(codec)
+        self.sigmap.absorb_morphism_structure::<C>(codec)
     }
 }

src/group_morphism.rs

@@ -8,11 +8,9 @@
 //! - [`Morphism`]: a collection of linear combinations acting on group elements
 //! - [`GroupMorphismPreimage`]: a higher-level structure managing morphisms and their associated images
 
-use std::iter;
-
-use crate::codec::Codec;
 use crate::errors::Error;
 use group::{Group, GroupEncoding};
+use std::iter;
 
 /// Implementations of core ops for the linear combination types.
 mod ops;
@@ -460,24 +458,3 @@ where
             .collect()
     }
 }
-
-/// Trait for accessing the underlying group morphism in a Sigma protocol.
-pub trait HasGroupMorphism {
-    type Group: Group + GroupEncoding;
-    fn group_morphism(&self) -> &GroupMorphismPreimage<Self::Group>;
-
-    /// Absorbs the morphism structure into a codec.
-    /// Only compatible with 64-bit platforms
-    fn absorb_morphism_structure<C: Codec>(&self, codec: &mut C) -> Result<(), Error> {
-        let morphism = self.group_morphism();
-        for lc in &morphism.morphism.constraints {
-            for term in lc.terms() {
-                let mut buf = [0u8; 16];
-                buf[..8].copy_from_slice(&(term.scalar().index() as u64).to_le_bytes());
-                buf[8..].copy_from_slice(&(term.elem().index() as u64).to_le_bytes());
-                codec.prover_message(&buf);
-            }
-        }
-        Ok(())
-    }
-}

src/protocol.rs

@@ -5,7 +5,7 @@ use crate::codec::Codec;
 use crate::traits::CompactProtocol;
 use crate::{
     errors::Error,
-    fiat_shamir::FiatShamir,
+    fiat_shamir::{FiatShamir, HasGroupMorphism},
     group_serialization::{deserialize_scalar, serialize_scalar},
     schnorr_protocol::SchnorrProtocol,
     traits::{SigmaProtocol, SigmaProtocolSimulator},
@@ -622,3 +622,17 @@ where
         Ok(codec.verifier_challenge())
     }
 }
+
+impl<G: Group + GroupEncoding> HasGroupMorphism for Protocol<G> {
+    fn absorb_morphism_structure<C: Codec>(&self, codec: &mut C) -> Result<(), Error> {
+        match self {
+            Protocol::Simple(p) => p.absorb_morphism_structure(codec),
+            Protocol::And(ps) | Protocol::Or(ps) => {
+                for p in ps {
+                    p.absorb_morphism_structure(codec)?
+                }
+                Ok(())
+            }
+        }
+    }
+}

src/schnorr_protocol.rs

@@ -6,8 +6,8 @@
 
 use crate::codec::Codec;
 use crate::errors::Error;
-use crate::fiat_shamir::FiatShamir;
-use crate::group_morphism::{GroupMorphismPreimage, HasGroupMorphism};
+use crate::fiat_shamir::{FiatShamir, HasGroupMorphism};
+use crate::group_morphism::GroupMorphismPreimage;
 use crate::{
     group_serialization::*,
     traits::{CompactProtocol, SigmaProtocol, SigmaProtocolSimulator},
@@ -431,8 +431,15 @@ where
 }
 
 impl<G: Group + GroupEncoding> HasGroupMorphism for SchnorrProtocol<G> {
-    type Group = G;
-    fn group_morphism(&self) -> &GroupMorphismPreimage<G> {
-        &self.0
+    fn absorb_morphism_structure<C: Codec>(&self, codec: &mut C) -> Result<(), Error> {
+        for lc in &self.0.morphism.constraints {
+            for term in lc.terms() {
+                let mut buf = [0u8; 16];
+                buf[..8].copy_from_slice(&(term.scalar().index() as u64).to_le_bytes());
+                buf[8..].copy_from_slice(&(term.elem().index() as u64).to_le_bytes());
+                codec.prover_message(&buf);
+            }
+        }
+        Ok(())
     }
 }

tests/morphism_preimage.rs

@@ -2,8 +2,7 @@ use bls12_381::{G1Projective as G, Scalar};
 use group::{Group, ff::Field};
 use rand::rngs::OsRng;
 
-use sigma_rs::fiat_shamir::NISigmaProtocol;
-use sigma_rs::group_morphism::HasGroupMorphism;
+use sigma_rs::fiat_shamir::{HasGroupMorphism, NISigmaProtocol};
 use sigma_rs::test_utils::{
     bbs_blind_commitment_computation, discrete_logarithm, dleq, pedersen_commitment,
     pedersen_commitment_dleq,