diff --git a/Cargo.toml b/Cargo.toml index 1de3a28..1f06a51 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,7 +22,7 @@ rust-version = "1.63" crate-type = ["cdylib", "lib"] [dependencies] -ark-bls12-381 = "0.3.0" +# ark-bls12-381 = "0.3.0" ark-ec = "0.3.0" ark-ff = "0.3.0" ark-std = "0.3.0" diff --git a/src/batch_adder.rs b/src/batch_adder.rs index 74c4625..a463f23 100644 --- a/src/batch_adder.rs +++ b/src/batch_adder.rs @@ -201,199 +201,199 @@ impl BatchAdder

{ } } -#[cfg(test)] -mod batch_add_tests { - use super::*; - use ark_bls12_381::G1Affine; - use ark_ec::{AffineCurve, ProjectiveCurve}; - use ark_std::UniformRand; - use std::ops::Add; - - #[test] - fn test_phase_one_zero_or_neg() { - let mut batch_adder = BatchAdder::new(4); - batch_adder.batch_add_phase_one(&G1Affine::zero(), &G1Affine::zero(), 0); - - let mut rng = ark_std::test_rng(); - let p = ::Projective::rand(&mut rng); - let p_affine = G1Affine::from(p); - let mut neg_p_affine = p_affine; - neg_p_affine.y = -neg_p_affine.y; - - batch_adder.batch_add_phase_one(&p_affine, &neg_p_affine, 0); - } - - #[test] - fn test_phase_one_p_add_p() { - let mut batch_adder = BatchAdder::new(4); - let mut rng = ark_std::test_rng(); - let prj = ::Projective::rand(&mut rng); - let p = G1Affine::from(prj); - let acc = p; - - batch_adder.batch_add_phase_one(&acc, &p, 0); - assert!(batch_adder.inverses[0].is_one()); - assert_eq!(batch_adder.inverse_state, p.y + p.y); - } - - #[test] - fn test_phase_one_p_add_q() { - let mut batch_adder = BatchAdder::new(4); - let mut rng = ark_std::test_rng(); - let p_prj = ::Projective::rand(&mut rng); - let q_prj = ::Projective::rand(&mut rng); - let p = G1Affine::from(p_prj); - let q = G1Affine::from(q_prj); - - batch_adder.batch_add_phase_one(&p, &q, 0); - assert!(batch_adder.inverses[0].is_one()); - assert_eq!(batch_adder.inverse_state, q.x - p.x); - } - - #[test] - fn test_phase_one_p_add_q_twice() { - let mut batch_adder = BatchAdder::new(4); - let mut rng = ark_std::test_rng(); - let p_prj = ::Projective::rand(&mut rng); - let q_prj = ::Projective::rand(&mut rng); - let p = G1Affine::from(p_prj); - let q = G1Affine::from(q_prj); - - batch_adder.batch_add_phase_one(&p, &q, 0); - batch_adder.batch_add_phase_one(&p, &q, 0); - assert_eq!(batch_adder.inverses[0], q.x - p.x); - assert_eq!(batch_adder.inverse_state, (q.x - p.x) * (q.x - p.x)); - } - - #[test] - fn test_phase_two_zero_add_p() { - let mut batch_adder = BatchAdder::new(4); - let mut rng = ark_std::test_rng(); - let p_prj = ::Projective::rand(&mut rng); - let p = G1Affine::from(p_prj); - let mut acc = G1Affine::zero(); - batch_adder.batch_add_phase_two(&mut acc, &p, 0); - assert_eq!(acc, p); - } - - #[test] - fn test_phase_two_p_add_neg() { - let mut batch_adder = BatchAdder::new(4); - - let mut rng = ark_std::test_rng(); - let p_prj = ::Projective::rand(&mut rng); - let mut acc = G1Affine::from(p_prj); - let mut p = acc; - p.y = -p.y; - - batch_adder.batch_add_phase_two(&mut acc, &p, 0); - assert_eq!(acc, G1Affine::zero()); - } - - #[test] - fn test_phase_two_p_add_q() { - let mut batch_adder = BatchAdder::new(4); - - let mut rng = ark_std::test_rng(); - let acc_prj = ::Projective::rand(&mut rng); - let mut acc = G1Affine::from(acc_prj); - let mut p = acc; - p.x = p.x + p.x; - - batch_adder.inverses[0] = (p.x - acc.x).inverse().unwrap(); - batch_adder.batch_add_phase_two(&mut acc, &p, 0); - assert_eq!(acc, G1Affine::from(acc_prj.add_mixed(&p))); - } - - #[test] - fn test_phase_two_p_add_p() { - let mut batch_adder = BatchAdder::new(4); - - let mut rng = ark_std::test_rng(); - let acc_prj = ::Projective::rand(&mut rng); - let mut acc = G1Affine::from(acc_prj); - let p = acc; - - batch_adder.inverses[0] = (p.y + p.y).inverse().unwrap(); - batch_adder.batch_add_phase_two(&mut acc, &p, 0); - assert_eq!(acc, G1Affine::from(acc_prj).add(p)); - } - - #[test] - fn test_batch_add() { - let mut batch_adder = BatchAdder::new(10); - - let mut rng = ark_std::test_rng(); - let mut buckets: Vec = (0..10) - .map(|_| G1Affine::from(::Projective::rand(&mut rng))) - .collect(); - let points: Vec = (0..10) - .map(|_| G1Affine::from(::Projective::rand(&mut rng))) - .collect(); - - let tmp = buckets.clone(); - batch_adder.batch_add(&mut buckets, &points); - - for i in 0..10 { - assert_eq!(buckets[i], tmp[i].add(points[i])); - } - } - - #[test] - fn test_batch_add_step_n() { - let mut batch_adder = BatchAdder::new(10); - - let mut rng = ark_std::test_rng(); - let mut buckets: Vec = (0..10) - .map(|_| G1Affine::from(::Projective::rand(&mut rng))) - .collect(); - let points: Vec = (0..10) - .map(|_| G1Affine::from(::Projective::rand(&mut rng))) - .collect(); - - let tmp = buckets.clone(); - batch_adder.batch_add_step_n(&mut buckets, 1, &points, 2, 3); - - for i in 0..3 { - assert_eq!(buckets[i], tmp[i].add(points[i * 2])); - } - } - - #[test] - fn test_batch_add_indexed() { - let mut batch_adder = BatchAdder::new(10); - let mut rng = ark_std::test_rng(); - - let mut buckets: Vec = (0..10) - .map(|_| G1Affine::from(::Projective::rand(&mut rng))) - .collect(); - let points: Vec = (0..10) - .map(|_| G1Affine::from(::Projective::rand(&mut rng))) - .collect(); - - let tmp = buckets.clone(); - batch_adder.batch_add_indexed(&mut buckets, &[0, 2, 4], &points, &[0, 2, 4]); - - for i in (0..5).step_by(2) { - assert_eq!(buckets[i], tmp[i].add(points[i])); - } - } - - #[test] - fn test_batch_add_indexed_single_bucket() { - let mut batch_adder = BatchAdder::new(1); - let mut rng = ark_std::test_rng(); - - let mut buckets: Vec = vec![G1Affine::from( - ::Projective::rand(&mut rng), - )]; - let points: Vec = vec![G1Affine::from( - ::Projective::rand(&mut rng), - )]; - - let tmp = buckets.clone(); - batch_adder.batch_add_indexed(&mut buckets, &[0], &points, &[0]); - - assert_eq!(buckets[0], tmp[0].add(points[0])); - } -} +// #[cfg(test)] +// mod batch_add_tests { +// use super::*; +// // use ark_bls12_381::G1Affine; +// use ark_ec::{AffineCurve, ProjectiveCurve}; +// use ark_std::UniformRand; +// use std::ops::Add; + +// #[test] +// fn test_phase_one_zero_or_neg() { +// let mut batch_adder = BatchAdder::new(4); +// batch_adder.batch_add_phase_one(&G1Affine::zero(), &G1Affine::zero(), 0); + +// let mut rng = ark_std::test_rng(); +// let p = ::Projective::rand(&mut rng); +// let p_affine = G1Affine::from(p); +// let mut neg_p_affine = p_affine; +// neg_p_affine.y = -neg_p_affine.y; + +// batch_adder.batch_add_phase_one(&p_affine, &neg_p_affine, 0); +// } + +// #[test] +// fn test_phase_one_p_add_p() { +// let mut batch_adder = BatchAdder::new(4); +// let mut rng = ark_std::test_rng(); +// let prj = ::Projective::rand(&mut rng); +// let p = G1Affine::from(prj); +// let acc = p; + +// batch_adder.batch_add_phase_one(&acc, &p, 0); +// assert!(batch_adder.inverses[0].is_one()); +// assert_eq!(batch_adder.inverse_state, p.y + p.y); +// } + +// #[test] +// fn test_phase_one_p_add_q() { +// let mut batch_adder = BatchAdder::new(4); +// let mut rng = ark_std::test_rng(); +// let p_prj = ::Projective::rand(&mut rng); +// let q_prj = ::Projective::rand(&mut rng); +// let p = G1Affine::from(p_prj); +// let q = G1Affine::from(q_prj); + +// batch_adder.batch_add_phase_one(&p, &q, 0); +// assert!(batch_adder.inverses[0].is_one()); +// assert_eq!(batch_adder.inverse_state, q.x - p.x); +// } + +// #[test] +// fn test_phase_one_p_add_q_twice() { +// let mut batch_adder = BatchAdder::new(4); +// let mut rng = ark_std::test_rng(); +// let p_prj = ::Projective::rand(&mut rng); +// let q_prj = ::Projective::rand(&mut rng); +// let p = G1Affine::from(p_prj); +// let q = G1Affine::from(q_prj); + +// batch_adder.batch_add_phase_one(&p, &q, 0); +// batch_adder.batch_add_phase_one(&p, &q, 0); +// assert_eq!(batch_adder.inverses[0], q.x - p.x); +// assert_eq!(batch_adder.inverse_state, (q.x - p.x) * (q.x - p.x)); +// } + +// #[test] +// fn test_phase_two_zero_add_p() { +// let mut batch_adder = BatchAdder::new(4); +// let mut rng = ark_std::test_rng(); +// let p_prj = ::Projective::rand(&mut rng); +// let p = G1Affine::from(p_prj); +// let mut acc = G1Affine::zero(); +// batch_adder.batch_add_phase_two(&mut acc, &p, 0); +// assert_eq!(acc, p); +// } + +// #[test] +// fn test_phase_two_p_add_neg() { +// let mut batch_adder = BatchAdder::new(4); + +// let mut rng = ark_std::test_rng(); +// let p_prj = ::Projective::rand(&mut rng); +// let mut acc = G1Affine::from(p_prj); +// let mut p = acc; +// p.y = -p.y; + +// batch_adder.batch_add_phase_two(&mut acc, &p, 0); +// assert_eq!(acc, G1Affine::zero()); +// } + +// #[test] +// fn test_phase_two_p_add_q() { +// let mut batch_adder = BatchAdder::new(4); + +// let mut rng = ark_std::test_rng(); +// let acc_prj = ::Projective::rand(&mut rng); +// let mut acc = G1Affine::from(acc_prj); +// let mut p = acc; +// p.x = p.x + p.x; + +// batch_adder.inverses[0] = (p.x - acc.x).inverse().unwrap(); +// batch_adder.batch_add_phase_two(&mut acc, &p, 0); +// assert_eq!(acc, G1Affine::from(acc_prj.add_mixed(&p))); +// } + +// #[test] +// fn test_phase_two_p_add_p() { +// let mut batch_adder = BatchAdder::new(4); + +// let mut rng = ark_std::test_rng(); +// let acc_prj = ::Projective::rand(&mut rng); +// let mut acc = G1Affine::from(acc_prj); +// let p = acc; + +// batch_adder.inverses[0] = (p.y + p.y).inverse().unwrap(); +// batch_adder.batch_add_phase_two(&mut acc, &p, 0); +// assert_eq!(acc, G1Affine::from(acc_prj).add(p)); +// } + +// #[test] +// fn test_batch_add() { +// let mut batch_adder = BatchAdder::new(10); + +// let mut rng = ark_std::test_rng(); +// let mut buckets: Vec = (0..10) +// .map(|_| G1Affine::from(::Projective::rand(&mut rng))) +// .collect(); +// let points: Vec = (0..10) +// .map(|_| G1Affine::from(::Projective::rand(&mut rng))) +// .collect(); + +// let tmp = buckets.clone(); +// batch_adder.batch_add(&mut buckets, &points); + +// for i in 0..10 { +// assert_eq!(buckets[i], tmp[i].add(points[i])); +// } +// } + +// #[test] +// fn test_batch_add_step_n() { +// let mut batch_adder = BatchAdder::new(10); + +// let mut rng = ark_std::test_rng(); +// let mut buckets: Vec = (0..10) +// .map(|_| G1Affine::from(::Projective::rand(&mut rng))) +// .collect(); +// let points: Vec = (0..10) +// .map(|_| G1Affine::from(::Projective::rand(&mut rng))) +// .collect(); + +// let tmp = buckets.clone(); +// batch_adder.batch_add_step_n(&mut buckets, 1, &points, 2, 3); + +// for i in 0..3 { +// assert_eq!(buckets[i], tmp[i].add(points[i * 2])); +// } +// } + +// #[test] +// fn test_batch_add_indexed() { +// let mut batch_adder = BatchAdder::new(10); +// let mut rng = ark_std::test_rng(); + +// let mut buckets: Vec = (0..10) +// .map(|_| G1Affine::from(::Projective::rand(&mut rng))) +// .collect(); +// let points: Vec = (0..10) +// .map(|_| G1Affine::from(::Projective::rand(&mut rng))) +// .collect(); + +// let tmp = buckets.clone(); +// batch_adder.batch_add_indexed(&mut buckets, &[0, 2, 4], &points, &[0, 2, 4]); + +// for i in (0..5).step_by(2) { +// assert_eq!(buckets[i], tmp[i].add(points[i])); +// } +// } + +// #[test] +// fn test_batch_add_indexed_single_bucket() { +// let mut batch_adder = BatchAdder::new(1); +// let mut rng = ark_std::test_rng(); + +// let mut buckets: Vec = vec![G1Affine::from( +// ::Projective::rand(&mut rng), +// )]; +// let points: Vec = vec![G1Affine::from( +// ::Projective::rand(&mut rng), +// )]; + +// let tmp = buckets.clone(); +// batch_adder.batch_add_indexed(&mut buckets, &[0], &points, &[0]); + +// assert_eq!(buckets[0], tmp[0].add(points[0])); +// } +// } diff --git a/src/bucket_msm.rs b/src/bucket_msm.rs index 310003f..9406844 100644 --- a/src/bucket_msm.rs +++ b/src/bucket_msm.rs @@ -1,17 +1,17 @@ -use ark_bls12_381::g1::Parameters as G1Parameters; -use ark_bls12_381::G1Affine; +// use ark_bls12_381::g1::Parameters as G1Parameters; +// use ark_bls12_381::G1Affine; use ark_ec::{ models::SWModelParameters as Parameters, short_weierstrass_jacobian::{GroupAffine, GroupProjective}, ProjectiveCurve, }; use ark_std::Zero; -use std::any::TypeId; +// use std::any::TypeId; use crate::{ batch_adder::BatchAdder, bitmap::Bitmap, - glv::endomorphism, + // glv::endomorphism, types::{GROUP_SIZE, GROUP_SIZE_IN_BITS}, }; @@ -64,89 +64,89 @@ impl BucketMSM

{ } } - pub fn process_point_and_slices_glv( - &mut self, - point: &GroupAffine

, - normal_slices: &[u32], - phi_slices: &[u32], - is_neg_scalar: bool, - is_neg_normal: bool, - ) { - assert_eq!( - TypeId::of::

(), - TypeId::of::(), - "glv is only supported for ark_bls12_381" - ); - assert!( - self.num_windows as usize == normal_slices.len() - && normal_slices.len() == phi_slices.len(), - "slice len check failed: normal_slices {}, phi_slices {}, num_windows {}", - normal_slices.len(), - phi_slices.len(), - self.num_windows - ); - - let mut p = *point; // copy - - if is_neg_scalar { - p.y = -p.y - }; - if is_neg_normal { - p.y = -p.y - }; - - self.cur_points.push(p); - for (win, normal_slice) in normal_slices.iter().enumerate() { - if (*normal_slice as i32) > 0 { - let bucket_id = (win << self.bucket_bits) as u32 + normal_slice - 1; - self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); - } - } - - p.y = -p.y; - - self.cur_points.push(p); - for (win, normal_slice) in normal_slices.iter().enumerate() { - if (*normal_slice as i32) < 0 { - let slice = normal_slice & 0x7FFFFFFF; - if slice > 0 { - let bucket_id = (win << self.bucket_bits) as u32 + slice - 1; - self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); - } - } - } - - // process phi slices - p.y = -p.y; - if is_neg_normal { - p.y = -p.y; - } - - // this isn't the cleanest of doing this, we'd better figure out a way to do this at compile time - let p_g1: &mut G1Affine = unsafe { &mut *(std::ptr::addr_of_mut!(p) as *mut G1Affine) }; - endomorphism(p_g1); - - self.cur_points.push(p); - for (win, phi_slice) in phi_slices.iter().enumerate() { - if (*phi_slice as i32) > 0 { - let bucket_id = (win << self.bucket_bits) as u32 + phi_slice - 1; - self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); - } - } - - p.y = -p.y; - - self.cur_points.push(p); - for (win, phi_slice) in phi_slices.iter().enumerate() { - if (*phi_slice as i32) < 0 { - let slice = phi_slice & 0x7FFFFFFF; - if slice > 0 { - let bucket_id = (win << self.bucket_bits) as u32 + slice - 1; - self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); - } - } - } - } + // pub fn process_point_and_slices_glv( + // &mut self, + // point: &GroupAffine

, + // normal_slices: &[u32], + // phi_slices: &[u32], + // is_neg_scalar: bool, + // is_neg_normal: bool, + // ) { + // assert_eq!( + // TypeId::of::

(), + // TypeId::of::(), + // "glv is only supported for ark_bls12_381" + // ); + // assert!( + // self.num_windows as usize == normal_slices.len() + // && normal_slices.len() == phi_slices.len(), + // "slice len check failed: normal_slices {}, phi_slices {}, num_windows {}", + // normal_slices.len(), + // phi_slices.len(), + // self.num_windows + // ); + + // let mut p = *point; // copy + + // if is_neg_scalar { + // p.y = -p.y + // }; + // if is_neg_normal { + // p.y = -p.y + // }; + + // self.cur_points.push(p); + // for (win, normal_slice) in normal_slices.iter().enumerate() { + // if (*normal_slice as i32) > 0 { + // let bucket_id = (win << self.bucket_bits) as u32 + normal_slice - 1; + // self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); + // } + // } + + // p.y = -p.y; + + // self.cur_points.push(p); + // for (win, normal_slice) in normal_slices.iter().enumerate() { + // if (*normal_slice as i32) < 0 { + // let slice = normal_slice & 0x7FFFFFFF; + // if slice > 0 { + // let bucket_id = (win << self.bucket_bits) as u32 + slice - 1; + // self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); + // } + // } + // } + + // // process phi slices + // p.y = -p.y; + // if is_neg_normal { + // p.y = -p.y; + // } + + // // this isn't the cleanest of doing this, we'd better figure out a way to do this at compile time + // let p_g1: &mut G1Affine = unsafe { &mut *(std::ptr::addr_of_mut!(p) as *mut G1Affine) }; + // endomorphism(p_g1); + + // self.cur_points.push(p); + // for (win, phi_slice) in phi_slices.iter().enumerate() { + // if (*phi_slice as i32) > 0 { + // let bucket_id = (win << self.bucket_bits) as u32 + phi_slice - 1; + // self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); + // } + // } + + // p.y = -p.y; + + // self.cur_points.push(p); + // for (win, phi_slice) in phi_slices.iter().enumerate() { + // if (*phi_slice as i32) < 0 { + // let slice = phi_slice & 0x7FFFFFFF; + // if slice > 0 { + // let bucket_id = (win << self.bucket_bits) as u32 + slice - 1; + // self._process_slices(bucket_id, self.cur_points.len() as u32 - 1); + // } + // } + // } + // } pub fn process_point_and_slices(&mut self, point: &GroupAffine

, slices: &[u32]) { assert!( @@ -377,27 +377,27 @@ mod bucket_msm_tests { assert_eq!(bucket_msm.buckets[4 + (2 << bucket_msm.bucket_bits)], r); } - #[test] - fn test_process_point_and_slices_glv_deal_two_points() { - let window_bits = 15u32; - let mut bucket_msm = BucketMSM::new(30u32, window_bits, 128u32, 4096u32); - let mut rng = ark_std::test_rng(); - let p_prj = G1Projective::rand(&mut rng); - let q_prj = G1Projective::rand(&mut rng); - let mut p = G1Affine::from(p_prj); - let mut q = G1Affine::from(q_prj); - - bucket_msm.process_point_and_slices_glv(&p, &[1u32, 3u32], &[4u32, 6u32], false, false); - bucket_msm.process_point_and_slices_glv(&q, &[2u32, 3u32], &[5u32, 6u32], false, false); - bucket_msm.process_complete(); - assert_eq!(bucket_msm.buckets[0], p); - assert_eq!(bucket_msm.buckets[1], q); - assert_eq!(bucket_msm.buckets[2 + (1 << bucket_msm.bucket_bits)], p + q); - - endomorphism(&mut p); - endomorphism(&mut q); - assert_eq!(bucket_msm.buckets[3], p); - assert_eq!(bucket_msm.buckets[4], q); - assert_eq!(bucket_msm.buckets[5 + (1 << bucket_msm.bucket_bits)], p + q); - } + // #[test] + // fn test_process_point_and_slices_glv_deal_two_points() { + // let window_bits = 15u32; + // let mut bucket_msm = BucketMSM::new(30u32, window_bits, 128u32, 4096u32); + // let mut rng = ark_std::test_rng(); + // let p_prj = G1Projective::rand(&mut rng); + // let q_prj = G1Projective::rand(&mut rng); + // let mut p = G1Affine::from(p_prj); + // let mut q = G1Affine::from(q_prj); + + // bucket_msm.process_point_and_slices_glv(&p, &[1u32, 3u32], &[4u32, 6u32], false, false); + // bucket_msm.process_point_and_slices_glv(&q, &[2u32, 3u32], &[5u32, 6u32], false, false); + // bucket_msm.process_complete(); + // assert_eq!(bucket_msm.buckets[0], p); + // assert_eq!(bucket_msm.buckets[1], q); + // assert_eq!(bucket_msm.buckets[2 + (1 << bucket_msm.bucket_bits)], p + q); + + // endomorphism(&mut p); + // endomorphism(&mut q); + // assert_eq!(bucket_msm.buckets[3], p); + // assert_eq!(bucket_msm.buckets[4], q); + // assert_eq!(bucket_msm.buckets[5 + (1 << bucket_msm.bucket_bits)], p + q); + // } } diff --git a/src/lib.rs b/src/lib.rs index 5f6142f..c142970 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,5 @@ pub mod bitmap; -pub mod glv; +// pub mod glv; pub mod msm; pub mod types; pub mod utils; diff --git a/src/msm.rs b/src/msm.rs index 25c7e8c..d3711e9 100644 --- a/src/msm.rs +++ b/src/msm.rs @@ -1,9 +1,9 @@ use crate::{ bucket_msm::BucketMSM, - glv::decompose, - types::{BigInt, G1BigInt, G1_SCALAR_SIZE_GLV, GROUP_SIZE_IN_BITS}, + // glv::decompose, + types::{BigInt, G1_SCALAR_SIZE_GLV, GROUP_SIZE_IN_BITS}, }; -use ark_bls12_381::{g1::Parameters as G1Parameters, Fr}; +// use ark_bls12_381::{g1::Parameters as G1Parameters, Fr}; use ark_ec::{ models::SWModelParameters as Parameters, short_weierstrass_jacobian::{GroupAffine, GroupProjective}, @@ -37,7 +37,7 @@ impl VariableBaseMSM { let total = 1 << window_bits; let half = total >> 1; slices.iter_mut().for_each(|el| { - *el = (scalar.as_ref()[0] % (1 << window_bits)) as u32; + *el = (scalar.to_64x4()[0] % (1 << window_bits)) as u32; scalar.divn(window_bits); *el += carry; @@ -56,55 +56,55 @@ impl VariableBaseMSM { ); } - fn multi_scalar_mul_g1_glv( - points: &[GroupAffine

], - scalars: &[BigInt

], - window_bits: u32, - max_batch: u32, - max_collisions: u32, - ) -> GroupProjective

{ - let num_slices: usize = ((G1_SCALAR_SIZE_GLV + window_bits - 1) / window_bits) as usize; - let mut bucket_msm = - BucketMSM::

::new(G1_SCALAR_SIZE_GLV, window_bits, max_batch, max_collisions); - // scalar = phi * lambda + normal - let mut phi_slices = vec![0u32; num_slices]; - let mut normal_slices = vec![0u32; num_slices]; - - scalars - .iter() - .zip(points) - .filter(|(s, _)| !s.is_zero()) - .for_each(|(&scalar, point)| { - // TODO - // use unsafe cast for type conversion until we have a better approach - let g1_scalar: G1BigInt = - unsafe { *(std::ptr::addr_of!(scalar) as *const G1BigInt) }; - - let (phi, normal, is_neg_scalar, is_neg_normal) = - decompose(&Fr::from(g1_scalar), window_bits); - - Self::msm_slice::( - phi.into(), - &mut phi_slices[..num_slices], - window_bits, - ); - Self::msm_slice::( - normal.into(), - &mut normal_slices[..num_slices], - window_bits, - ); - bucket_msm.process_point_and_slices_glv( - point, - &normal_slices[..num_slices], - &phi_slices[..num_slices], - is_neg_scalar, - is_neg_normal, - ); - }); - - bucket_msm.process_complete(); - bucket_msm.batch_reduce() - } + // fn multi_scalar_mul_g1_glv( + // points: &[GroupAffine

], + // scalars: &[BigInt

], + // window_bits: u32, + // max_batch: u32, + // max_collisions: u32, + // ) -> GroupProjective

{ + // let num_slices: usize = ((G1_SCALAR_SIZE_GLV + window_bits - 1) / window_bits) as usize; + // let mut bucket_msm = + // BucketMSM::

::new(G1_SCALAR_SIZE_GLV, window_bits, max_batch, max_collisions); + // // scalar = phi * lambda + normal + // let mut phi_slices = vec![0u32; num_slices]; + // let mut normal_slices = vec![0u32; num_slices]; + + // scalars + // .iter() + // .zip(points) + // .filter(|(s, _)| !s.is_zero()) + // .for_each(|(&scalar, point)| { + // // TODO + // // use unsafe cast for type conversion until we have a better approach + // let g1_scalar: G1BigInt = + // unsafe { *(std::ptr::addr_of!(scalar) as *const G1BigInt) }; + + // let (phi, normal, is_neg_scalar, is_neg_normal) = + // decompose(&Fr::from(g1_scalar), window_bits); + + // Self::msm_slice::( + // phi.into(), + // &mut phi_slices[..num_slices], + // window_bits, + // ); + // Self::msm_slice::( + // normal.into(), + // &mut normal_slices[..num_slices], + // window_bits, + // ); + // bucket_msm.process_point_and_slices_glv( + // point, + // &normal_slices[..num_slices], + // &phi_slices[..num_slices], + // is_neg_scalar, + // is_neg_normal, + // ); + // }); + + // bucket_msm.process_complete(); + // bucket_msm.batch_reduce() + // } fn multi_scalar_mul_general( points: &[GroupAffine

], @@ -144,15 +144,15 @@ impl VariableBaseMSM { window_bits as usize > GROUP_SIZE_IN_BITS, "Window_bits must be greater than the default log(group size)" ); - if glv_enabled { - assert!( - TypeId::of::

() == TypeId::of::(), - "Glv is only supported for bls12-381 curve!" - ); - Self::multi_scalar_mul_g1_glv(points, scalars, window_bits, max_batch, max_collisions) - } else { + // if glv_enabled { + // assert!( + // TypeId::of::

() == TypeId::of::(), + // "Glv is only supported for bls12-381 curve!" + // ); + // Self::multi_scalar_mul_g1_glv(points, scalars, window_bits, max_batch, max_collisions) + // } else { Self::multi_scalar_mul_general(points, scalars, window_bits, max_batch, max_collisions) - } + // } } pub fn multi_scalar_mul( @@ -164,40 +164,40 @@ impl VariableBaseMSM { } } -#[cfg(test)] -mod collision_method_pippenger_tests { - use super::*; - use ark_bls12_381::g1::Parameters; - - #[test] - fn test_msm_slice_window_size_1() { - let scalar = G1BigInt::from(0b101); - let mut slices: Vec = vec![0; 3]; - VariableBaseMSM::msm_slice::(scalar, &mut slices, 1); - // print!("slices {:?}\n", slices); - assert!(slices.iter().eq([1, 0, 1].iter())); - } - #[test] - fn test_msm_slice_window_size_2() { - let scalar = G1BigInt::from(0b000110); - let mut slices: Vec = vec![0; 3]; - VariableBaseMSM::msm_slice::(scalar, &mut slices, 2); - assert!(slices.iter().eq([2, 1, 0].iter())); - } - - #[test] - fn test_msm_slice_window_size_3() { - let scalar = G1BigInt::from(0b010111000); - let mut slices: Vec = vec![0; 3]; - VariableBaseMSM::msm_slice::(scalar, &mut slices, 3); - assert!(slices.iter().eq([0, 0x80000001, 3].iter())); - } - - #[test] - fn test_msm_slice_window_size_16() { - let scalar = G1BigInt::from(0x123400007FFF); - let mut slices: Vec = vec![0; 3]; - VariableBaseMSM::msm_slice::(scalar, &mut slices, 16); - assert!(slices.iter().eq([0x7FFF, 0, 0x1234].iter())); - } -} +// #[cfg(test)] +// mod collision_method_pippenger_tests { +// use super::*; +// use ark_bls12_381::g1::Parameters; + +// #[test] +// fn test_msm_slice_window_size_1() { +// let scalar = G1BigInt::from(0b101); +// let mut slices: Vec = vec![0; 3]; +// VariableBaseMSM::msm_slice::(scalar, &mut slices, 1); +// // print!("slices {:?}\n", slices); +// assert!(slices.iter().eq([1, 0, 1].iter())); +// } +// #[test] +// fn test_msm_slice_window_size_2() { +// let scalar = G1BigInt::from(0b000110); +// let mut slices: Vec = vec![0; 3]; +// VariableBaseMSM::msm_slice::(scalar, &mut slices, 2); +// assert!(slices.iter().eq([2, 1, 0].iter())); +// } + +// #[test] +// fn test_msm_slice_window_size_3() { +// let scalar = G1BigInt::from(0b010111000); +// let mut slices: Vec = vec![0; 3]; +// VariableBaseMSM::msm_slice::(scalar, &mut slices, 3); +// assert!(slices.iter().eq([0, 0x80000001, 3].iter())); +// } + +// #[test] +// fn test_msm_slice_window_size_16() { +// let scalar = G1BigInt::from(0x123400007FFF); +// let mut slices: Vec = vec![0; 3]; +// VariableBaseMSM::msm_slice::(scalar, &mut slices, 16); +// assert!(slices.iter().eq([0x7FFF, 0, 0x1234].iter())); +// } +// } diff --git a/src/types.rs b/src/types.rs index 901a68e..10ebd74 100644 --- a/src/types.rs +++ b/src/types.rs @@ -1,16 +1,16 @@ -use ark_bls12_381::G1Affine; +// use ark_bls12_381::G1Affine; use ark_ec::{models::ModelParameters, AffineCurve}; use ark_ff::{FpParameters, PrimeField}; -pub const G1_SCALAR_SIZE: u32 = - <<::ScalarField as PrimeField>::Params as FpParameters>::MODULUS_BITS; +// pub const G1_SCALAR_SIZE: u32 = +// <<::ScalarField as PrimeField>::Params as FpParameters>::MODULUS_BITS; pub const G1_SCALAR_SIZE_GLV: u32 = 128u32; pub const GROUP_SIZE_IN_BITS: usize = 6; pub const GROUP_SIZE: usize = 1 << GROUP_SIZE_IN_BITS; -pub type G1BigInt = <::ScalarField as PrimeField>::BigInt; -pub type G1Projective = ::Projective; -pub type G1ScalarField = ::ScalarField; -pub type G1BaseField = ::BaseField; +// pub type G1BigInt = <::ScalarField as PrimeField>::BigInt; +// pub type G1Projective = ::Projective; +// pub type G1ScalarField = ::ScalarField; +// pub type G1BaseField = ::BaseField; pub type BigInt

= <

::ScalarField as PrimeField>::BigInt; diff --git a/tests/glv_tests.rs b/tests/glv_tests.rs index d9c09b9..4a09e30 100644 --- a/tests/glv_tests.rs +++ b/tests/glv_tests.rs @@ -1,71 +1,72 @@ -#[cfg(test)] -mod glv_tests { - use ark_bls12_381::{Fr, G1Affine}; - use ark_ec::AffineCurve; - use ark_ff::{BigInteger256, PrimeField, UniformRand}; - use ark_msm::{glv::*, types::G1ScalarField}; - use num_bigint::BigUint; +// #[cfg(test)] +// mod glv_tests { +// use ark_bls12_381::{Fr, G1Affine}; +// use ark_ec::AffineCurve; +// use ark_ff::{BigInteger256, PrimeField, UniformRand}; +// use ark_msm::types::G1ScalarField; +// // use ark_msm::{glv::*, types::G1ScalarField}; +// use num_bigint::BigUint; - #[test] - fn test_decompose_1() { - let s: G1ScalarField = Fr::from(1); - let (q, r, _, _) = decompose(&s, 16); +// #[test] +// fn test_decompose_1() { +// let s: G1ScalarField = Fr::from(1); +// let (q, r, _, _) = decompose(&s, 16); - assert_eq!(q, Fr::from(0)); - assert_eq!(r, Fr::from(1)); - } +// assert_eq!(q, Fr::from(0)); +// assert_eq!(r, Fr::from(1)); +// } - #[test] - fn test_decompose_lambda_plus_1() { - let s: G1ScalarField = Fr::from(BigInteger256([ - 0x0000000100000000, - 0xac45a4010001a402, - 0x0000000000000000, - 0x0000000000000000, - ])); - let (q, r, _, _) = decompose(&s, 16); +// #[test] +// fn test_decompose_lambda_plus_1() { +// let s: G1ScalarField = Fr::from(BigInteger256([ +// 0x0000000100000000, +// 0xac45a4010001a402, +// 0x0000000000000000, +// 0x0000000000000000, +// ])); +// let (q, r, _, _) = decompose(&s, 16); - assert_eq!(q, Fr::from(1)); - assert_eq!(r, Fr::from(1)); - } +// assert_eq!(q, Fr::from(1)); +// assert_eq!(r, Fr::from(1)); +// } - #[test] - fn test_decompose_random() { - let mut rng = ark_std::test_rng(); - let s = Fr::rand(&mut rng); - let (q, r, _, _) = decompose(&s, 16); +// #[test] +// fn test_decompose_random() { +// let mut rng = ark_std::test_rng(); +// let s = Fr::rand(&mut rng); +// let (q, r, _, _) = decompose(&s, 16); - let lambda: u128 = 0xac45a4010001a40200000000ffffffff; - let mut ss: BigUint = s.into(); - let modulus: BigUint = BigUint::parse_bytes( - b"73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", - 16, - ) - .unwrap(); - if s.into_repr().as_ref()[3] >= 0x3FFFFFFFF { - ss = modulus - ss; - } - let quotient = ss.clone() / lambda; - let remainder = ss - quotient.clone() * lambda; - assert_eq!(q, Fr::from(quotient)); - assert_eq!(r, Fr::from(remainder)); - } +// let lambda: u128 = 0xac45a4010001a40200000000ffffffff; +// let mut ss: BigUint = s.into(); +// let modulus: BigUint = BigUint::parse_bytes( +// b"73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", +// 16, +// ) +// .unwrap(); +// if s.into_repr().as_ref()[3] >= 0x3FFFFFFFF { +// ss = modulus - ss; +// } +// let quotient = ss.clone() / lambda; +// let remainder = ss - quotient.clone() * lambda; +// assert_eq!(q, Fr::from(quotient)); +// assert_eq!(r, Fr::from(remainder)); +// } - #[test] - fn test_endo() { - let mut rng = ark_std::test_rng(); - let lambda: G1ScalarField = Fr::from(BigInteger256([ - 0x00000000ffffffff, - 0xac45a4010001a402, - 0x0000000000000000, - 0x0000000000000000, - ])); - let p = G1Affine::from(::Projective::rand(&mut rng)); +// #[test] +// fn test_endo() { +// let mut rng = ark_std::test_rng(); +// let lambda: G1ScalarField = Fr::from(BigInteger256([ +// 0x00000000ffffffff, +// 0xac45a4010001a402, +// 0x0000000000000000, +// 0x0000000000000000, +// ])); +// let p = G1Affine::from(::Projective::rand(&mut rng)); - let mut endo_p = p; - endomorphism(&mut endo_p); +// let mut endo_p = p; +// endomorphism(&mut endo_p); - let lambda_p = G1Affine::from(p.mul(lambda)); - assert_eq!(lambda_p, endo_p); - } -} +// let lambda_p = G1Affine::from(p.mul(lambda)); +// assert_eq!(lambda_p, endo_p); +// } +// }