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,36 @@
+use anyhow::Result;
+
+use lurk::{field::LurkField, ptr::Ptr, store::Store, z_ptr::ZExprPtr, z_store::ZStore};
+use serde::{Deserialize, Serialize};
+
+/// Holds data for commitments.
+///
+/// WARNING: CONTAINS PRIVATE DATA
+#[derive(Serialize, Deserialize)]
+pub struct Commitment<F: LurkField> {
+    pub hidden: ZExprPtr<F>,
+    pub zstore: ZStore<F>,
+}
+
+impl<'a, F: LurkField + Serialize + Deserialize<'a>> Commitment<F> {
+    #[allow(dead_code)]
+    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(),
+        })
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn persist(&self, hash: &str) -> Result<()> {
+        use super::{field_data::FieldData, paths::commitment_path};
+        use std::{fs::File, io::BufWriter};
+
+        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,27 @@
+use anyhow::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 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, T: Deserialize<'a>>(&'a self) -> Result<T> {
+        Ok(bincode::deserialize(&self.data)?)
+    }
+}

src/cli/lurk_proof.rs

@@ -7,35 +7,21 @@ use lurk::{
         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>,
-}
+#[cfg(not(target_arch = "wasm32"))]
+use std::{fs::File, io::BufReader, io::BufWriter};
 
-#[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)?)
-    }
-}
+#[cfg(not(target_arch = "wasm32"))]
+use super::{
+    field_data::FieldData,
+    paths::{proof_meta_path, proof_path},
+};
 
 /// Carries extra information to help with visualization, experiments etc
 #[derive(Serialize, Deserialize)]
@@ -51,6 +37,15 @@ pub struct LurkProofMeta<F: LurkField> {
     pub zstore: ZStore<F>,
 }
 
+impl<F: LurkField + Serialize> LurkProofMeta<F> {
+    #[cfg(not(target_arch = "wasm32"))]
+    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(())
+    }
+}
+
 type F = pasta_curves::pallas::Scalar; // TODO: generalize this
 
 /// Minimal data structure containing just enough for proof verification
@@ -67,6 +62,13 @@ pub enum LurkProof<'a> {
 }
 
 impl<'a> LurkProof<'a> {
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn persist(&self, id: &str) -> Result<()> {
+        let fd = &FieldData::wrap::<F, LurkProof<'_>>(self)?;
+        bincode::serialize_into(BufWriter::new(&File::create(proof_path(id))?), fd)?;
+        Ok(())
+    }
+
     #[allow(dead_code)]
     fn verify(self) -> Result<bool> {
         match self {
@@ -96,12 +98,9 @@ impl<'a> LurkProof<'a> {
 
     #[cfg(not(target_arch = "wasm32"))]
     pub fn verify_proof(proof_id: &str) -> Result<()> {
-        use super::paths::proof_path;
-        use std::{fs::File, io::BufReader};
-
         let file = File::open(proof_path(proof_id))?;
         let fd: FieldData = bincode::deserialize_from(BufReader::new(file))?;
-        let lurk_proof: LurkProof = fd.open()?;
+        let lurk_proof: LurkProof = fd.extract()?;
         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;

src/cli/paths.rs

@@ -23,8 +23,13 @@ pub fn proofs_dir() -> PathBuf {
 }
 
 #[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 lurk_leaf_dirs() -> [PathBuf; 2] {
+    [proofs_dir(), commits_dir()]
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -35,6 +40,16 @@ pub fn create_lurk_dirs() -> Result<()> {
     Ok(())
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+pub fn repl_history() -> PathBuf {
+    lurk_dir().join(Path::new("repl-history"))
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn commitment_path(hash: &str) -> PathBuf {
+    commits_dir().join(Path::new(hash))
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub fn proof_path(name: &str) -> PathBuf {
     proofs_dir().join(Path::new(name)).with_extension("proof")
@@ -44,8 +59,3 @@ pub fn proof_path(name: &str) -> PathBuf {
 pub fn proof_meta_path(name: &str) -> PathBuf {
     proofs_dir().join(Path::new(name)).with_extension("meta")
 }
-
-#[cfg(not(target_arch = "wasm32"))]
-pub fn repl_history() -> PathBuf {
-    lurk_dir().join(Path::new("repl-history"))
-}

src/cli/repl.rs

@@ -37,13 +37,7 @@ use lurk::{
 };
 
 #[cfg(not(target_arch = "wasm32"))]
-use std::{fs::File, io::BufWriter};
-
-#[cfg(not(target_arch = "wasm32"))]
-use super::{
-    lurk_proof::{LurkProof, LurkProofMeta},
-    paths::{proof_meta_path, proof_path},
-};
+use super::lurk_proof::{LurkProof, LurkProofMeta};
 
 #[derive(Completer, Helper, Highlighter, Hinter)]
 struct InputValidator {
@@ -166,8 +160,6 @@ impl Repl<F> {
 
     #[cfg(not(target_arch = "wasm32"))]
     pub fn prove_last_frames(&mut self) -> Result<()> {
-        use crate::cli::lurk_proof::FieldData;
-
         match self.evaluation.as_mut() {
             None => bail!("No evaluation to prove"),
             Some(Evaluation {
@@ -211,37 +203,30 @@ impl Repl<F> {
                     assert_eq!(self.rc * num_steps, n_frames);
                     assert!(proof.verify(&pp, num_steps, &public_inputs, &public_outputs)?);
 
-                    let lurk_proof_wrap = FieldData::wrap::<F, LurkProof<'_>>(&LurkProof::Nova {
+                    let lurk_proof = &LurkProof::Nova {
                         proof,
                         public_inputs,
                         public_outputs,
                         num_steps,
                         rc: self.rc,
                         lang: (*self.lang).clone(),
-                    })?;
-
-                    let lurk_proof_meta_wrap =
-                        FieldData::wrap::<F, LurkProofMeta<F>>(&LurkProofMeta {
-                            iterations: *iterations,
-                            evaluation_cost: *cost,
-                            generation_cost: generation.duration_since(start).as_nanos(),
-                            compression_cost: compression.duration_since(generation).as_nanos(),
-                            status,
-                            expression,
-                            environment,
-                            result,
-                            zstore: zstore.unwrap(),
-                        })?;
+                    };
+
+                    let lurk_proof_meta = &LurkProofMeta {
+                        iterations: *iterations,
+                        evaluation_cost: *cost,
+                        generation_cost: generation.duration_since(start).as_nanos(),
+                        compression_cost: compression.duration_since(generation).as_nanos(),
+                        status,
+                        expression,
+                        environment,
+                        result,
+                        zstore: zstore.unwrap(),
+                    };
 
                     let id = &format!("{}", timestamp());
-                    bincode::serialize_into(
-                        BufWriter::new(&File::create(proof_path(id))?),
-                        &lurk_proof_wrap,
-                    )?;
-                    bincode::serialize_into(
-                        BufWriter::new(&File::create(proof_meta_path(id))?),
-                        &lurk_proof_meta_wrap,
-                    )?;
+                    lurk_proof.persist(id)?;
+                    lurk_proof_meta.persist(id)?;
                     println!("Proof ID: \"{id}\"");
                     Ok(())
                 }
@@ -250,6 +235,39 @@ impl Repl<F> {
         }
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    fn hide(&mut self, secret: F, payload: Ptr<F>) -> Result<()> {
+        use super::commitment::Commitment;
+
+        let commitment = Commitment::new(secret, payload, &mut self.store)?;
+        let hash = &format!("0x{}", commitment.hidden.value().hex_digits());
+        commitment.persist(hash)?;
+        println!("Data: {}\nHash: {hash}", payload.fmt_to_string(&self.store));
+        Ok(())
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn fetch(&mut self, hash: &str) -> Result<()> {
+        use super::{commitment::Commitment, field_data::FieldData, paths::commitment_path};
+        use std::{fs::File, io::BufReader};
+
+        let file = File::open(commitment_path(hash))?;
+        let fd: FieldData = bincode::deserialize_from(BufReader::new(file))?;
+        if fd.field != F::FIELD {
+            bail!("Invalid field: {}. Expected {}", &fd.field, &F::FIELD)
+        } else {
+            let commitment: Commitment<F> = fd.extract()?;
+            if format!("0x{}", commitment.hidden.value().hex_digits()) != hash {
+                bail!("Hash mismatch. Corrupted commitment file.")
+            } else {
+                self.store
+                    .intern_z_expr_ptr(&commitment.hidden, &commitment.zstore);
+                println!("Data for {hash} is now available");
+            }
+        }
+        Ok(())
+    }
+
     #[inline]
     fn eval_expr(&mut self, expr_ptr: Ptr<F>) -> Result<(IO<F>, usize, Vec<Ptr<F>>)> {
         Ok(Evaluator::new(expr_ptr, self.env, &mut self.store, self.limit, &self.lang).eval()?)
@@ -416,6 +434,47 @@ impl Repl<F> {
                     process::exit(1);
                 }
             }
+            "lurk.commit" => {
+                #[cfg(not(target_arch = "wasm32"))]
+                {
+                    let first = self.peek1(cmd, args)?;
+                    let (first_io, ..) = self.eval_expr(first)?;
+                    self.hide(ff::Field::ZERO, first_io.expr)?;
+                }
+            }
+            "lurk.hide" => {
+                #[cfg(not(target_arch = "wasm32"))]
+                {
+                    let (first, second) = self.peek2(cmd, args)?;
+                    let (first_io, ..) = self
+                        .eval_expr(first)
+                        .with_context(|| "evaluating first arg")?;
+                    let (second_io, ..) = self
+                        .eval_expr(second)
+                        .with_context(|| "evaluating second arg")?;
+                    let Some(secret) = self.store.fetch_num(&first_io.expr) else {
+                    bail!("Secret must be a number. Got {}", first_io.expr.fmt_to_string(&self.store))
+                };
+                    self.hide(secret.into_scalar(), second_io.expr)?;
+                }
+            }
+            "fetch" => {
+                #[cfg(not(target_arch = "wasm32"))]
+                {
+                    let first = self.peek1(cmd, args)?;
+                    let n = self.store.lurk_sym("num");
+                    let expr = self.store.list(&[n, first]);
+                    let (expr_io, ..) = self
+                        .eval_expr(expr)
+                        .with_context(|| "evaluating first arg")?;
+                    let hash = self
+                        .store
+                        .fetch_num(&expr_io.expr)
+                        .expect("must be a number");
+                    #[cfg(not(target_arch = "wasm32"))]
+                    self.fetch(&format!("0x{}", hash.into_scalar().hex_digits()))?;
+                }
+            }
             "clear" => self.env = self.store.nil(),
             "set-env" => {
                 // The state's env is set to the result of evaluating the first argument.