DO NOT MERGE: GLV Implementation

CHANGELOG.md

@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 ### Added
+- [\#211](https://github.com/Manta-Network/manta-rs/pull/211) GLV scalar multiplication implementation
+- [\#286](https://github.com/Manta-Network/manta-rs/pull/286) MantaPay v1.0.0
 
 ### Changed
 - [\#293](https://github.com/Manta-Network/manta-rs/pull/293) Add decimals argument to AssetMetadata display
@@ -30,7 +32,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 ## [0.5.7] - 2022-11-04
 ### Added
 - [\#262](https://github.com/Manta-Network/manta-rs/pull/262) Added exporting seed phrase and multiple networks support for signer.
-- [#276](https://github.com/Manta-Network/manta-rs/pull/276) New circuits part 1: manta-crypto abstractions
+- [\#276](https://github.com/Manta-Network/manta-rs/pull/276) New circuits part 1: manta-crypto abstractions
 
 ### Changed
 - [\#274](https://github.com/Manta-Network/manta-rs/pull/274) Update TS client installer script to use release 0.5.6.

manta-benchmark/Cargo.toml

@@ -44,6 +44,7 @@ name = "to_public"
 harness = false
 
 [dependencies]
+criterion = { version = "0.3.4", default-features = false }
 getrandom = { version = "0.2.8", default-features = false, features = ["js"] }
 instant = { version = "0.1.12", default-features = false, features = [ "wasm-bindgen" ] }
 manta-accounting = { path = "../manta-accounting", default-features = false, features = ["test"] }

manta-benchmark/benches/ecc.rs

@@ -18,17 +18,17 @@
 
 use core::iter::repeat_with;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use manta_benchmark::ecc;
+use manta_benchmark::{ecc, glv::GLVMutiplicationSetup, Benchmark};
 use manta_crypto::{
-    arkworks::bls12_381::{G1Affine, G1Projective},
+    arkworks::bls12_381::{G1Affine as BLSAffine, G1Projective as BLSProjective},
     rand::OsRng,
 };
 
 #[inline]
 fn affine_affine_addition(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let mut lhs = black_box(ecc::sample_affine_point::<G1Affine, _>(&mut rng));
+    let mut lhs = black_box(ecc::sample_affine_point::<BLSAffine, _>(&mut rng));
     let rhs = black_box(ecc::sample_affine_point(&mut rng));
     group.bench_function("affine-affine addition", |b| {
         b.iter(|| {
@@ -41,7 +41,7 @@ fn affine_affine_addition(c: &mut Criterion) {
 fn projective_affine_addition(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let mut lhs = black_box(ecc::sample_projective_point::<G1Projective, _>(&mut rng));
+    let mut lhs = black_box(ecc::sample_projective_point::<BLSProjective, _>(&mut rng));
     let rhs = black_box(ecc::sample_affine_point(&mut rng));
     group.bench_function("projective-affine addition", |b| {
         b.iter(|| {
@@ -54,8 +54,8 @@ fn projective_affine_addition(c: &mut Criterion) {
 fn projective_projective_addition(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let mut lhs = black_box(ecc::sample_projective_point::<G1Projective, _>(&mut rng));
-    let rhs = black_box(ecc::sample_projective_point::<G1Projective, _>(&mut rng));
+    let mut lhs = black_box(ecc::sample_projective_point::<BLSProjective, _>(&mut rng));
+    let rhs = black_box(ecc::sample_projective_point::<BLSProjective, _>(&mut rng));
     group.bench_function("projective-projective addition", |b| {
         b.iter(|| {
             let _ = black_box(ecc::projective_projective_add_assign(&mut lhs, rhs));
@@ -67,8 +67,8 @@ fn projective_projective_addition(c: &mut Criterion) {
 fn affine_scalar_multiplication(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let point = black_box(ecc::sample_affine_point::<G1Affine, _>(&mut rng));
-    let scalar = black_box(ecc::sample_scalar::<G1Affine, _>(&mut rng));
+    let point = black_box(ecc::sample_affine_point::<BLSAffine, _>(&mut rng));
+    let scalar = black_box(ecc::sample_scalar::<BLSAffine, _>(&mut rng));
     group.bench_function("affine-scalar multiplication", |b| {
         b.iter(|| {
             let _ = black_box(ecc::affine_scalar_mul(&point, scalar));
@@ -80,8 +80,8 @@ fn affine_scalar_multiplication(c: &mut Criterion) {
 fn projective_scalar_multiplication(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let mut point = black_box(ecc::sample_projective_point::<G1Projective, _>(&mut rng));
-    let scalar = black_box(ecc::sample_scalar::<G1Affine, _>(&mut rng));
+    let mut point = black_box(ecc::sample_projective_point::<BLSProjective, _>(&mut rng));
+    let scalar = black_box(ecc::sample_scalar::<BLSAffine, _>(&mut rng));
     group.bench_function("projective-scalar multiplication", |b| {
         b.iter(|| {
             let _ = black_box(ecc::projective_scalar_mul_assign(&mut point, scalar));
@@ -93,7 +93,7 @@ fn projective_scalar_multiplication(c: &mut Criterion) {
 fn projective_to_affine_normalization(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let point = black_box(ecc::sample_projective_point::<G1Projective, _>(&mut rng));
+    let point = black_box(ecc::sample_projective_point::<BLSProjective, _>(&mut rng));
     group.bench_function("projective to affine normalization", |b| {
         b.iter(|| {
             let _ = black_box(ecc::projective_to_affine_normalization(&point));
@@ -105,7 +105,7 @@ fn projective_to_affine_normalization(c: &mut Criterion) {
 fn batch_vector_projective_to_affine_normalization(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let points = repeat_with(|| ecc::sample_projective_point::<G1Projective, _>(&mut rng))
+    let points = repeat_with(|| ecc::sample_projective_point::<BLSProjective, _>(&mut rng))
         .take(1 << 16)
         .collect::<Vec<_>>();
     let points_slice = black_box(points.as_slice());
@@ -122,7 +122,7 @@ fn batch_vector_projective_to_affine_normalization(c: &mut Criterion) {
 fn naive_vector_projective_to_affine_normalization(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench");
     let mut rng = OsRng;
-    let points = repeat_with(|| ecc::sample_projective_point::<G1Projective, _>(&mut rng))
+    let points = repeat_with(|| ecc::sample_projective_point::<BLSProjective, _>(&mut rng))
         .take(1 << 16)
         .collect::<Vec<_>>();
     let points_slice = black_box(points.as_slice());
@@ -135,6 +135,12 @@ fn naive_vector_projective_to_affine_normalization(c: &mut Criterion) {
     });
 }
 
+#[inline]
+fn glv_scalar_multiplication(c: &mut Criterion) {
+    black_box(GLVMutiplicationSetup::<BLSAffine, _>::setup(&mut OsRng, ()))
+        .define_benchmark(&mut c.benchmark_group("bench"));
+}
+
 criterion_group!(
     ecc,
     affine_affine_addition,
@@ -145,5 +151,6 @@ criterion_group!(
     projective_to_affine_normalization,
     batch_vector_projective_to_affine_normalization,
     naive_vector_projective_to_affine_normalization,
+    glv_scalar_multiplication,
 );
 criterion_main!(ecc);

manta-benchmark/src/glv.rs

@@ -0,0 +1,76 @@
+// Copyright 2019-2022 Manta Network.
+// This file is part of manta-rs.
+//
+// manta-rs is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// manta-rs is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Benchmark trait
+
+use crate::Benchmark;
+use core::marker::PhantomData;
+use criterion::black_box;
+use manta_crypto::{
+    arkworks::{
+        ec::{AffineCurveExt, ProjectiveCurve},
+        ff::UniformRand,
+        glv::{GLVParameters, HasGLV},
+    },
+    rand::RngCore,
+};
+
+/// GLV Multiplication Setup
+pub struct GLVMutiplicationSetup<C, M>
+where
+    C: AffineCurveExt + HasGLV<M>,
+{
+    /// GLV Parameters
+    glv_parameters: GLVParameters<C>,
+
+    /// Scalar
+    scalar: C::ScalarField,
+
+    /// Curve Point
+    point: C,
+
+    /// Type Parameter Marker
+    __: PhantomData<M>,
+}
+
+impl<C, M> Benchmark for GLVMutiplicationSetup<C, M>
+where
+    C: AffineCurveExt + HasGLV<M>,
+{
+    const NAME: &'static str = "GLV scalar multiplication";
+
+    type Parameters = ();
+    type Output = C;
+
+    #[inline]
+    fn setup<R>(rng: &mut R, (): Self::Parameters) -> Self
+    where
+        R: RngCore + ?Sized,
+    {
+        Self {
+            glv_parameters: C::glv_parameters(),
+            scalar: C::ScalarField::rand(rng),
+            point: C::Projective::rand(rng).into_affine(),
+            __: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn benchmark(&self) -> Self::Output {
+        self.glv_parameters
+            .scalar_mul(&black_box(self.point), &black_box(self.scalar))
+    }
+}

manta-crypto/Cargo.toml

@@ -53,8 +53,6 @@ serde = [
 
 # Standard Library
 std = [
-    "ark-bls12-381?/std",
-    "ark-bn254?/std",
     "ark-ec?/std",
     "ark-ed-on-bls12-381?/std",
     "ark-ed-on-bn254?/std",
@@ -88,6 +86,7 @@ ark-std = { version = "0.3.0", optional = true, default-features = false }
 derivative = { version = "2.2.0", default-features = false, features = ["use_core"] }
 ed25519-dalek = { version = "1.0.1", optional = true, default-features = false, features = ["u64_backend"] }
 manta-util = { path = "../manta-util", default-features = false, features = ["alloc"] }
+num-bigint = { version = "0.4.3", optional = true, default-features = false }
 num-integer = { version = "0.1.45", optional = true, default-features = false } 
 rand = { version = "0.8.4", optional = true, default-features = false, features = ["alloc"] }
 rand_chacha = { version = "0.3.1", optional = true, default-features = false }

manta-crypto/src/arkworks/ec.rs

@@ -0,0 +1,72 @@
+// Copyright 2019-2022 Manta Network.
+// This file is part of manta-rs.
+//
+// manta-rs is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// manta-rs is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Arkworks Elliptic Curves Backend
+
+#[doc(inline)]
+pub use ark_ec::*;
+
+/// Affine Curve Extension
+pub trait AffineCurveExt: AffineCurve {
+    /// Returns the `x` coordinate of `self`.
+    fn x(&self) -> &Self::BaseField;
+
+    /// Returns the `y` coordinate of `self`.
+    fn y(&self) -> &Self::BaseField;
+
+    /// Builds [`Self`] from `x` and `y`.
+    fn from_xy_unchecked(x: Self::BaseField, y: Self::BaseField) -> Self;
+}
+
+impl<P> AffineCurveExt for short_weierstrass_jacobian::GroupAffine<P>
+where
+    P: SWModelParameters,
+{
+    #[inline]
+    fn x(&self) -> &Self::BaseField {
+        &self.x
+    }
+
+    #[inline]
+    fn y(&self) -> &Self::BaseField {
+        &self.y
+    }
+
+    #[inline]
+    fn from_xy_unchecked(x: Self::BaseField, y: Self::BaseField) -> Self {
+        Self::new(x, y, false)
+    }
+}
+
+impl<P> AffineCurveExt for twisted_edwards_extended::GroupAffine<P>
+where
+    P: TEModelParameters,
+{
+    #[inline]
+    fn x(&self) -> &Self::BaseField {
+        &self.x
+    }
+
+    #[inline]
+    fn y(&self) -> &Self::BaseField {
+        &self.y
+    }
+
+    #[inline]
+    fn from_xy_unchecked(x: Self::BaseField, y: Self::BaseField) -> Self {
+        Self::new(x, y)
+    }
+}