Fix lint in pairing library

Author: Avaneesh-axiom

extensions/pairing/guest/src/halo2curves_shims/bls12_381/mod.rs

@@ -9,6 +9,9 @@ pub use line::*;
 #[cfg(test)]
 pub mod tests;
 
+// Make public for use by tests in guest-libs/pairing/
+pub mod test_utils;
+
 use halo2curves_axiom::bls12_381::{Fq, Fq12, Fq2};
 use openvm_algebra_guest::field::FieldExtension;
 

extensions/pairing/guest/src/halo2curves_shims/bls12_381/test_utils.rs

@@ -0,0 +1,33 @@
+use core::mem::transmute;
+
+use halo2curves_axiom::bls12_381::{Fq12, MillerLoopResult};
+use hex_literal::hex;
+use lazy_static::lazy_static;
+use num_bigint::BigUint;
+use num_traits::Pow;
+use openvm_algebra_guest::ExpBytes;
+
+lazy_static! {
+    pub static ref BLS12_381_MODULUS: BigUint = BigUint::from_bytes_be(&hex!(
+        "1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab"
+    ));
+    pub static ref BLS12_381_ORDER: BigUint = BigUint::from_bytes_be(&hex!(
+        "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001"
+    ));
+}
+
+// Manual final exponentiation because halo2curves `MillerLoopResult` doesn't have constructor
+pub fn final_exp(f: Fq12) -> Fq12 {
+    let p = BLS12_381_MODULUS.clone();
+    let r = BLS12_381_ORDER.clone();
+    let exp: BigUint = (p.pow(12u32) - BigUint::from(1u32)) / r;
+    ExpBytes::exp_bytes(&f, true, &exp.to_bytes_be())
+}
+
+// Gt(Fq12) is not public
+pub fn assert_miller_results_eq(a: MillerLoopResult, b: Fq12) {
+    // [jpw] This doesn't work:
+    // assert_eq!(a.final_exponentiation(), unsafe { transmute(final_exp(b)) });
+    let a = unsafe { transmute::<MillerLoopResult, Fq12>(a) };
+    assert_eq!(final_exp(a), final_exp(b));
+}

extensions/pairing/guest/src/halo2curves_shims/bls12_381/tests/mod.rs

@@ -1,13 +1,7 @@
 use alloc::vec::Vec;
-use core::mem::transmute;
 
-use halo2curves_axiom::bls12_381::{Fq, Fq12, Fq2, G1Affine, G2Affine, MillerLoopResult};
-use hex_literal::hex;
+use halo2curves_axiom::bls12_381::{Fq, Fq2, G1Affine, G2Affine};
 use itertools::izip;
-use lazy_static::lazy_static;
-use num_bigint::BigUint;
-use num_traits::Pow;
-use openvm_algebra_guest::ExpBytes;
 use openvm_ecc_guest::AffinePoint;
 use rand::{rngs::StdRng, SeedableRng};
 
@@ -19,32 +13,6 @@ mod test_line;
 mod test_miller_loop;
 
 #[cfg(not(target_os = "zkvm"))]
-
-lazy_static! {
-    pub static ref BLS12_381_MODULUS: BigUint = BigUint::from_bytes_be(&hex!(
-        "1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab"
-    ));
-    pub static ref BLS12_381_ORDER: BigUint = BigUint::from_bytes_be(&hex!(
-        "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001"
-    ));
-}
-
-// Manual final exponentiation because halo2curves `MillerLoopResult` doesn't have constructor
-pub fn final_exp(f: Fq12) -> Fq12 {
-    let p = BLS12_381_MODULUS.clone();
-    let r = BLS12_381_ORDER.clone();
-    let exp: BigUint = (p.pow(12u32) - BigUint::from(1u32)) / r;
-    ExpBytes::exp_bytes(&f, true, &exp.to_bytes_be())
-}
-
-// Gt(Fq12) is not public
-pub fn assert_miller_results_eq(a: MillerLoopResult, b: Fq12) {
-    // [jpw] This doesn't work:
-    // assert_eq!(a.final_exponentiation(), unsafe { transmute(final_exp(b)) });
-    let a = unsafe { transmute::<MillerLoopResult, Fq12>(a) };
-    assert_eq!(final_exp(a), final_exp(b));
-}
-
 #[allow(non_snake_case)]
 #[allow(clippy::type_complexity)]
 pub fn generate_test_points_bls12_381(

extensions/pairing/guest/src/halo2curves_shims/bls12_381/tests/test_miller_loop.rs

@@ -8,7 +8,7 @@ use subtle::ConditionallySelectable;
 use super::generate_test_points_bls12_381;
 use crate::{
     halo2curves_shims::bls12_381::{
-        tests::{assert_miller_results_eq, final_exp},
+        test_utils::{assert_miller_results_eq, final_exp},
         Bls12_381,
     },
     pairing::{Evaluatable, LineMulMType, MillerStep, MultiMillerLoop},

extensions/pairing/guest/src/halo2curves_shims/bn254/mod.rs

@@ -9,6 +9,9 @@ pub use line::*;
 #[cfg(test)]
 pub mod tests;
 
+// Make public for use by tests in guest-libs/pairing/
+pub mod test_utils;
+
 use halo2curves_axiom::bn256::{Fq, Fq12, Fq2};
 use openvm_algebra_guest::field::FieldExtension;
 

extensions/pairing/guest/src/halo2curves_shims/bn254/test_utils.rs

@@ -0,0 +1,35 @@
+use core::mem::transmute;
+
+use halo2curves_axiom::{
+    bn256::{Fq12, Gt},
+    pairing::MillerLoopResult,
+};
+use hex_literal::hex;
+use lazy_static::lazy_static;
+use num_bigint::BigUint;
+use num_traits::Pow;
+use openvm_algebra_guest::ExpBytes;
+
+lazy_static! {
+    pub static ref BN254_MODULUS: BigUint = BigUint::from_bytes_be(&hex!(
+        "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47"
+    ));
+    pub static ref BN254_ORDER: BigUint = BigUint::from_bytes_be(&hex!(
+        "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001"
+    ));
+}
+
+// Manual final exponentiation because halo2curves `MillerLoopResult` doesn't have constructor
+pub fn final_exp(f: Fq12) -> Fq12 {
+    let p = BN254_MODULUS.clone();
+    let r = BN254_ORDER.clone();
+    let exp: BigUint = (p.pow(12u32) - BigUint::from(1u32)) / r;
+    ExpBytes::exp_bytes(&f, true, &exp.to_bytes_be())
+}
+
+// Gt(Fq12) is not public
+pub fn assert_miller_results_eq(a: Gt, b: Fq12) {
+    let a = a.final_exponentiation();
+    let b = final_exp(b);
+    assert_eq!(unsafe { transmute::<Gt, Fq12>(a) }, b);
+}

extensions/pairing/guest/src/halo2curves_shims/bn254/tests/mod.rs

@@ -1,16 +1,7 @@
 use alloc::vec::Vec;
-use core::mem::transmute;
 
-use halo2curves_axiom::{
-    bn256::{Fq, Fq12, Fq2, G1Affine, G2Affine, Gt},
-    pairing::MillerLoopResult,
-};
-use hex_literal::hex;
+use halo2curves_axiom::bn256::{Fq, Fq2, G1Affine, G2Affine};
 use itertools::izip;
-use lazy_static::lazy_static;
-use num_bigint::BigUint;
-use num_traits::Pow;
-use openvm_algebra_guest::ExpBytes;
 use openvm_ecc_guest::AffinePoint;
 use rand::{rngs::StdRng, SeedableRng};
 
@@ -21,30 +12,6 @@ mod test_line;
 #[cfg(test)]
 mod test_miller_loop;
 
-lazy_static! {
-    pub static ref BN254_MODULUS: BigUint = BigUint::from_bytes_be(&hex!(
-        "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47"
-    ));
-    pub static ref BN254_ORDER: BigUint = BigUint::from_bytes_be(&hex!(
-        "30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001"
-    ));
-}
-
-// Manual final exponentiation because halo2curves `MillerLoopResult` doesn't have constructor
-pub fn final_exp(f: Fq12) -> Fq12 {
-    let p = BN254_MODULUS.clone();
-    let r = BN254_ORDER.clone();
-    let exp: BigUint = (p.pow(12u32) - BigUint::from(1u32)) / r;
-    ExpBytes::exp_bytes(&f, true, &exp.to_bytes_be())
-}
-
-// Gt(Fq12) is not public
-pub fn assert_miller_results_eq(a: Gt, b: Fq12) {
-    let a = a.final_exponentiation();
-    let b = final_exp(b);
-    assert_eq!(unsafe { transmute::<Gt, Fq12>(a) }, b);
-}
-
 #[allow(non_snake_case)]
 #[allow(clippy::type_complexity)]
 pub fn generate_test_points_bn254(

extensions/pairing/guest/src/halo2curves_shims/bn254/tests/test_miller_loop.rs

@@ -2,8 +2,11 @@ use alloc::vec::Vec;
 
 use halo2curves_axiom::bn256::G2Prepared;
 
-use super::{assert_miller_results_eq, generate_test_points_bn254};
-use crate::{halo2curves_shims::bn254::Bn254, pairing::MultiMillerLoop};
+use super::generate_test_points_bn254;
+use crate::{
+    halo2curves_shims::bn254::{test_utils::assert_miller_results_eq, Bn254},
+    pairing::MultiMillerLoop,
+};
 
 #[allow(non_snake_case)]
 fn run_miller_loop_test(rand_seeds: &[u64]) {

guest-libs/ff_derive/guest/src/lib.rs

@@ -44,6 +44,8 @@ impl ReprEndianness {
         }
     }
 
+    // Clippy things methods named from_* don't take self as a parameter
+    #[allow(clippy::wrong_self_convention)]
     fn from_repr(&self, name: &syn::Ident, limbs: usize) -> proc_macro2::TokenStream {
         let read_repr = match self {
             ReprEndianness::Big => quote! {

guest-libs/k256/guest/src/internal.rs

@@ -74,10 +74,10 @@ impl IntrinsicCurve for Secp256k1 {
 
 impl Secp256k1Point {
     pub fn x_be_bytes(&self) -> [u8; 32] {
-        <Self as WeierstrassPoint>::x(&self).to_be_bytes()
+        <Self as WeierstrassPoint>::x(self).to_be_bytes()
     }
 
     pub fn y_be_bytes(&self) -> [u8; 32] {
-        <Self as WeierstrassPoint>::y(&self).to_be_bytes()
+        <Self as WeierstrassPoint>::y(self).to_be_bytes()
     }
 }

guest-libs/k256/guest/src/point.rs

@@ -225,7 +225,7 @@ impl FromEncodedPoint<Secp256k1> for Secp256k1Point {
         match openvm_ecc_guest::ecdsa::VerifyingKey::<Secp256k1>::from_sec1_bytes(
             encoded_point.as_bytes(),
         ) {
-            Ok(verifying_key) => CtOption::new(verifying_key.as_affine().clone(), 1.into()),
+            Ok(verifying_key) => CtOption::new(*verifying_key.as_affine(), 1.into()),
             Err(_) => CtOption::new(Secp256k1Point::default(), 0.into()),
         }
     }

guest-libs/p256/guest/src/internal.rs

@@ -74,10 +74,10 @@ impl IntrinsicCurve for P256 {
 
 impl P256Point {
     pub fn x_be_bytes(&self) -> [u8; 32] {
-        <Self as WeierstrassPoint>::x(&self).to_be_bytes()
+        <Self as WeierstrassPoint>::x(self).to_be_bytes()
     }
 
     pub fn y_be_bytes(&self) -> [u8; 32] {
-        <Self as WeierstrassPoint>::y(&self).to_be_bytes()
+        <Self as WeierstrassPoint>::y(self).to_be_bytes()
     }
 }

guest-libs/p256/guest/src/point.rs

@@ -220,7 +220,7 @@ impl FromEncodedPoint<P256> for P256Point {
         match openvm_ecc_guest::ecdsa::VerifyingKey::<P256>::from_sec1_bytes(
             encoded_point.as_bytes(),
         ) {
-            Ok(verifying_key) => CtOption::new(verifying_key.as_affine().clone(), 1.into()),
+            Ok(verifying_key) => CtOption::new(*verifying_key.as_affine(), 1.into()),
             Err(_) => CtOption::new(P256Point::default(), 0.into()),
         }
     }

guest-libs/pairing/guest/src/bls12_381/mod.rs

@@ -15,10 +15,6 @@ pub(crate) mod utils;
 pub use fp12::*;
 pub use fp2::*;
 use hex_literal::hex;
-#[cfg(not(target_os = "zkvm"))]
-use lazy_static::lazy_static;
-#[cfg(not(target_os = "zkvm"))]
-use num_bigint::BigUint;
 use openvm_ecc_sw_macros::sw_declare;
 use openvm_pairing_guest::pairing::PairingIntrinsics;
 

guest-libs/pairing/guest/src/bls12_381/tests.rs

@@ -6,23 +6,23 @@ use num_bigint::BigUint;
 use num_traits::One;
 use openvm_algebra_guest::{field::FieldExtension, IntMod};
 use openvm_ecc_guest::{weierstrass::WeierstrassPoint, AffinePoint};
+use openvm_pairing_guest::{
+    bls12_381::{BLS12_381_MODULUS, BLS12_381_ORDER},
+    pairing::{FinalExp, MultiMillerLoop, PairingCheck, PairingIntrinsics},
+};
 use rand::{rngs::StdRng, SeedableRng};
 
-use super::{Fp, Fp12, Fp2, BLS12_381_MODULUS, BLS12_381_ORDER};
+use super::{Fp, Fp12, Fp2};
 use crate::{
     bls12_381::{
         utils::{
             convert_bls12381_fp12_to_halo2_fq12, convert_bls12381_halo2_fq12_to_fp12,
             convert_bls12381_halo2_fq2_to_fp2, convert_bls12381_halo2_fq_to_fp,
             convert_g2_affine_halo2_to_openvm,
         },
-        Bls12_381, G2Affine as OpenVmG2Affine, BLS12_381_PSEUDO_BINARY_ENCODING,
-        BLS12_381_SEED_ABS,
-    },
-    pairing::{
-        fp2_invert_assign, fp6_invert_assign, fp6_square_assign, FinalExp, MultiMillerLoop,
-        PairingCheck, PairingIntrinsics,
+        Bls12_381, G2Affine as OpenVmG2Affine,
     },
+    operations::{fp2_invert_assign, fp6_invert_assign, fp6_square_assign},
 };
 
 #[test]
@@ -158,7 +158,7 @@ fn test_fp_one() {
 // Gt(Fq12) is not public
 fn assert_miller_results_eq(a: MillerLoopResult, b: Fp12) {
     let b = convert_bls12381_fp12_to_halo2_fq12(b);
-    crate::halo2curves_shims::bls12_381::tests::assert_miller_results_eq(a, b);
+    openvm_pairing_guest::halo2curves_shims::bls12_381::test_utils::assert_miller_results_eq(a, b);
 }
 
 #[test]
@@ -289,9 +289,12 @@ fn test_bls12381_pairing_check_hint_host() {
         y: h2c_q.y,
     };
 
-    let f_cmp =
-        crate::halo2curves_shims::bls12_381::Bls12_381::multi_miller_loop(&[p_cmp], &[q_cmp]);
-    let (c_cmp, s_cmp) = crate::halo2curves_shims::bls12_381::Bls12_381::final_exp_hint(&f_cmp);
+    let f_cmp = openvm_pairing_guest::halo2curves_shims::bls12_381::Bls12_381::multi_miller_loop(
+        &[p_cmp],
+        &[q_cmp],
+    );
+    let (c_cmp, s_cmp) =
+        openvm_pairing_guest::halo2curves_shims::bls12_381::Bls12_381::final_exp_hint(&f_cmp);
     let c_cmp = convert_bls12381_halo2_fq12_to_fp12(c_cmp);
     let s_cmp = convert_bls12381_halo2_fq12_to_fp12(s_cmp);
 

guest-libs/pairing/guest/src/bn254/mod.rs

@@ -3,10 +3,6 @@ extern crate alloc;
 use core::ops::{Add, Neg};
 
 use hex_literal::hex;
-#[cfg(not(target_os = "zkvm"))]
-use lazy_static::lazy_static;
-#[cfg(not(target_os = "zkvm"))]
-use num_bigint::BigUint;
 use openvm_algebra_guest::{Field, IntMod};
 use openvm_algebra_moduli_macros::moduli_declare;
 use openvm_ecc_guest::{

guest-libs/pairing/guest/src/bn254/tests.rs

@@ -7,21 +7,23 @@ use num_bigint::BigUint;
 use num_traits::One;
 use openvm_algebra_guest::{field::FieldExtension, IntMod};
 use openvm_ecc_guest::{weierstrass::WeierstrassPoint, AffinePoint};
-use openvm_pairing_guest::pairing::{
-    fp2_invert_assign, fp6_invert_assign, fp6_square_assign, FinalExp, MultiMillerLoop,
-    PairingCheck, PairingIntrinsics,
+use openvm_pairing_guest::{
+    bn254::{BN254_MODULUS, BN254_ORDER},
+    pairing::{FinalExp, MultiMillerLoop, PairingCheck, PairingIntrinsics},
 };
 use rand::{rngs::StdRng, SeedableRng};
 
 use super::{Fp, Fp12, Fp2};
-use crate::bn254::{
-    utils::{
-        convert_bn254_fp12_to_halo2_fq12, convert_bn254_halo2_fq12_to_fp12,
-        convert_bn254_halo2_fq2_to_fp2, convert_bn254_halo2_fq_to_fp,
-        convert_g2_affine_halo2_to_openvm,
+use crate::{
+    bn254::{
+        utils::{
+            convert_bn254_fp12_to_halo2_fq12, convert_bn254_halo2_fq12_to_fp12,
+            convert_bn254_halo2_fq2_to_fp2, convert_bn254_halo2_fq_to_fp,
+            convert_g2_affine_halo2_to_openvm,
+        },
+        Bn254, G2Affine as OpenVmG2Affine,
     },
-    Bn254, G2Affine as OpenVmG2Affine, BN254_MODULUS, BN254_ORDER, BN254_PSEUDO_BINARY_ENCODING,
-    BN254_SEED,
+    operations::{fp2_invert_assign, fp6_invert_assign, fp6_square_assign},
 };
 
 #[test]
@@ -146,7 +148,7 @@ fn test_fp_one() {
 // Gt(Fq12) is not public
 fn assert_miller_results_eq(a: Gt, b: Fp12) {
     let b = convert_bn254_fp12_to_halo2_fq12(b);
-    crate::halo2curves_shims::bn254::tests::assert_miller_results_eq(a, b);
+    openvm_pairing_guest::halo2curves_shims::bn254::test_utils::assert_miller_results_eq(a, b);
 }
 
 #[test]
@@ -274,8 +276,12 @@ fn test_bn254_pairing_check_hint_host() {
         y: h2c_q.y,
     };
 
-    let f_cmp = crate::halo2curves_shims::bn254::Bn254::multi_miller_loop(&[p_cmp], &[q_cmp]);
-    let (c_cmp, u_cmp) = crate::halo2curves_shims::bn254::Bn254::final_exp_hint(&f_cmp);
+    let f_cmp = openvm_pairing_guest::halo2curves_shims::bn254::Bn254::multi_miller_loop(
+        &[p_cmp],
+        &[q_cmp],
+    );
+    let (c_cmp, u_cmp) =
+        openvm_pairing_guest::halo2curves_shims::bn254::Bn254::final_exp_hint(&f_cmp);
     let c_cmp = convert_bn254_halo2_fq12_to_fp12(c_cmp);
     let u_cmp = convert_bn254_halo2_fq12_to_fp12(u_cmp);