Bn254 Backend for Perpetual Powers of Tau

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - [\#213](https://github.com/Manta-Network/manta-rs/pull/197) Add Ceremony Utilities
 - [\#206](https://github.com/Manta-Network/manta-rs/pull/206) Move Poseidon sage script to test the hardcoded round constant values. 
 - [\#172](https://github.com/Manta-Network/manta-rs/pull/172) Add abstract Phase 2 for Groth16 trusted setup 
+- [\#193](https://github.com/Manta-Network/manta-rs/pull/193) Add Bn254 curve backend for Groth16 trusted setup
 - [\#196](https://github.com/Manta-Network/manta-rs/pull/172) Add fixed base scalar multiplication using precomputed bases
 - [\#197](https://github.com/Manta-Network/manta-rs/pull/197) Add ECLAIR utilities for next circuit upgrade
 

manta-parameters/data.checkfile

@@ -8,3 +8,4 @@ eb5c880bdf3c998a9a081f0259fd536e07f4bb71095bcef5664326bcb1ad6428  data/pay/testn
 5719387f9625828f46835a8375656578e028d8fc6da6822b765f47e296c0aaac  data/pay/testnet/verifying/mint.dat
 29a8229b59490223372c1f2b918f10d806be64ac4ffa5695dbdfe97b4b52e404  data/pay/testnet/verifying/private-transfer.dat
 bbe115020d563d63d404437c38741f0d527ab0441b4aaf4de463d9e9452dee09  data/pay/testnet/verifying/reclaim.dat
+25d2368d77dc834774504ca9b001fd4b5926c24c51e87f8e208db5fe40040075  data/ppot/round72powers19.lfs

manta-parameters/src/lib.rs

@@ -212,6 +212,15 @@ macro_rules! define_lfs {
     };
 }
 
+/// Perpetual Powers of Tau Accumulators
+pub mod ppot {
+    define_lfs!(
+        Round72Powers19,
+        "Accumulator with 1 << 19 powers, Bn",
+        "/data/ppot/round72powers19",
+    );
+}
+
 /// Concrete Parameters for Manta Pay
 pub mod pay {
     /// Testnet Data

manta-pay/src/crypto/constraint/arkworks/pairing.rs

@@ -16,162 +16,183 @@
 
 //! Pairing Engine Utilities
 
-/// BLS-12 Utilities
-pub mod bls12 {
-    use crate::crypto::constraint::arkworks::codec::{HasDeserialization, HasSerialization};
-    use alloc::vec::Vec;
-    use manta_crypto::arkworks::{
-        ec::models::bls12::{g2, Bls12Parameters},
-        ff::Fp2,
-        serialize::{CanonicalDeserialize, CanonicalSerialize, Read, SerializationError, Write},
-    };
+/// Generates the `G2Prepared` and `G2PreparedRef` structures for serialization compatibility
+/// with arkworks canonical serialization.
+macro_rules! pairing_impl {
+    ($params:ident) => {
+        /// Line Evaluation Coefficients
+        pub type EllCoeff<F> = (F, F, F);
+
+        /// G2 Prepared Point
+        #[derive(derivative::Derivative, CanonicalSerialize, CanonicalDeserialize)]
+        #[derivative(Clone, Default, Debug, Eq, PartialEq)]
+        pub struct G2Prepared<P>
+        where
+            P: $params,
+        {
+            /// Coefficients
+            pub ell_coeffs: Vec<EllCoeff<Fp2<P::Fp2Params>>>,
 
-    /// Line Evaluation Coefficients
-    pub type EllCoeff<F> = (F, F, F);
-
-    /// G2 Prepared Point
-    #[derive(derivative::Derivative, CanonicalSerialize, CanonicalDeserialize)]
-    #[derivative(Clone, Default, Debug, Eq, PartialEq)]
-    pub struct G2Prepared<P>
-    where
-        P: Bls12Parameters,
-    {
-        /// Coefficients
-        pub ell_coeffs: Vec<EllCoeff<Fp2<P::Fp2Params>>>,
-
-        /// Infinity Flag
-        pub infinity: bool,
-    }
-
-    impl<P> From<g2::G2Prepared<P>> for G2Prepared<P>
-    where
-        P: Bls12Parameters,
-    {
-        #[inline]
-        fn from(point: g2::G2Prepared<P>) -> Self {
-            Self {
-                ell_coeffs: point.ell_coeffs,
-                infinity: point.infinity,
-            }
+            /// Infinity Flag
+            pub infinity: bool,
         }
-    }
-
-    impl<P> From<G2Prepared<P>> for g2::G2Prepared<P>
-    where
-        P: Bls12Parameters,
-    {
-        #[inline]
-        fn from(point: G2Prepared<P>) -> Self {
-            Self {
-                ell_coeffs: point.ell_coeffs,
-                infinity: point.infinity,
+
+        impl<P> From<g2::G2Prepared<P>> for G2Prepared<P>
+        where
+            P: $params,
+        {
+            #[inline]
+            fn from(point: g2::G2Prepared<P>) -> Self {
+                Self {
+                    ell_coeffs: point.ell_coeffs,
+                    infinity: point.infinity,
+                }
             }
         }
-    }
-
-    /// G2 Prepared Point Reference
-    #[derive(derivative::Derivative)]
-    #[derivative(Debug, Eq, PartialEq)]
-    pub struct G2PreparedRef<'p, P>(pub &'p g2::G2Prepared<P>)
-    where
-        P: Bls12Parameters;
-
-    impl<'p, P> CanonicalSerialize for G2PreparedRef<'p, P>
-    where
-        P: Bls12Parameters,
-    {
-        #[inline]
-        fn serialize<W>(&self, mut writer: W) -> Result<(), SerializationError>
+
+        impl<P> From<G2Prepared<P>> for g2::G2Prepared<P>
         where
-            W: Write,
+            P: $params,
         {
-            let g2::G2Prepared {
-                ell_coeffs,
-                infinity,
-            } = &self.0;
-            ell_coeffs.serialize(&mut writer)?;
-            infinity.serialize(&mut writer)?;
-            Ok(())
+            #[inline]
+            fn from(point: G2Prepared<P>) -> Self {
+                Self {
+                    ell_coeffs: point.ell_coeffs,
+                    infinity: point.infinity,
+                }
+            }
         }
 
-        #[inline]
-        fn serialized_size(&self) -> usize {
-            let g2::G2Prepared {
-                ell_coeffs,
-                infinity,
-            } = &self.0;
-            ell_coeffs.serialized_size() + infinity.serialized_size()
-        }
+        /// G2 Prepared Point Reference
+        #[derive(derivative::Derivative)]
+        #[derivative(Debug, Eq, PartialEq)]
+        pub struct G2PreparedRef<'p, P>(pub &'p g2::G2Prepared<P>)
+        where
+            P: $params;
 
-        #[inline]
-        fn serialize_uncompressed<W>(&self, mut writer: W) -> Result<(), SerializationError>
+        impl<'p, P> CanonicalSerialize for G2PreparedRef<'p, P>
         where
-            W: Write,
+            P: $params,
         {
-            let g2::G2Prepared {
-                ell_coeffs,
-                infinity,
-            } = &self.0;
-            ell_coeffs.serialize_uncompressed(&mut writer)?;
-            infinity.serialize_uncompressed(&mut writer)?;
-            Ok(())
+            #[inline]
+            fn serialize<W>(&self, mut writer: W) -> Result<(), SerializationError>
+            where
+                W: Write,
+            {
+                let g2::G2Prepared {
+                    ell_coeffs,
+                    infinity,
+                } = &self.0;
+                ell_coeffs.serialize(&mut writer)?;
+                infinity.serialize(&mut writer)?;
+                Ok(())
+            }
+
+            #[inline]
+            fn serialized_size(&self) -> usize {
+                let g2::G2Prepared {
+                    ell_coeffs,
+                    infinity,
+                } = &self.0;
+                ell_coeffs.serialized_size() + infinity.serialized_size()
+            }
+
+            #[inline]
+            fn serialize_uncompressed<W>(&self, mut writer: W) -> Result<(), SerializationError>
+            where
+                W: Write,
+            {
+                let g2::G2Prepared {
+                    ell_coeffs,
+                    infinity,
+                } = &self.0;
+                ell_coeffs.serialize_uncompressed(&mut writer)?;
+                infinity.serialize_uncompressed(&mut writer)?;
+                Ok(())
+            }
+
+            #[inline]
+            fn serialize_unchecked<W>(&self, mut writer: W) -> Result<(), SerializationError>
+            where
+                W: Write,
+            {
+                let g2::G2Prepared {
+                    ell_coeffs,
+                    infinity,
+                } = &self.0;
+                ell_coeffs.serialize_unchecked(&mut writer)?;
+                infinity.serialize_unchecked(&mut writer)?;
+                Ok(())
+            }
+
+            #[inline]
+            fn uncompressed_size(&self) -> usize {
+                let g2::G2Prepared {
+                    ell_coeffs,
+                    infinity,
+                } = &self.0;
+                ell_coeffs.uncompressed_size() + infinity.uncompressed_size()
+            }
         }
 
-        #[inline]
-        fn serialize_unchecked<W>(&self, mut writer: W) -> Result<(), SerializationError>
+        impl<'p, P> From<&'p g2::G2Prepared<P>> for G2PreparedRef<'p, P>
         where
-            W: Write,
+            P: $params,
         {
-            let g2::G2Prepared {
-                ell_coeffs,
-                infinity,
-            } = &self.0;
-            ell_coeffs.serialize_unchecked(&mut writer)?;
-            infinity.serialize_unchecked(&mut writer)?;
-            Ok(())
+            #[inline]
+            fn from(point: &'p g2::G2Prepared<P>) -> Self {
+                Self(point)
+            }
         }
 
-        #[inline]
-        fn uncompressed_size(&self) -> usize {
-            let g2::G2Prepared {
-                ell_coeffs,
-                infinity,
-            } = &self.0;
-            ell_coeffs.uncompressed_size() + infinity.uncompressed_size()
+        impl<'p, P> From<G2PreparedRef<'p, P>> for &'p g2::G2Prepared<P>
+        where
+            P: $params,
+        {
+            #[inline]
+            fn from(point: G2PreparedRef<'p, P>) -> Self {
+                point.0
+            }
         }
-    }
-
-    impl<'p, P> From<&'p g2::G2Prepared<P>> for G2PreparedRef<'p, P>
-    where
-        P: Bls12Parameters,
-    {
-        #[inline]
-        fn from(point: &'p g2::G2Prepared<P>) -> Self {
-            Self(point)
+
+        impl<'p, P> HasSerialization<'p> for g2::G2Prepared<P>
+        where
+            P: $params,
+        {
+            type Serialize = G2PreparedRef<'p, P>;
         }
-    }
-
-    impl<'p, P> From<G2PreparedRef<'p, P>> for &'p g2::G2Prepared<P>
-    where
-        P: Bls12Parameters,
-    {
-        #[inline]
-        fn from(point: G2PreparedRef<'p, P>) -> Self {
-            point.0
+
+        impl<P> HasDeserialization for g2::G2Prepared<P>
+        where
+            P: $params,
+        {
+            type Deserialize = G2Prepared<P>;
         }
-    }
-
-    impl<'p, P> HasSerialization<'p> for g2::G2Prepared<P>
-    where
-        P: Bls12Parameters,
-    {
-        type Serialize = G2PreparedRef<'p, P>;
-    }
-
-    impl<P> HasDeserialization for g2::G2Prepared<P>
-    where
-        P: Bls12Parameters,
-    {
-        type Deserialize = G2Prepared<P>;
-    }
+    };
+}
+
+/// BLS12 Utilities
+pub mod bls12 {
+    use crate::crypto::constraint::arkworks::codec::{HasDeserialization, HasSerialization};
+    use alloc::vec::Vec;
+    use manta_crypto::arkworks::{
+        ec::models::bls12::{g2, Bls12Parameters},
+        ff::Fp2,
+        serialize::{CanonicalDeserialize, CanonicalSerialize, Read, SerializationError, Write},
+    };
+
+    pairing_impl!(Bls12Parameters);
+}
+
+/// Bn254 Utilities
+pub mod bn254 {
+    use crate::crypto::constraint::arkworks::codec::{HasDeserialization, HasSerialization};
+    use alloc::vec::Vec;
+    use manta_crypto::arkworks::{
+        ec::models::bn::{g2, BnParameters},
+        ff::Fp2,
+        serialize::{CanonicalDeserialize, CanonicalSerialize, Read, SerializationError, Write},
+    };
+
+    pairing_impl!(BnParameters);
 }

manta-trusted-setup/Cargo.toml

@@ -25,6 +25,9 @@ is-it-maintained-open-issues = { repository = "Manta-Network/manta-rs" }
 maintenance = { status = "actively-developed" }
 
 [features]
+# Perpetual Powers of Tau Ceremony
+ppot = ["ark-bn254", "memmap"]
+
 # Rayon Parallelization
 rayon = ["manta-util/rayon"]
 
@@ -42,18 +45,26 @@ std = ["manta-util/std"]
 test = ["manta-crypto/test"]
 
 [dependencies]
+ark-bn254 = { version = "0.3.0", optional = true, default-features = false, features = ["curve", "scalar_field"] }
 ark-groth16 = { version = "0.3.0", default-features = false }
 ark-poly = { version = "0.3.0", default-features = false }
+ark-relations = { version = "0.3.0", default-features = false }
 ark-std = { version = "0.3.0", default-features = false }
 bincode = { version = "1.3.3", optional = true, default-features = false }
 blake2 = { version = "0.10.4", default-features = false }
-byteorder = { version = "1.4.3", default-features = false }
 derivative = { version = "2.2.0", default-features = false, features = ["use_core"] }
 manta-crypto = { path = "../manta-crypto", default-features = false, features = ["arkworks", "getrandom", "rand_chacha"] }
 manta-util = { path = "../manta-util", default-features = false }
+memmap = { version = "0.7.0", optional = true, default-features = false }
+rand_chacha = { version = "0.3.1", default-features = false }
 
 [dev-dependencies]
 ark-bls12-381 = { version = "0.3.0", default-features = false, features = ["curve", "scalar_field"] }
+ark-bn254 = { version = "0.3.0", default-features = false, features = ["curve", "scalar_field"] }
+ark-r1cs-std = { version = "0.3.1", default-features = false }
 ark-snark = { version = "0.3.0", default-features = false }
-manta-pay = { path = "../manta-pay", default-features = false, features = ["groth16"] } # TODO: To be removed
+manta-accounting = { path = "../manta-accounting", default-features = false }
+manta-parameters = { path = "../manta-parameters", default-features = false, features = ["download"] }
+manta-pay = { path = "../manta-pay", default-features = false, features = ["groth16", "test"] }
 manta-trusted-setup = { path = ".", default-features = false, features = ["test"] }
+tempfile = { version = "3.3.0", default-features = false }