Merge pull request #1 from EYBlockchain/livesey/fully-collapse

Livesey/fully collapse

Author: Michael-EY

circuits/src/verifier/accumulator.rs

@@ -121,6 +121,12 @@ impl<S: SelfEmulation> Accumulator<S> {
         self.rhs.collapse();
     }
 
+    /// Evaluates the variable and fixed parts of the Accumulator collapsing
+    /// each side to a single point.
+    pub fn fully_collapse(&self, fixed_bases: &BTreeMap<String, S::C>) -> (S::C, S::C) {
+        (self.lhs.eval(fixed_bases), self.rhs.eval(fixed_bases))
+    }
+
     /// Accumulates several accumulators together. The resulting acc will
     /// satisfy the invariant iff all the accumulators individually do.
     pub fn accumulate(accs: &[Self]) -> Self {
@@ -293,6 +299,21 @@ impl<S: SelfEmulation> AssignedAccumulator<S> {
         self.rhs.collapse(layouter, curve_chip, scalar_chip)
     }
 
+    /// Evaluates the variable and fixed parts of the AssignedAccumulator
+    /// collapsing each side to a single point.
+    ///
+    /// This will likely be an expensive in-circuit operation.
+    pub fn fully_collapse(
+        &self,
+        layouter: &mut impl Layouter<S::F>,
+        curve_chip: &S::CurveChip,
+        fixed_bases: &BTreeMap<String, S::C>,
+    ) -> Result<(S::AssignedPoint, S::AssignedPoint), Error> {
+        let lhs_pt = self.lhs.eval(layouter, curve_chip, fixed_bases)?;
+        let rhs_pt = self.rhs.eval(layouter, curve_chip, fixed_bases)?;
+        Ok((lhs_pt, rhs_pt))
+    }
+
     /// Accumulates several accumulators together. The resulting acc will
     /// satisfy the invariant iff all the accumulators individually do.
     pub fn accumulate(

circuits/src/verifier/msm.rs

@@ -485,6 +485,34 @@ impl<S: SelfEmulation> AssignedMsm<S> {
         Ok(())
     }
 
+    /// Evaluates the variable and fixed base parts of the AssignedMsm
+    /// collapsing it to a single point.
+    ///
+    /// The fixed bases are constrained in-circuit to be fixed.
+    pub fn eval(
+        &self,
+        layouter: &mut impl Layouter<S::F>,
+        curve_chip: &S::CurveChip,
+        fixed_bases: &BTreeMap<String, S::C>,
+    ) -> Result<S::AssignedPoint, Error> {
+        let mut bases = self.bases.clone();
+        let mut scalars = self.scalars.clone();
+
+        for (key, scalar) in self.fixed_base_scalars.iter() {
+            let base = fixed_bases.get(key).expect("Base not provided: {key}");
+            let fixed_base = curve_chip.assign_fixed(layouter, *base)?;
+            bases.push(fixed_base);
+            scalars.push(scalar.clone());
+        }
+
+        let scalar_tuples = scalars
+            .iter()
+            .map(|s| (s.scalar.clone(), s.bound.bits() as usize))
+            .collect::<Vec<_>>();
+
+        S::msm(layouter, curve_chip, &scalar_tuples, &bases)
+    }
+
     /// Scales all the scalars of the AssignedMsm by the given factor r.
     ///
     /// This function mutates self.