Add CLI Commands for Frida-poc

.gitignore

@@ -1,6 +1,6 @@
-target
-data
-
 # IDEs
 .vscode
 .idea
+
+target
+data

Cargo.toml

@@ -18,6 +18,7 @@ required-features = ["bench"]
 clap = { version = "4.5", features = ["derive"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+shlex = "1.3.0"
 winter-crypto = "0.9.0"
 winter-fri = "0.9.0"
 winter-math = "0.9.0"

src/commands/commit.rs

@@ -1,49 +1,84 @@
-use frida_poc::{
-    frida_data::encoded_data_element_count,
-    frida_prover::{traits::BaseFriProver, FridaProver},
+use crate::{
+    frida_prover::{Commitment, FridaProver},
     frida_prover_channel::FridaProverChannel,
     frida_random::FridaRandom,
+    utils::{read_file_to_vec, write_to_file},
 };
+use std::path::Path;
 use winter_crypto::hashers::Blake3_256;
-use winter_fri::FriOptions;
 use winter_math::fields::f128::BaseElement;
+use winter_utils::{Deserializable, Serializable};
 
 type Blake3 = Blake3_256<BaseElement>;
 type FridaChannel =
     FridaProverChannel<BaseElement, Blake3, Blake3, FridaRandom<Blake3, Blake3, BaseElement>>;
 type FridaProverType = FridaProver<BaseElement, BaseElement, FridaChannel, Blake3>;
 
-pub fn run(data_path: &str, num_queries: usize, options: FriOptions) {
-    let data = std::fs::read(data_path).expect("Unable to read data file");
-    let mut prover: FridaProverType = FridaProver::new(options.clone());
+/// Runs the commitment process, saving the commitment to a file.
+pub fn run(
+    prover: &mut FridaProverType,
+    num_queries: usize,
+    data_path: &Path,
+    commitment_path: &Path,
+) -> Result<Commitment<Blake3>, Box<dyn std::error::Error>> {
+    // Read data from file
+    let data = read_file_to_vec(data_path)?;
 
-    let encoded_element_count =
-        encoded_data_element_count::<BaseElement>(data.len()).next_power_of_two();
+    // Create commitment from data
+    let (commitment, _) =
+        prover
+            .commit(data, num_queries)
+            .map_err(|e| -> Box<dyn std::error::Error> {
+                format!("Prover commit error: {}", e).into()
+            })?;
 
-    let (commitment, _) = prover.commit(data.clone(), num_queries).unwrap();
-    // TODO: Save commitment to file
+    // Write commitment to file
+    let commitment_bytes = commitment.to_bytes();
+    write_to_file(commitment_path, &commitment_bytes)?;
 
-    println!(
-        "Data committed with commitment: {:?} and encoded element count: {}",
-        commitment, encoded_element_count
-    );
+    println!("Commitment created and saved to {:?}", commitment_path);
+    Ok(commitment)
+}
+
+/// Reads the commitment from a file.
+pub fn read_commitment_from_file(
+    file_path: &Path,
+) -> Result<Commitment<Blake3>, Box<dyn std::error::Error>> {
+    let commitment_bytes = read_file_to_vec(file_path)?;
+    let commitment = Commitment::<Blake3>::read_from_bytes(&commitment_bytes).map_err(
+        |e| -> Box<dyn std::error::Error> { format!("Deserialization error: {}", e).into() },
+    )?;
+    Ok(commitment)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::{
+        commands::generate_data, frida_prover::traits::BaseFriProver, utils::CleanupFiles,
+    };
+    use winter_fri::FriOptions;
 
     #[test]
     fn test_commit() {
-        let data_path = "data/data.bin";
-        assert!(
-            std::path::Path::new(data_path).exists(),
-            "Test data file does not exist"
-        );
+        let data_path = Path::new("data/data.bin");
+        let commitment_path = Path::new("data/commitment.bin");
+
+        let _cleanup = CleanupFiles::new(vec![data_path, commitment_path]);
+
+        if !data_path.exists() {
+            generate_data::run(200, data_path).unwrap();
+        }
+
+        let mut prover = FridaProverType::new(FriOptions::new(8, 2, 7));
+
+        // Run the commitment process
+        let commitment = run(&mut prover, 31, data_path, commitment_path).unwrap();
 
-        let options = FriOptions::new(8, 2, 7);
-        run(data_path, 31, options);
+        // Read the commitment from the file
+        let commitment_file = read_commitment_from_file(commitment_path).unwrap();
 
-        // TODO: Check if the commitment file is correct
+        // Verify the commitment
+        assert_eq!(commitment, commitment_file, "Commitment does not match.");
     }
 }

src/commands/generate_data.rs

@@ -1,26 +1,80 @@
-use std::fs::File;
-use std::io::Write;
+use crate::utils::write_to_file;
+use std::{fs, io, path::Path};
 use winter_rand_utils::rand_vector;
 
-pub fn run(size: usize, file_path: &str) {
+pub fn run(size: usize, file_path: &Path) -> Result<Vec<u8>, GenerateDataError> {
+    // Generate random data
     let data = rand_vector::<u8>(size);
-    let mut file = File::create(file_path).expect("Unable to create file");
-    file.write_all(&data).expect("Unable to write data");
-    println!("Generated data of size {} and saved to {}", size, file_path);
+
+    // Ensure directory exists
+    if let Some(parent) = std::path::Path::new(file_path).parent() {
+        fs::create_dir_all(parent).map_err(GenerateDataError::IoError)?;
+    }
+
+    // Write data to file
+    write_to_file(file_path, &data).map_err(GenerateDataError::IoError)?;
+
+    // Print success message
+    println!(
+        "Generated data of size {} and saved to {}",
+        size,
+        file_path.display()
+    );
+
+    Ok(data)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::fs;
+    use crate::utils::{read_file_to_vec, CleanupFiles};
 
     #[test]
-    fn test_generate_data() {
+    fn test_generate_data() -> Result<(), GenerateDataError> {
         let size = 200;
-        let file_path = "data/data.bin";
-        run(size, file_path);
-        let metadata = fs::metadata(file_path).expect("Unable to read metadata");
-        assert!(metadata.is_file());
-        assert_eq!(metadata.len(), size as u64);
+        let file_path = Path::new("data/data.bin");
+
+        let _cleanup = CleanupFiles::new(vec![file_path]);
+
+        // Generate data and write to file
+        let data = run(size, file_path)?;
+
+        // Read data from file
+        let file_data = read_file_to_vec(file_path).map_err(GenerateDataError::IoError)?;
+
+        // Verify data
+        assert_eq!(data, file_data);
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub enum GenerateDataError {
+    IoError(io::Error),
+    CustomError(String),
+}
+
+impl std::fmt::Display for GenerateDataError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            GenerateDataError::IoError(ref err) => write!(f, "IO error: {}", err),
+            GenerateDataError::CustomError(ref err) => write!(f, "Custom error: {}", err),
+        }
+    }
+}
+
+impl std::error::Error for GenerateDataError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            GenerateDataError::IoError(ref err) => Some(err),
+            GenerateDataError::CustomError(_) => None,
+        }
+    }
+}
+
+impl From<io::Error> for GenerateDataError {
+    fn from(err: io::Error) -> GenerateDataError {
+        GenerateDataError::IoError(err)
     }
 }