msm accept projective + fr & convert internally

arkworks/src/fft_g1.rs

@@ -4,31 +4,14 @@ use crate::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine};
 
 use crate::kzg_types::ArkG1ProjAddAffine;
 
-use kzg::msm::msm_impls::{batch_convert, msm};
+use kzg::msm::msm_impls::msm;
 
-use ark_ff::BigInteger256;
-
-use kzg::{Fr as KzgFr, G1Mul, Scalar256};
+use kzg::{Fr as KzgFr, G1Mul};
 use kzg::{FFTG1, G1};
 use std::ops::MulAssign;
 
 pub fn g1_linear_combination(out: &mut ArkG1, points: &[ArkG1], scalars: &[ArkFr], len: usize) {
-    if len < 8 {
-        *out = ArkG1::default();
-        for i in 0..len {
-            let tmp = points[i].mul(&scalars[i]);
-            *out = out.add_or_dbl(&tmp);
-        }
-        return;
-    }
-
-    let points = batch_convert(&points[0..len]);
-    let scalars = scalars[0..len]
-        .iter()
-        .map(|scalar| Scalar256::from_u64(BigInteger256::from(scalar.fr).0))
-        .collect::<Vec<_>>();
-
-    *out = msm::<ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>(&points, &scalars);
+    *out = msm::<ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine, ArkFr>(&points, &scalars, len);
 }
 
 pub fn make_data(data: usize) -> Vec<ArkG1> {

blst/src/kzg_proofs.rs

@@ -6,16 +6,15 @@ use crate::types::{fr::FsFr, g1::FsG1Affine};
 
 use crate::types::g1::FsG1ProjAddAffine;
 
-use kzg::msm::msm_impls::{batch_convert, msm};
+use kzg::msm::msm_impls::msm;
 
 use crate::types::g2::FsG2;
-use alloc::vec::Vec;
 use blst::{
     blst_fp12_is_one, blst_p1_affine, blst_p1_cneg, blst_p1_to_affine, blst_p2_affine,
-    blst_p2_to_affine, blst_scalar, blst_scalar_from_fr, Pairing,
+    blst_p2_to_affine, Pairing,
 };
 
-use kzg::{G1Mul, PairingVerify, Scalar256, G1};
+use kzg::PairingVerify;
 
 impl PairingVerify<FsG1, FsG2> for FsG1 {
     fn verify(a1: &FsG1, a2: &FsG2, b1: &FsG1, b2: &FsG2) -> bool {
@@ -24,28 +23,7 @@ impl PairingVerify<FsG1, FsG2> for FsG1 {
 }
 
 pub fn g1_linear_combination(out: &mut FsG1, points: &[FsG1], scalars: &[FsFr], len: usize) {
-    if len < 8 {
-        *out = FsG1::default();
-        for i in 0..len {
-            let tmp = points[i].mul(&scalars[i]);
-            *out = out.add_or_dbl(&tmp);
-        }
-        return;
-    }
-
-    let points = batch_convert(&points[0..len]);
-    let scalars = scalars[0..len]
-        .iter()
-        .map(|scalar| {
-            let mut blst_scalar = blst_scalar::default();
-            unsafe {
-                blst_scalar_from_fr(&mut blst_scalar, &scalar.0);
-            }
-            Scalar256::from_u8(&blst_scalar.b)
-        })
-        .collect::<Vec<_>>();
-
-    *out = msm::<FsG1, FsFp, FsG1Affine, FsG1ProjAddAffine>(&points, &scalars);
+    *out = msm::<FsG1, FsFp, FsG1Affine, FsG1ProjAddAffine, FsFr>(points, scalars, len);
 }
 
 pub fn pairings_verify(a1: &FsG1, a2: &FsG2, b1: &FsG1, b2: &FsG2) -> bool {

kzg/src/msm/msm_impls.rs

@@ -1,29 +1,30 @@
-use crate::{G1Affine, G1Fp, G1GetFp, G1ProjAddAffine, Scalar256, G1};
+use crate::{G1Affine, G1Fp, G1GetFp, G1ProjAddAffine, Scalar256, G1, Fr, G1Mul};
 use alloc::vec::Vec;
 
-#[cfg(feature = "arkmsm")]
+#[cfg(all(feature = "arkmsm", not(feature = "parallel")))]
 use super::arkmsm::arkmsm_msm::VariableBaseMSM;
 
-#[cfg(not(feature = "arkmsm"))]
+#[cfg(all(not(feature = "arkmsm"), not(feature = "parallel")))]
 use super::tiling_pippenger_ops::tiling_pippenger;
 
 #[cfg(feature = "parallel")]
 use super::tiling_parallel_pippenger::{parallel_affine_conv, tiling_parallel_pippenger};
 
 #[cfg(feature = "parallel")]
-pub fn msm_parallel<
+fn msm_parallel<
     TG1: G1 + G1GetFp<TG1Fp>,
     TG1Fp: G1Fp,
     TG1Affine: G1Affine<TG1, TG1Fp>,
-    TProjAddAffine: G1ProjAddAffine<TG1, TG1Fp, TG1Affine>,
 >(
     points: &[TG1Affine],
     scalars: &[Scalar256],
 ) -> TG1 {
     tiling_parallel_pippenger(points, scalars)
 }
 
-pub fn msm_sequential<
+#[cfg(not(feature = "parallel"))]
+#[allow(clippy::extra_unused_type_parameters)]
+fn msm_sequential<
     TG1: G1 + G1GetFp<TG1Fp>,
     TG1Fp: G1Fp,
     TG1Affine: G1Affine<TG1, TG1Fp>,
@@ -34,7 +35,8 @@ pub fn msm_sequential<
 ) -> TG1 {
     #[cfg(not(feature = "arkmsm"))]
     {
-        tiling_pippenger(points, scalars)
+        assert!(core::cmp::min(points.len(), scalars.len()) > 1);
+        tiling_pippenger::<TG1, TG1Fp, TG1Affine>(points, scalars)
     }
 
     #[cfg(feature = "arkmsm")]
@@ -43,28 +45,44 @@ pub fn msm_sequential<
     }
 }
 
+fn batch_convert<TG1: G1, TFp: G1Fp, TG1Affine: G1Affine<TG1, TFp> + Sized>(
+    points: &[TG1],
+) -> Vec<TG1Affine> {
+    #[cfg(feature = "parallel")]
+    return parallel_affine_conv::<TG1, TFp, TG1Affine>(points);
+
+    #[cfg(not(feature = "parallel"))]
+    return TG1Affine::into_affines(points);
+}
+
+#[allow(clippy::extra_unused_type_parameters)]
 pub fn msm<
-    TG1: G1 + G1GetFp<TG1Fp>,
+    TG1: G1 + G1GetFp<TG1Fp> + G1Mul<TFr>,
     TG1Fp: G1Fp,
     TG1Affine: G1Affine<TG1, TG1Fp>,
     TProjAddAffine: G1ProjAddAffine<TG1, TG1Fp, TG1Affine>,
+    TFr: Fr
 >(
-    points: &[TG1Affine],
-    scalars: &[Scalar256],
+    points: &[TG1], scalars: &[TFr], len: usize
 ) -> TG1 {
-    #[cfg(feature = "parallel")]
-    return msm_parallel::<TG1, TG1Fp, TG1Affine, TProjAddAffine>(points, scalars);
+    if len < 8 {
+        let mut out = TG1::default();
+        for i in 0..len {
+            let tmp = points[i].mul(&scalars[i]);
+            out.add_or_dbl_assign(&tmp);
+        }
+        return out;
+    }
 
-    #[cfg(not(feature = "parallel"))]
-    return msm_sequential::<TG1, TG1Fp, TG1Affine, TProjAddAffine>(points, scalars);
-}
+    let points = batch_convert::<TG1, TG1Fp, TG1Affine>(&points[0..len]);
+    let scalars = scalars[0..len]
+        .iter()
+        .map(TFr::to_scalar)
+        .collect::<Vec<_>>();
 
-pub fn batch_convert<TG1: G1, TFp: G1Fp, TG1Affine: G1Affine<TG1, TFp> + Sized>(
-    points: &[TG1],
-) -> Vec<TG1Affine> {
     #[cfg(feature = "parallel")]
-    return parallel_affine_conv::<TG1, TFp, TG1Affine>(points);
+    return msm_parallel::<TG1, TG1Fp, TG1Affine>(&points, &scalars);
 
     #[cfg(not(feature = "parallel"))]
-    return TG1Affine::into_affines(points);
-}
+    return msm_sequential::<TG1, TG1Fp, TG1Affine, TProjAddAffine>(&points, &scalars);
+}