Merge pull request #5 from QED-it/preprocessing-target

Explicit support for preprocessing mode

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zkinterface_bellman"
-version = "1.3.2"
+version = "1.3.4"
 authors = ["Aurélien Nicolas <[email protected]>"]
 license = "MIT"
 edition = "2018"
@@ -21,7 +21,7 @@ path = "src/bin.rs"
 zokrates = ["num-bigint"]
 
 [dependencies]
-zkinterface = { version = "1.3.3" }
+zkinterface = { version = "1.3.4" }
 
 bellman = "0.8.1"
 ff = "0.8.0"

src/zkif_cs.rs

@@ -10,29 +10,40 @@ use std::mem;
 
 const DEFAULT_CONSTRAINTS_PER_MESSAGE: usize = 100000;
 
+#[derive(PartialEq, Copy, Clone)]
+pub enum Target {
+    /// Generate constraints, public inputs, witness.
+    Prover,
+    /// Generate constraints, public inputs.
+    Verifier,
+    /// Generate constraints only.
+    Preprocessing,
+}
 
 pub struct ZkifCS<Scalar: PrimeField> {
     pub constraints_per_message: usize,
 
     statement: StatementBuilder<WorkspaceSink>,
     constraints: ConstraintSystem,
-    proving: bool,
-    witness: Vec<u8>,
+    target: Target,
+    witness_ids: Vec<u64>,
+    witness_encoding: Vec<u8>,
     phantom: PhantomData<Scalar>,
 }
 
 impl<Scalar: PrimeField> ZkifCS<Scalar> {
     /// Must call finish() to finalize the files in the workspace.
-    pub fn new(workspace: impl AsRef<Path>, proving: bool) -> Self {
+    pub fn new(workspace: impl AsRef<Path>, target: Target) -> Self {
         let sink = WorkspaceSink::new(workspace).unwrap();
         let statement = StatementBuilder::new(sink);
 
         ZkifCS {
             constraints_per_message: DEFAULT_CONSTRAINTS_PER_MESSAGE,
             statement,
             constraints: ConstraintSystem::default(),
-            proving,
-            witness: vec![],
+            target,
+            witness_ids: vec![],
+            witness_encoding: vec![],
             phantom: PhantomData,
         }
     }
@@ -42,11 +53,11 @@ impl<Scalar: PrimeField> ZkifCS<Scalar> {
             self.statement.push_constraints(self.constraints)?;
         }
 
-        if self.proving {
+        if self.target == Target::Prover {
             let wit = Witness {
                 assigned_variables: Variables {
-                    variable_ids: self.statement.header.list_witness_ids(),
-                    values: Some(self.witness.clone()),
+                    variable_ids: self.witness_ids,
+                    values: Some(self.witness_encoding.clone()),
                 }
             };
             self.statement.push_witness(wit)?;
@@ -86,22 +97,31 @@ impl<Scalar: PrimeField> bl::ConstraintSystem<Scalar> for ZkifCS<Scalar> {
               A: FnOnce() -> AR, AR: Into<String>
     {
         let zkid = self.statement.allocate_var();
-        if self.proving {
-            let fr = f()?;
-            write_scalar(&fr, &mut self.witness);
+
+        if self.target == Target::Prover {
+            self.witness_ids.push(zkid);
+            let value = f()?;
+            write_scalar(&value, &mut self.witness_encoding);
         }
+
         Ok(Variable::new_unchecked(Index::Aux(zkid as usize)))
     }
 
     fn alloc_input<F, A, AR>(&mut self, _annotation: A, f: F) -> Result<Variable, SynthesisError>
         where F: FnOnce() -> Result<Scalar, SynthesisError>,
               A: FnOnce() -> AR, AR: Into<String>
     {
-        let value = f()?;
-        let mut encoded = vec![];
-        write_scalar(&value, &mut encoded);
+        let mut encoded_value = vec![];
+
+        match self.target {
+            Target::Prover | Target::Verifier => {
+                let value = f()?;
+                write_scalar(&value, &mut encoded_value);
+            }
+            Target::Preprocessing => { /* Leave value empty (still a valid encoding of 0) */ }
+        }
 
-        let zkid = self.statement.allocate_instance_var(&encoded);
+        let zkid = self.statement.allocate_instance_var(&encoded_value);
         Ok(Variable::new_unchecked(Index::Input(zkid as usize)))
     }
 
@@ -141,7 +161,7 @@ fn test_zkif_cs() -> zkinterface::Result<()> {
     let dir = Path::new("local/test/");
     let _ = remove_dir_all(dir);
 
-    let mut cs = ZkifCS::<Scalar>::new(dir, true);
+    let mut cs = ZkifCS::<Scalar>::new(dir, Target::Prover);
 
     // Create 10 constraints to store in chunks of 4.
     cs.constraints_per_message = 4;