feat: implement taper challenge handling, and upate proofs

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "replication-game"
 version = "0.1.0"
-authors = ["nicola <[email protected]>"]
+authors = ["nicola <[email protected]>", "dignifiedquire <[email protected]"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
 
@@ -19,27 +19,35 @@ rocket = "0.4"
 blake2 = "0.8.0"
 hex = "0.3.2"
 crypto-mac = "0.7.0"
-filecoin-proofs = { git = "https://[email protected]/filecoin-project/rust-fil-proofs" }
-storage-proofs = { git = "https://[email protected]/filecoin-project/rust-fil-proofs" }
 diesel = { version = "1.3", features = ["postgres", "r2d2"] }
 diesel_migrations = "1.3"
 failure = "0.1"
-serde = "1.0"
-serde_derive = "1.0"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 clap = "2"
 slog = "2.4"
 rand = "0.4"
-sapling-crypto = { git = "https://github.com/zcash-hackworks/sapling-crypto", branch = "master" }
 diesel-derive-enum = { version = "0.4.4", features = ["postgres"] }
 byteorder = "1.2.7"
 memmap = "0.7.0"
 tempfile = "3.0.5"
 flate2 = {version = "1.0.6", default-features = false, features = ["rust_backend"]}
 
+[dependencies.filecoin-proofs]
+git = "https://github.com/filecoin-project/rust-fil-proofs"
+rev = "b429279195e08ecf3abd9879a3ef6f3b6fb2e21f"
+
+[dependencies.storage-proofs]
+git = "https://github.com/filecoin-project/rust-fil-proofs"
+rev = "b429279195e08ecf3abd9879a3ef6f3b6fb2e21f"
+
+[dependencies.sapling-crypto]
+git = "https://github.com/filecoin-project/sapling-crypto"
+branch = "master"
+
 [dependencies.pairing]
-version = "0.14.2"
-features = ["expose-arith", "u128-support"]
+git = "https://github.com/filecoin-project/pairing"
+branch = "master"
 
 [dependencies.rocket_contrib]
 version = "0.4"

migrations/2019-03-15-111850_add-taper-params/down.sql

@@ -0,0 +1,6 @@
+-- This file should undo anything in `up.sql`
+
+ALTER TABLE params
+DROP COLUMN is_tapered,
+DROP COLUMN taper_layers,
+DROP COLUMN taper;

migrations/2019-03-15-111850_add-taper-params/up.sql

@@ -0,0 +1,6 @@
+-- Your SQL goes here
+
+ALTER TABLE params
+ADD COLUMN is_tapered BOOLEAN,
+ADD COLUMN taper_layers INT,
+ADD COLUMN taper DOUBLE PRECISION;

src/bin/game.rs

@@ -73,9 +73,18 @@ fn main() {
         seed: value_t!(matches, "seed", String).unwrap(),
     };
 
-    let typ = match matches.subcommand().0 {
-        "drgporep" => proof::ProofType::DrgPoRep,
-        "zigzag" => proof::ProofType::Zigzag,
+    let (typ, zigzag) = match matches.subcommand().0 {
+        "drgporep" => (proof::ProofType::DrgPoRep, None),
+        "zigzag" => (
+            proof::ProofType::Zigzag,
+            Some(proof::ZigZagParams {
+                expansion_degree: value_t!(matches, "expansion-degree", usize).unwrap(),
+                layers: value_t!(matches, "layers", usize).unwrap(),
+                is_tapered: true,
+                taper_layers: 7,
+                taper: 1.0 / 3.0,
+            }),
+        ),
         _ => panic!("invalid subcommand: {}", matches.subcommand().0),
     };
 
@@ -84,9 +93,8 @@ fn main() {
         size: value_t!(matches, "size", usize).unwrap() * 1024,
         degree: value_t!(matches, "degree", usize).unwrap(),
         vde: value_t!(matches, "vde", usize).unwrap(),
-        challenge_count: 2, // TODO: use 200
-        expansion_degree: value_t!(matches, "expansion-degree", usize).ok(),
-        layers: value_t!(matches, "layers", usize).ok(),
+        challenge_count: 8008,
+        zigzag,
     };
 
     let prover = value_t!(matches, "prover", String).unwrap();

src/models/leaderboard.rs

@@ -1,7 +1,7 @@
 use blake2::{Blake2b, Digest};
 use byteorder::{BigEndian, ByteOrder};
 use diesel::{self, prelude::*};
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 
 use crate::models::proof;
 use crate::schema::{leaderboard, params};
@@ -90,6 +90,9 @@ pub struct Params {
     pub degree: i32,
     pub expansion_degree: Option<i32>,
     pub layers: Option<i32>,
+    pub is_tapered: Option<bool>,
+    pub taper_layers: Option<i32>,
+    pub taper: Option<f64>,
 }
 
 impl Params {
@@ -112,8 +115,11 @@ impl Params {
                     challenge_count: val.challenge_count as i32,
                     vde: val.vde as i32,
                     degree: val.degree as i32,
-                    expansion_degree: val.expansion_degree.map(|v| v as i32),
-                    layers: val.layers.map(|v| v as i32),
+                    expansion_degree: val.zigzag.as_ref().map(|v| v.expansion_degree as i32),
+                    layers: val.zigzag.as_ref().map(|v| v.layers as i32),
+                    is_tapered: val.zigzag.as_ref().map(|v| v.is_tapered),
+                    taper_layers: val.zigzag.as_ref().map(|v| v.taper_layers as i32),
+                    taper: val.zigzag.as_ref().map(|v| v.taper),
                 })
                 .execute(conn)?;
         }

src/models/proof.rs

@@ -1,7 +1,8 @@
 use diesel_derive_enum::DbEnum;
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 use storage_proofs::hasher::pedersen::PedersenDomain;
 use storage_proofs::hasher::PedersenHasher;
+use storage_proofs::layered_drgporep::LayerChallenges;
 use storage_proofs::{drgporep, layered_drgporep, porep};
 
 use crate::models::seed::Seed;
@@ -24,10 +25,34 @@ pub struct Params {
     pub challenge_count: usize,
     pub vde: usize,
     pub degree: usize,
-    // only set for zigzag
-    pub expansion_degree: Option<usize>,
-    // only set for zigzag
-    pub layers: Option<usize>,
+    pub zigzag: Option<ZigZagParams>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ZigZagParams {
+    pub expansion_degree: usize,
+    pub layers: usize,
+    pub is_tapered: bool,
+    pub taper_layers: usize,
+    pub taper: f64,
+}
+
+impl Params {
+    pub fn as_zigzag_params(&self) -> Option<(usize, LayerChallenges)> {
+        self.zigzag.as_ref().map(|zigzag| {
+            let layer_challenges = if zigzag.is_tapered {
+                LayerChallenges::new_tapered(
+                    zigzag.layers,
+                    self.challenge_count,
+                    zigzag.taper_layers,
+                    zigzag.taper as f64,
+                )
+            } else {
+                LayerChallenges::new_fixed(zigzag.layers, self.challenge_count)
+            };
+            (zigzag.expansion_degree, layer_challenges)
+        })
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, DbEnum)]

src/models/seed.rs

@@ -1,4 +1,4 @@
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Seed {

src/proofs.rs

@@ -35,12 +35,13 @@ pub fn zigzag_work(prover: String, params: proof::Params, seed: Seed) -> String
 
     let data_size = params.size;
     let m = params.degree;
-    let expansion_degree = params.expansion_degree.unwrap_or_else(|| 6);
-    let sloth_iter = params.vde;
     let challenge_count = params.challenge_count;
+    let sloth_iter = params.vde;
+
+    let (expansion_degree, layer_challenges) = params
+        .as_zigzag_params()
+        .unwrap_or_else(|| (6, LayerChallenges::new_fixed(10, challenge_count)));
 
-    // TODO: should these be configurable?
-    let layers = params.layers.unwrap_or_else(|| 10);
     let partitions = 1;
 
     let mut rng = thread_rng();
@@ -49,19 +50,16 @@ pub fn zigzag_work(prover: String, params: proof::Params, seed: Seed) -> String
 
     let nodes = data_size / 32;
     let mut data = file_backed_mmap_from_random_bytes(&mut rng, nodes);
-    let layer_challenges = LayerChallenges::new_fixed(layers, challenge_count);
 
     let sp = layered_drgporep::SetupParams {
-        drg_porep_setup_params: drgporep::SetupParams {
-            drg: drgporep::DrgParams {
-                nodes,
-                degree: m,
-                expansion_degree,
-                // TODO: where should this come from?
-                seed: [0u32; 7],
-            },
-            sloth_iter,
+        drg: drgporep::DrgParams {
+            nodes,
+            degree: m,
+            expansion_degree,
+            // TODO: where should this come from?
+            seed: [0u32; 7],
         },
+        sloth_iter,
         layer_challenges,
     };
 
@@ -148,6 +146,8 @@ pub fn porep_work(prover: String, params: proof::Params, seed: Seed) -> String {
             // TODO: where should this come from?
             seed: [0u32; 7],
         },
+        challenges_count: challenge_count,
+        private: false,
         sloth_iter,
     };
 
@@ -160,12 +160,15 @@ pub fn porep_work(prover: String, params: proof::Params, seed: Seed) -> String {
             .unwrap();
 
     let pub_inputs = PublicInputs {
-        replica_id,
+        replica_id: Some(replica_id),
         challenges,
         tau: Some(tau),
     };
 
-    let priv_inputs = PrivateInputs::<PedersenHasher> { aux: &aux };
+    let priv_inputs = PrivateInputs::<PedersenHasher> {
+        tree_d: &aux.tree_d,
+        tree_r: &aux.tree_r,
+    };
 
     eprintln!("sampling proving & verifying");
 

src/routes/proof.rs

@@ -9,7 +9,7 @@ use rocket_contrib::json::Json;
 use storage_proofs::drgporep::{self, *};
 use storage_proofs::drgraph::*;
 use storage_proofs::hasher::{Hasher, PedersenHasher};
-use storage_proofs::layered_drgporep::{self, LayerChallenges};
+use storage_proofs::layered_drgporep;
 use storage_proofs::proof::ProofScheme;
 use storage_proofs::zigzag_drgporep::*;
 
@@ -60,28 +60,22 @@ fn validate(res: &proof::Response) -> bool {
 
     match res.proof {
         proof::Proof::Zigzag(ref proof) => {
-            if params.expansion_degree.is_none()
-                || params.layers.is_none()
-                || res.comm_r_star.is_none()
-            {
+            if params.zigzag.is_none() {
                 return false;
             }
 
-            let expansion_degree = params.expansion_degree.expect("missing expansion degree");
-            let layers = params.layers.expect("missing layers");
+            let (expansion_degree, layer_challenges) =
+                params.as_zigzag_params().expect("missing zigzag params");
             let comm_r_star = res.comm_r_star.expect("missing comm r star");
-            let layer_challenges = LayerChallenges::new_fixed(layers, challenge_count);
 
             let sp = layered_drgporep::SetupParams {
-                drg_porep_setup_params: drgporep::SetupParams {
-                    drg: drgporep::DrgParams {
-                        nodes,
-                        degree: m,
-                        expansion_degree,
-                        seed: param_seed,
-                    },
-                    sloth_iter,
+                drg: drgporep::DrgParams {
+                    nodes,
+                    degree: m,
+                    expansion_degree,
+                    seed: param_seed,
                 },
+                sloth_iter,
                 layer_challenges,
             };
 
@@ -105,13 +99,15 @@ fn validate(res: &proof::Response) -> bool {
                     expansion_degree: 0,
                     seed: param_seed,
                 },
+                challenges_count: challenge_count,
+                private: false,
                 sloth_iter,
             };
 
             println!("running setup");
             let pp = DrgPoRep::<PedersenHasher, BucketGraph<PedersenHasher>>::setup(&sp).unwrap();
             let pub_inputs = PublicInputs::<<PedersenHasher as Hasher>::Domain> {
-                replica_id,
+                replica_id: Some(replica_id),
                 challenges: vec![2; challenge_count],
                 tau: Some(res.tau),
             };

src/schema.rs

@@ -9,7 +9,7 @@ table! {
 
 table! {
     use crate::models::proof::ProofTypeMapping;
-    use diesel::sql_types::{Nullable, BigInt, Integer};
+    use diesel::sql_types::{Nullable, BigInt, Integer, Double, Bool};
 
     params (id) {
         id -> BigInt,
@@ -20,6 +20,9 @@ table! {
         degree -> Integer,
         expansion_degree -> Nullable<Integer>,
         layers -> Nullable<Integer>,
+        is_tapered -> Nullable<Bool>,
+        taper_layers -> Nullable<Integer>,
+        taper -> Nullable<Double>,
     }
 }