Implement persistent commitments

fcomm/src/lib.rs

@@ -555,7 +555,7 @@ impl<F: LurkField + Serialize + DeserializeOwned> LurkPtr<F> {
             LurkPtr::ZStorePtr(z_store_ptr) => {
                 let z_store = &z_store_ptr.z_store;
                 let z_ptr = z_store_ptr.z_ptr;
-                s.intern_z_expr_ptr(z_ptr, z_store)
+                s.intern_z_expr_ptr(&z_ptr, z_store)
                     .expect("failed to intern z_ptr")
             }
         }

src/cli/commitment.rs

@@ -0,0 +1,44 @@
+use lurk::{field::LurkField, z_ptr::ZExprPtr, z_store::ZStore};
+use serde::{Deserialize, Serialize};
+
+/// Holds data for commitments.
+///
+/// **Warning**: holds private data. The `ZStore` contains the secret used to
+/// hide the original payload.
+#[derive(Serialize, Deserialize)]
+pub struct Commitment<F: LurkField> {
+    pub(crate) hidden: ZExprPtr<F>,
+    pub(crate) zstore: ZStore<F>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+mod cli {
+    use anyhow::Result;
+    use lurk::{field::LurkField, ptr::Ptr, store::Store, z_store::ZStore};
+    use serde::Serialize;
+    use std::{fs::File, io::BufWriter};
+
+    use crate::cli::{field_data::FieldData, paths::cli::commitment_path};
+
+    use super::Commitment;
+
+    impl<F: LurkField> Commitment<F> {
+        pub fn new(secret: F, payload: Ptr<F>, store: &mut Store<F>) -> Result<Self> {
+            let hidden = store.hide(secret, payload);
+            let mut zstore = Some(ZStore::<F>::default());
+            let hidden = store.get_z_expr(&hidden, &mut zstore)?.0;
+            Ok(Self {
+                hidden,
+                zstore: zstore.unwrap(),
+            })
+        }
+    }
+
+    impl<F: LurkField + Serialize> Commitment<F> {
+        pub fn persist(&self, hash: &str) -> Result<()> {
+            let fd = &FieldData::wrap::<F, Commitment<F>>(self)?;
+            bincode::serialize_into(BufWriter::new(&File::create(commitment_path(hash))?), fd)?;
+            Ok(())
+        }
+    }
+}

src/cli/field_data.rs

@@ -0,0 +1,30 @@
+use anyhow::{bail, Result};
+use serde::{Deserialize, Serialize};
+
+use lurk::field::{LanguageField, LurkField};
+
+/// A wrapper for data whose deserialization depends on a certain LurkField
+#[derive(Serialize, Deserialize)]
+pub struct FieldData {
+    pub(crate) field: LanguageField,
+    data: Vec<u8>,
+}
+
+#[allow(dead_code)]
+impl FieldData {
+    #[inline]
+    pub fn wrap<F: LurkField, T: Serialize>(t: &T) -> Result<Self> {
+        Ok(Self {
+            field: F::FIELD,
+            data: bincode::serialize(t)?,
+        })
+    }
+
+    #[inline]
+    pub fn extract<'a, F: LurkField, T: Deserialize<'a>>(&'a self) -> Result<T> {
+        if self.field != F::FIELD {
+            bail!("Invalid field: {}. Expected {}", &self.field, &F::FIELD)
+        }
+        Ok(bincode::deserialize(&self.data)?)
+    }
+}

src/cli/lurk_proof.rs

@@ -1,61 +1,43 @@
 use serde::{Deserialize, Serialize};
 
-use anyhow::Result;
-
 use lurk::{
+    coprocessor::Coprocessor,
     eval::{
         lang::{Coproc, Lang},
         Status,
     },
-    field::{LanguageField, LurkField},
+    field::LurkField,
     proof::nova,
-    public_parameters::public_params,
     z_ptr::ZExprPtr,
     z_store::ZStore,
 };
 
-/// A wrapper for data whose deserialization depends on a certain LurkField
-#[derive(Serialize, Deserialize)]
-pub struct FieldData {
-    field: LanguageField,
-    data: Vec<u8>,
-}
-
-#[allow(dead_code)]
-impl FieldData {
-    #[inline]
-    pub fn wrap<F: LurkField, T: Serialize>(t: &T) -> Result<Self> {
-        Ok(Self {
-            field: F::FIELD,
-            data: bincode::serialize(t)?,
-        })
-    }
-
-    #[inline]
-    pub fn open<'a, T: Deserialize<'a>>(&'a self) -> Result<T> {
-        Ok(bincode::deserialize(&self.data)?)
-    }
-}
-
-/// Carries extra information to help with visualization, experiments etc
+/// Carries extra information to help with visualization, experiments etc.
+///
+/// Note: the `ZStore` in this struct only has enough data to recover the meaning
+/// of the claim being proven: `expression`, when evaluated in the context of
+/// `environment`, is reduced to `result`. It doesn't contain private data.
 #[derive(Serialize, Deserialize)]
 pub struct LurkProofMeta<F: LurkField> {
-    pub iterations: usize,
-    pub evaluation_cost: u128,
-    pub generation_cost: u128,
-    pub compression_cost: u128,
-    pub status: Status,
-    pub expression: ZExprPtr<F>,
-    pub environment: ZExprPtr<F>,
-    pub result: ZExprPtr<F>,
-    pub zstore: ZStore<F>,
+    pub(crate) iterations: usize,
+    pub(crate) evaluation_cost: u128,
+    pub(crate) generation_cost: u128,
+    pub(crate) compression_cost: u128,
+    pub(crate) status: Status,
+    pub(crate) expression: ZExprPtr<F>,
+    pub(crate) environment: ZExprPtr<F>,
+    pub(crate) result: ZExprPtr<F>,
+    pub(crate) zstore: ZStore<F>,
 }
 
-type F = pasta_curves::pallas::Scalar; // TODO: generalize this
+type Pallas = pasta_curves::pallas::Scalar; // TODO: generalize this
 
 /// Minimal data structure containing just enough for proof verification
 #[derive(Serialize, Deserialize)]
-pub enum LurkProof<'a> {
+pub enum LurkProof<'a, F: LurkField>
+where
+    Coproc<F>: Coprocessor<Pallas>,
+{
     Nova {
         proof: nova::Proof<'a, Coproc<F>>,
         public_inputs: Vec<F>,
@@ -66,43 +48,73 @@ pub enum LurkProof<'a> {
     },
 }
 
-impl<'a> LurkProof<'a> {
-    #[allow(dead_code)]
-    fn verify(self) -> Result<bool> {
-        match self {
-            Self::Nova {
-                proof,
-                public_inputs,
-                public_outputs,
-                num_steps,
-                rc,
-                lang,
-            } => {
-                log::info!("Loading public parameters");
-                let pp = public_params(rc, std::sync::Arc::new(lang))?;
-                Ok(proof.verify(&pp, num_steps, &public_inputs, &public_outputs)?)
-            }
+#[cfg(not(target_arch = "wasm32"))]
+mod cli {
+    use crate::cli::{
+        field_data::FieldData,
+        paths::cli::{proof_meta_path, proof_path},
+    };
+    use anyhow::Result;
+    use lurk::{
+        coprocessor::Coprocessor, eval::lang::Coproc, field::LurkField,
+        public_parameters::public_params,
+    };
+    use serde::Serialize;
+    use std::{fs::File, io::BufReader, io::BufWriter};
+
+    use super::{LurkProof, LurkProofMeta, Pallas};
+
+    impl<F: LurkField + Serialize> LurkProofMeta<F> {
+        pub fn persist(&self, id: &str) -> Result<()> {
+            let fd = &FieldData::wrap::<F, LurkProofMeta<F>>(self)?;
+            bincode::serialize_into(BufWriter::new(&File::create(proof_meta_path(id))?), fd)?;
+            Ok(())
         }
     }
 
-    #[allow(dead_code)]
-    fn print_verification(proof_id: &str, success: bool) {
-        if success {
-            println!("✓ Proof \"{proof_id}\" verified");
-        } else {
-            println!("✗ Proof \"{proof_id}\" failed on verification");
+    impl<'a, F: LurkField + Serialize> LurkProof<'a, F>
+    where
+        Coproc<F>: Coprocessor<Pallas>,
+    {
+        pub fn persist(&self, id: &str) -> Result<()> {
+            let fd = &FieldData::wrap::<F, LurkProof<'_, F>>(self)?;
+            bincode::serialize_into(BufWriter::new(&File::create(proof_path(id))?), fd)?;
+            Ok(())
+        }
+
+        fn print_verification(proof_id: &str, success: bool) {
+            if success {
+                println!("✓ Proof \"{proof_id}\" verified");
+            } else {
+                println!("✗ Proof \"{proof_id}\" failed on verification");
+            }
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn verify_proof(proof_id: &str) -> Result<()> {
-        use super::paths::proof_path;
-        use std::{fs::File, io::BufReader};
+    impl<'a> LurkProof<'a, Pallas> {
+        fn verify(self) -> Result<bool> {
+            match self {
+                Self::Nova {
+                    proof,
+                    public_inputs,
+                    public_outputs,
+                    num_steps,
+                    rc,
+                    lang,
+                } => {
+                    log::info!("Loading public parameters");
+                    let pp = public_params(rc, std::sync::Arc::new(lang))?;
+                    Ok(proof.verify(&pp, num_steps, &public_inputs, &public_outputs)?)
+                }
+            }
+        }
 
-        let file = File::open(proof_path(proof_id))?;
-        let fd: FieldData = bincode::deserialize_from(BufReader::new(file))?;
-        let lurk_proof: LurkProof = fd.open()?;
-        Self::print_verification(proof_id, lurk_proof.verify()?);
-        Ok(())
+        pub fn verify_proof<F: LurkField>(proof_id: &str) -> Result<()> {
+            let file = File::open(proof_path(proof_id))?;
+            let fd: FieldData = bincode::deserialize_from(BufReader::new(file))?;
+            let lurk_proof = fd.extract::<F, LurkProof<'_, Pallas>>()?;
+            Self::print_verification(proof_id, lurk_proof.verify()?);
+            Ok(())
+        }
     }
 }

src/cli/mod.rs

@@ -1,3 +1,5 @@
+mod commitment;
+mod field_data;
 mod lurk_proof;
 mod paths;
 mod repl;
@@ -361,7 +363,7 @@ struct VerifyArgs {
 /// Parses CLI arguments and continues the program flow accordingly
 pub fn parse_and_run() -> Result<()> {
     #[cfg(not(target_arch = "wasm32"))]
-    paths::create_lurk_dirs()?;
+    paths::cli::create_lurk_dirs()?;
 
     if let Ok(repl_cli) = ReplCli::try_parse() {
         repl_cli.run()
@@ -376,7 +378,7 @@ pub fn parse_and_run() -> Result<()> {
                 #[cfg(not(target_arch = "wasm32"))]
                 {
                     use crate::cli::lurk_proof::LurkProof;
-                    LurkProof::verify_proof(&verify_args.proof_id)?;
+                    LurkProof::verify_proof::<pallas::Scalar>(&verify_args.proof_id)?;
                 }
                 Ok(())
             }

src/cli/paths.rs

@@ -1,51 +1,52 @@
 #[cfg(not(target_arch = "wasm32"))]
-use anyhow::Result;
+pub mod cli {
+    use anyhow::Result;
 
-#[cfg(not(target_arch = "wasm32"))]
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
+    use std::{
+        fs,
+        path::{Path, PathBuf},
+    };
 
-#[cfg(not(target_arch = "wasm32"))]
-fn home_dir() -> PathBuf {
-    home::home_dir().expect("missing home directory")
-}
+    fn home_dir() -> PathBuf {
+        home::home_dir().expect("missing home directory")
+    }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn lurk_dir() -> PathBuf {
-    home_dir().join(Path::new(".lurk"))
-}
+    pub fn lurk_dir() -> PathBuf {
+        home_dir().join(Path::new(".lurk"))
+    }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn proofs_dir() -> PathBuf {
-    lurk_dir().join(Path::new("proofs"))
-}
+    pub fn proofs_dir() -> PathBuf {
+        lurk_dir().join(Path::new("proofs"))
+    }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn lurk_leaf_dirs() -> [PathBuf; 1] {
-    [proofs_dir()]
-}
+    pub fn commits_dir() -> PathBuf {
+        lurk_dir().join(Path::new("commits"))
+    }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn create_lurk_dirs() -> Result<()> {
-    for dir in lurk_leaf_dirs() {
-        fs::create_dir_all(dir)?;
+    pub fn lurk_leaf_dirs() -> [PathBuf; 2] {
+        [proofs_dir(), commits_dir()]
     }
-    Ok(())
-}
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn proof_path(name: &str) -> PathBuf {
-    proofs_dir().join(Path::new(name)).with_extension("proof")
-}
+    pub fn create_lurk_dirs() -> Result<()> {
+        for dir in lurk_leaf_dirs() {
+            fs::create_dir_all(dir)?;
+        }
+        Ok(())
+    }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn proof_meta_path(name: &str) -> PathBuf {
-    proofs_dir().join(Path::new(name)).with_extension("meta")
-}
+    pub fn repl_history() -> PathBuf {
+        lurk_dir().join(Path::new("repl-history"))
+    }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn repl_history() -> PathBuf {
-    lurk_dir().join(Path::new("repl-history"))
+    pub fn commitment_path(hash: &str) -> PathBuf {
+        commits_dir().join(Path::new(hash))
+    }
+
+    pub fn proof_path(name: &str) -> PathBuf {
+        proofs_dir().join(Path::new(name)).with_extension("proof")
+    }
+
+    pub fn proof_meta_path(name: &str) -> PathBuf {
+        proofs_dir().join(Path::new(name)).with_extension("meta")
+    }
 }