pipe ScalarVars through CanonicalLinearRelation and fix type inference

Author: nategraf

src/linear_relation/canonical.rs

@@ -274,7 +274,9 @@ impl<G: PrimeGroup> CanonicalLinearRelation<G> {
 
         // Build the canonical relation
         let mut canonical = Self::new();
-        canonical.num_scalars = (max_scalar_index + 1) as usize;
+        canonical.scalar_vars = (0..=max_scalar_index as usize)
+            .map(|i| ScalarVar(i, PhantomData))
+            .collect();
 
         // Add all group elements to the map
         let mut group_var_map = Vec::new();
@@ -334,19 +336,8 @@ impl<G: PrimeGroup, A: Allocator<G = G>> TryFrom<&LinearRelation<G, A>>
             ));
         }
 
+        // Process each constraint using the canonical linear relation builder.
         let mut builder = CanonicalLinearRelationBuilder::default();
-
-        #[cfg(feature = "std")]
-        let mut scalar_vars = HashSet::<ScalarVar<G>>::new();
-        #[cfg(not(feature = "std"))]
-        let mut scalar_vars = HashSet::<ScalarVar<G>>::with_hasher(RandomState::new());
-        // Cache for deduplicating weighted group elements
-        #[cfg(feature = "std")]
-        let mut weighted_group_cache = HashMap::new();
-        #[cfg(not(feature = "std"))]
-        let mut weighted_group_cache = HashMap::with_hasher(RandomState::new());
-
-        // Process each constraint using the modular helper method
         for (lhs, rhs) in iter::zip(&relation.image, &relation.linear_combinations) {
             // If any group element in the image is not assigned, return `InvalidInstance`.
             let lhs_value = relation.heap.get_element(*lhs)?;
@@ -526,9 +517,14 @@ impl<G: PrimeGroup> CanonicalLinearRelationBuilder<G> {
 
 impl<G: PrimeGroup> Default for CanonicalLinearRelationBuilder<G> {
     fn default() -> Self {
+        #[cfg(feature = "std")]
+        let weighted_group_cache = HashMap::new();
+        #[cfg(not(feature = "std"))]
+        let weighted_group_cache = HashMap::with_hasher(RandomState::new());
+
         Self {
             relation: CanonicalLinearRelation::new(),
-            weighted_group_cache: Default::default(),
+            weighted_group_cache,
         }
     }
 }

src/linear_relation/mod.rs

@@ -172,18 +172,26 @@ pub struct LinearRelation<G: PrimeGroup, A = Heap<G>> {
     pub image: Vec<GroupVar<G>>,
 }
 
-impl<G: PrimeGroup, A: Allocator<G = G>> LinearRelation<G, A> {
+impl<G: PrimeGroup> LinearRelation<G> {
     /// Create a new empty [`LinearRelation`].
-    pub fn new() -> Self
-    where
-        A: Default,
-    {
+    pub fn new() -> Self {
         Self {
             linear_combinations: Vec::new(),
             heap: Default::default(),
             image: Vec::new(),
         }
     }
+}
+
+impl<G: PrimeGroup, A: Allocator<G = G>> LinearRelation<G, A> {
+    /// Create a new empty [`LinearRelation`] using the given [`Allocator`].
+    pub fn new_in(allocator: A) -> Self {
+        Self {
+            linear_combinations: Vec::new(),
+            heap: allocator,
+            image: Vec::new(),
+        }
+    }
 
     /// Adds a new equation to the statement of the form:
     /// `lhs = Σ weight_i * (scalar_i * point_i)`.

src/schnorr_protocol.rs

@@ -240,7 +240,7 @@ impl<G: PrimeGroup> SigmaProtocol for CanonicalLinearRelation<G> {
     /// # Errors
     /// - Returns [`Error::VerificationFailure`] if the byte data is malformed or the length is incorrect.
     fn deserialize_response(&self, data: &[u8]) -> Result<Self::Response, Error> {
-        deserialize_scalars::<G>(data, self.num_scalars).ok_or(Error::VerificationFailure)
+        deserialize_scalars::<G>(data, self.scalar_vars.len()).ok_or(Error::VerificationFailure)
     }
 
     fn instance_label(&self) -> impl AsRef<[u8]> {

src/tests/test_relations.rs

@@ -13,7 +13,6 @@ use crate::linear_relation::{Allocator, CanonicalLinearRelation, LinearRelation,
 pub fn discrete_logarithm<G: PrimeGroup, R: rand::RngCore>(
     rng: &mut R,
 ) -> (CanonicalLinearRelation<G>, ScalarMap<G>) {
-    // TODO(victor/scalarvar): Why is type inference failing here?
     let x = G::Scalar::random(rng);
     let mut relation = LinearRelation::new();