WIP

Author: Pratyush

Cargo.toml

@@ -15,6 +15,7 @@ members = [
     "r1cs-core",
     "r1cs-core-new",
     "r1cs-std",
+    "r1cs-std-new",
     "algebra-core/algebra-core-derive",
 ]
 

r1cs-std-new/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "r1cs-std-new"
+version = "0.1.0"
+authors = [
+    "Sean Bowe",
+    "Alessandro Chiesa",
+    "Matthew Green",
+    "Ian Miers",
+    "Pratyush Mishra",
+    "Howard Wu"
+]
+description = "A standard library for constraint system gadgets"
+homepage = "https://libzexe.org"
+repository = "https://github.com/scipr/zexe"
+documentation = "https://docs.rs/r1cs-std/"
+keywords = ["zero knowledge", "cryptography", "zkSNARK", "SNARK"]
+categories = ["cryptography"]
+include = ["Cargo.toml", "src", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+
+################################# Dependencies ################################
+
+[dependencies]
+algebra = { path = "../algebra", default-features = false }
+r1cs-core = { package = "r1cs-core-new", path = "../r1cs-core-new", default-features = false }
+derivative = { version = "2", features = ["use_core"] }
+
+[dev-dependencies]
+rand = { version = "0.7", default-features = false }
+rand_xorshift = { version = "0.2" }
+# Currently this means that all downstream users of `r1cs-std` will be using
+# `algebra` with the `bls12_381` feature.
+algebra = { path = "../algebra", default-features = false, features = [ "bls12_381" ] }
+
+[features]
+default = ["std"]
+full = [ "bls12_377", "jubjub", "edwards_bls12", "edwards_sw6", "mnt4_298", "mnt4_753", "mnt6_298", "mnt6_753" ]
+
+bls12_377 = [ "algebra/bls12_377" ]
+jubjub = [ "algebra/jubjub" ]
+edwards_bls12 = [ "algebra/edwards_bls12" ]
+edwards_sw6 = [ "algebra/edwards_sw6" ]
+mnt4_298 = [ "algebra/mnt4_298" ]
+mnt4_753 = [ "algebra/mnt4_753" ]
+mnt6_298 = [ "algebra/mnt6_298" ]
+mnt6_753 = [ "algebra/mnt6_753" ]
+
+std = [ "algebra/std", "r1cs-core/std" ]
+parallel = [ "std", "algebra/parallel" ]

r1cs-std-new/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

r1cs-std-new/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

r1cs-std-new/src/alloc.rs

@@ -0,0 +1,120 @@
+use crate::Vec;
+use algebra::Field;
+use core::borrow::Borrow;
+use r1cs_core::{ConstraintSystem, SynthesisError};
+
+pub trait AllocGadget<V, ConstraintF: Field>
+where
+    Self: Sized,
+    V: ?Sized,
+{
+    fn alloc<F, T, CS: ConstraintSystem<ConstraintF>>(cs: CS, f: F) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<V>;
+
+    fn alloc_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
+        cs: CS,
+        f: F,
+    ) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<V>,
+    {
+        Self::alloc(cs, f)
+    }
+
+    fn alloc_input<F, T, CS: ConstraintSystem<ConstraintF>>(
+        cs: CS,
+        f: F,
+    ) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<V>;
+
+    fn alloc_input_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
+        cs: CS,
+        f: F,
+    ) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<V>,
+    {
+        Self::alloc_input(cs, f)
+    }
+}
+
+impl<I, ConstraintF: Field, A: AllocGadget<I, ConstraintF>> AllocGadget<[I], ConstraintF>
+    for Vec<A>
+{
+    fn alloc<F, T, CS: ConstraintSystem<ConstraintF>>(
+        mut cs: CS,
+        f: F,
+    ) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<[I]>,
+    {
+        let mut vec = Vec::new();
+        for (i, value) in f()?.borrow().iter().enumerate() {
+            vec.push(A::alloc(&mut cs.ns(|| format!("value_{}", i)), || {
+                Ok(value)
+            })?);
+        }
+        Ok(vec)
+    }
+
+    fn alloc_input<F, T, CS: ConstraintSystem<ConstraintF>>(
+        mut cs: CS,
+        f: F,
+    ) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<[I]>,
+    {
+        let mut vec = Vec::new();
+        for (i, value) in f()?.borrow().iter().enumerate() {
+            vec.push(A::alloc_input(
+                &mut cs.ns(|| format!("value_{}", i)),
+                || Ok(value),
+            )?);
+        }
+        Ok(vec)
+    }
+
+    fn alloc_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
+        mut cs: CS,
+        f: F,
+    ) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<[I]>,
+    {
+        let mut vec = Vec::new();
+        for (i, value) in f()?.borrow().iter().enumerate() {
+            vec.push(A::alloc_checked(
+                &mut cs.ns(|| format!("value_{}", i)),
+                || Ok(value),
+            )?);
+        }
+        Ok(vec)
+    }
+
+    fn alloc_input_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
+        mut cs: CS,
+        f: F,
+    ) -> Result<Self, SynthesisError>
+    where
+        F: FnOnce() -> Result<T, SynthesisError>,
+        T: Borrow<[I]>,
+    {
+        let mut vec = Vec::new();
+        for (i, value) in f()?.borrow().iter().enumerate() {
+            vec.push(A::alloc_input_checked(
+                &mut cs.ns(|| format!("value_{}", i)),
+                || Ok(value),
+            )?);
+        }
+        Ok(vec)
+    }
+}