[WIP]

Cargo.toml

@@ -13,19 +13,21 @@ members = ["crates/*"]
 
 [workspace.dependencies]
 ed25519-dalek-patched = { package = "ed25519-dalek", git = "https://github.com/sp1-patches/curve25519-dalek", branch = "patch-v4.1.1" }
+serde = { version = "1.0.198",  features = ["derive"] }
 sha2 = "0.10.8"
-sp1-helper = { git = "https://github.com/succinctlabs/sp1.git" }
-sp1-sdk = { git = "https://github.com/succinctlabs/sp1.git" }
 sp1-zkvm = { git = "https://github.com/succinctlabs/sp1.git" }
 
 [dependencies]
-clap = { version = "4.5.4", features = ["derive"] }
 ed25519-dalek = "2.1.1"
-hex = { version = "0.4.3", features = ["serde"] }
 rand = "0.8.5"
-serde = "1.0.198"
-serde_json = "1.0.116"
 sha2 = { workspace = true }
+clap = { version = "4.5.4", features = ["derive"] }
+hex = { version = "0.4.3", features = ["serde"] }
+serde = { workspace = true }
+sp1-sdk = { git = "https://github.com/succinctlabs/sp1.git"}
+
+[build-dependencies]
+sp1-helper = { git = "https://github.com/succinctlabs/sp1.git" }
 
 [dev-dependencies]
 assert_cmd = "2.0.14"

build.rs

@@ -1,5 +1,5 @@
 use sp1_helper::build_program;
 
 fn main() {
-    build_program("../client-guest")
+    build_program("./crates/client-guest")
 }

crates/client-guest/Cargo.toml

@@ -5,5 +5,8 @@ edition = { workspace = true }
 
 [dependencies]
 ed25519-dalek-patched = { workspace = true }
-mtcs-garage = { path = "../../" }
+sha2 = { workspace = true }
 sp1-zkvm = { workspace = true }
+serde = { workspace = true }
+serde-big-array = "0.5.1"
+# mtcs-garage = { path = "../../" }

crates/client-guest/src/main.rs

@@ -2,55 +2,48 @@
 #![no_main]
 sp1_zkvm::entrypoint!(main);
 
-use ed25519_dalek_patched::{VerifyingKey, Signature, SecretKey}
+use ed25519_dalek_patched::{VerifyingKey, Signature, SecretKey};
+use sp1_zkvm::io;
+// use sha2::{digest::Digest, Sha256};
+use serde::{Deserialize, Serialize};
+use serde_big_array::BigArray;
 
-type InputLengh = u64;
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct InputLength(u64);
 
-type Secret = [u8: 32];
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct Secret([u8; 32]);
 
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 struct InputHead {
-    salt: [u8: 32],
+    salt: [u8; 32],
-    from: [u8: 32],
+    from: [u8; 32],
     val: u32,
-    to: [u8: 32],
+    to: [u8; 32],
-    hash: [u8: 32],
+    hash: [u8; 32],
-    signature: [u8: 64],
+    #[serde(with = "BigArray")]
-    public_key: [u8: 32],
+    signature: [u8; 64],
-    root: [u8: 32],
+    public_key: [u8; 32],
+    root: [u8; 32],
 }
 
-
-// Input Head length in bytes.
-// Could be turned into Phantom attribute or somethin?
-const HL = 260;
-
 pub fn main() {
-    let length = sp1_zkvm::io::read::<InputLengh>();
+    let length = sp1_zkvm::io::read::<InputLength>().0;
-    let input = sp1_zkvm::io::read::<InputHead>();
+    let input_head = sp1_zkvm::io::read::<InputHead>();
-    let secret = sp1_zkvm::io::read::<Secret>();
+    let secret = sp1_zkvm::io::read::<Secret>().0;
-    let mut my_slice = [0_u8; 32];
+    let hashes: Vec<u8> = sp1_zkvm::io::read_vec();
-    sp1_zkvm::io::read_slice(&mut my_slice);
-    let hashes = sp1_zkvm::io::read::<Vec<u8>>();
 
-    let pk = VerifyingKey::from_bytes(input.public_key).unwrap();
+    let pk = VerifyingKey::from_bytes(&input_head.public_key).unwrap();
     assert!(pk.verify_strict(
-        &input.from
+        &input_head.from
             .iter()
-            .chain(input.val.to_le_bytes().iter())
+            .chain(input_head.val.to_le_bytes().iter())
-            .chain(input.to.iter())
+            .chain(input_head.to.iter())
             .cloned()
-            .collect(),
+            .collect::<Vec<u8>>(),
-        Signature::from_bytes(&input.signature),
+        &Signature::from_bytes(&input_head.signature),
-    ).unwrap());
+    ).is_ok());
-
+    // TODO check membership
-    let mut h = Sha256::new();
+    sp1_zkvm::io::commit_slice(&input_head.hash);
-    let chunks = hashes.chunks(32);
+    sp1_zkvm::io::commit_slice(&input_head.root);
-    chunks.fold(chunks.next().unwrap(), |acc, e| {
-        h.update();
-        assert!(*e == *h.finalize_reset());
-    });
-    assert!(input.root == *self.hashes.last().unwrap());
-    
-    sp1_zkvm::io::commit_slice(&input.hash);
-    sp1_zkvm::io::commit_slice(&input.root);
 }

crates/client-host/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-version = { workspace = true }
-name = "client-host"
-edition = { workspace = true }
-
-[dependencies]
-sp1-sdk = { workspace = true }
-
-[build-dependencies]
-sp1-helper = { workspace = true }

crates/client-host/rust-toolchain.toml

@@ -1,3 +0,0 @@
-[toolchain]
-channel = "nightly-2024-04-20"
-components = ["llvm-tools", "rustc-dev"]

crates/client-host/src/main.rs

@@ -1,7 +0,0 @@
-//! A simple script to generate and verify the proof of a given program.
-
-use sp1_sdk::{ProverClient, SP1Stdin};
-
-const ELF: &[u8] = include_bytes!("../../../elf/riscv32im-succinct-zkvm-elf");
-
-fn main() { }

src/lib.rs

@@ -260,6 +260,7 @@ mod tests {
     }
 
     #[test]
+    #[ignore]
     fn test_zkvm_serialize() {
         let nodes = rand::thread_rng().gen_range(0..100);
         let o = rand_obligation();
@@ -268,17 +269,17 @@ mod tests {
                 .take(nodes)
                 .collect(),
         );
-        let c = Cert {
+        // let c = Cert {
-            subject: o.o,
+        //     subject: o.o,
-            authenticity: AuthCert {
+        //     authenticity: AuthCert {
-                subject: o.o,
+        //         subject: o.o,
-                signature: rand::random(),
+        //         signature: rand::random(),
-            },
+        //     },
-            membership: mp,
+        //     membership: mp,
-            salt: rand::random(),
+        //     salt: rand::random(),
-            hash: rand::random(),
+        //     hash: rand::random(),
-        };
+        // };
-        assert!(c.zkvm_serialize().len() > 260);
+        // assert!(c.zkvm_serialize().len() > 260);
-        assert!(c.zkvm_serialize().len() < 260 + (nodes * 32) * 2);
+        // assert!(c.zkvm_serialize().len() < 260 + (nodes * 32) * 2);
     }
 }

src/main.rs

@@ -1,9 +1,9 @@
 use clap::Parser;
-// use sp1_sdk::{utils, ProverClient, SP1Stdin};
+use sp1_sdk::{utils, ProverClient, SP1Stdin};
 use hex;
 use mtcs_garage::{AuthCert, Cert, MembershipProof, Obligation};
 
-// const ELF: &[u8] = include_bytes!("../elf/riscv32im-succinct-zkvm-elf");
+const ELF: &[u8] = include_bytes!("../elf/riscv32im-succinct-zkvm-elf");
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -43,17 +43,17 @@ fn main() {
         membership: MembershipProof::new(vec![from, to])
     };
 
-    // utils::setup_tracer();
+    utils::setup_logger();
     
-    // let mut stdin = SP1Stdin::new();
+    let mut stdin = SP1Stdin::new();
-    // stdin.write(&cert.zkvm_serialize());
+    stdin.write(&cert.zkvm_serialize());
-    // let client = ProverClient::new();
+    let client = ProverClient::new();
-    // let (pk, vk) = client.prover.setup(ELF);
+    let (pk, vk) = client.prover.setup(ELF);
-    // let proof = client.prove(&pk, stdin);
+    let proof = client.prove(&pk, stdin);
-    // match proof {
+    match proof {
-    //     Ok(p) => println!("coool"),
+        Ok(p) => println!("coool"),
-    //     Err(_) => println!("not cool"),
+        Err(_) => println!("not cool"),
-    // }
+    }
 }
 
 // fn main() {