Recursive Redshift

.vscode/launch.json

@@ -0,0 +1,45 @@
+
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "Run Test Debugger",
+        "type": "cppvsdbg",
+        "request": "launch",
+        "program": "${workspaceFolder}/target/debug/buggin-70708b3916187eeb.exe",
+        "args": [],
+        "stopAtEntry": false,
+        "cwd": "${workspaceFolder}",
+        "environment": [],
+        "externalConsole": true,
+        "preLaunchTask": "cargo test build",
+      },
+
+    {
+      "type": "lldb",
+      "request": "launch",
+      "name": "Launch",
+      "args": [],
+      "program": "${workspaceFolder}/target/debug/boa",
+      "cwd": "${workspaceFolder}",
+      "stopOnEntry": false,
+      "sourceLanguages": ["rust"],
+      "sourceMap": {
+        "/rustc/*": "${env:HOME}/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust"
+      }
+    },
+    {
+      "name": "(Windows) Launch",
+      "type": "cppvsdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/target/debug/boa.exe",
+      "stopAtEntry": false,
+      "cwd": "${workspaceFolder}",
+      "sourceFileMap": {
+        "/rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8": "${env:USERPROFILE}/.rustup/toolchains/stable-x86_64-pc-windows-msvc/lib/rustlib/src/rust"
+      },
+      "symbolSearchPath": "https://msdl.microsoft.com/download/symbols",
+      "environment": []
+    }
+  ]
+}

Cargo.toml

@@ -16,29 +16,38 @@ crate-type = ["cdylib", "lib", "staticlib"]
 rand = "0.4"
 bit-vec = "0.4.4"
 futures = "0.1"
-cfg-if = "0.1.7"
+cfg-if = "0.1"
+
+# pairing = {package = "pairing_ce", path = "../pairing" }
+#pairing = {package = "pairing_ce", version = "0.19" }
+pairing = {package = "pairing_ce", git = "https://github.com/matter-labs/pairing.git"}
+
 
-#pairing = {package = "pairing_ce", path = "../pairing" }
-pairing = {package = "pairing_ce", version = "0.18.0" }
 byteorder = "1"
 
 futures-cpupool = {version = "0.1", optional = true}
 num_cpus = {version = "1", optional = true}
-crossbeam = {version = "0.7.1", optional = true}
+crossbeam = {version = "0.7", optional = true}
 
 prefetch = {version = "0.2", optional = true}
 
-web-sys = {version = "0.3.17", optional = true, features = ["console", "Performance", "Window"]}
+web-sys = {version = "0.3", optional = true, features = ["console", "Performance", "Window"]}
+
+tiny-keccak = {version = "1.5"}
+blake2-rfc = {version = "0.2.18"}
+
+lazy_static = {version = "1", optional = true}
+num = {package = "num", version = "0.2.1"}
 
-tiny-keccak = {version = "1.4.2", optional = true}
-blake2-rfc = {version = "0.2.18", optional = true}
+blake2s_simd = {version = "0.5", optional = true}
+blake2s_const = {version = "0.6", optional = true, path = "./src/redshift/IOP/hashes/blake2_const/blake2s"}
 
 [features]
-default = ["multicore"]
-#default = ["multicore", "nightly"]
-#default = ["wasm"]
+default = ["multicore", "redshift"]
 multicore = ["futures-cpupool", "num_cpus", "crossbeam"]
-sonic = ["tiny-keccak", "blake2-rfc"]
+sonic = []
 gm17 = []
+redshift = ["lazy_static", "blake2s_simd", "blake2s_const"]
 wasm = ["web-sys"]
 nightly = ["prefetch"]
+#derive_serde = ["pairing/derive_serde"]

src/cs.rs

@@ -20,7 +20,7 @@ pub trait Circuit<E: Engine> {
 }
 
 /// Represents a variable in our constraint system.
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub struct Variable(pub(crate) Index);
 
 impl Variable {
@@ -50,6 +50,12 @@ pub enum Index {
 #[derive(Clone)]
 pub struct LinearCombination<E: Engine>(pub(crate) Vec<(Variable, E::Fr)>);
 
+impl<E: Engine> Default for LinearCombination<E> {
+    fn default() -> Self {
+        LinearCombination(vec![])
+    }
+}
+
 impl<E: Engine> AsRef<[(Variable, E::Fr)]> for LinearCombination<E> {
     fn as_ref(&self) -> &[(Variable, E::Fr)] {
         &self.0
@@ -60,6 +66,21 @@ impl<E: Engine> LinearCombination<E> {
     pub fn zero() -> LinearCombination<E> {
         LinearCombination(vec![])
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// returns true if this linear combination 
+    /// consists of exactly one element with coefficient 1
+    pub fn is_simple(&self) -> Option<Variable> {
+        let res = match self.0.len() == 1 && self.0[0].1 == E::Fr::one() {
+            true => Some(self.0[0].0),
+            false => None,
+        };
+
+        res
+    }
 }
 
 impl<E: Engine> Add<(E::Fr, Variable)> for LinearCombination<E> {
@@ -169,7 +190,9 @@ pub enum SynthesisError {
     /// During verification, our verifying key was malformed.
     MalformedVerifyingKey,
     /// During CRS generation, we observed an unconstrained auxillary variable
-    UnconstrainedVariable
+    UnconstrainedVariable,
+    /// Error that should never happen under normal circumstances
+    Unknown,
 }
 
 impl From<io::Error> for SynthesisError {
@@ -188,7 +211,8 @@ impl Error for SynthesisError {
             SynthesisError::UnexpectedIdentity => "encountered an identity element in the CRS",
             SynthesisError::IoError(_) => "encountered an I/O error",
             SynthesisError::MalformedVerifyingKey => "malformed verifying key",
-            SynthesisError::UnconstrainedVariable => "auxillary variable was unconstrained"
+            SynthesisError::UnconstrainedVariable => "auxillary variable was unconstrained",
+            SynthesisError::Unknown => "unknown error",
         }
     }
 }

src/domain.rs

@@ -202,6 +202,28 @@ impl<E: Engine, G: Group<E>> EvaluationDomain<E, G> {
         self.distribute_powers(worker, geninv);
     }
 
+    pub fn transform_powers_of_tau_into_lagrange_basis(&mut self, worker: &Worker) {
+        self.ifft(&worker);
+    }
+
+    pub fn transform_powers_of_tau_into_lagrange_basis_on_coset(&mut self, worker: &Worker)
+    {
+        let geninv = self.geninv;
+        self.distribute_powers(worker, geninv);
+
+        // worker.scope(self.coeffs.len(), |scope, chunk| {
+        //     for v in self.coeffs.chunks_mut(chunk) {
+        //         scope.spawn(move |_| {
+        //             for v in v.iter_mut() {
+        //                 v.group_mul_assign(&geninv);
+        //             }
+        //         });
+        //     }
+        // });
+
+        self.ifft(worker);
+    }
+
     /// This evaluates t(tau) for this domain, which is
     /// tau^m - 1 for these radix-2 domains.
     pub fn z(&self, tau: &E::Fr) -> E::Fr {

src/groth16/mod.rs

@@ -13,8 +13,6 @@ use std::io::{self, Read, Write};
 use std::sync::Arc;
 use byteorder::{BigEndian, WriteBytesExt, ReadBytesExt};
 
-#[cfg(test)]
-mod tests;
 
 mod generator;
 mod prover;