feat: debug success & Demo version 0.1.0

Author: zTgx

src/main.cpp

@@ -1,11 +1,8 @@
-#include <rust/include/librustbellman.h>
 #include <verifier.h>
 #include <transaction.h>
 #include <iostream>
 
 int main(int argc, char** argv) {
-    hello_world();
-
     // transaction needed to be verified
     auto tx = Transaction::Mock();
 

src/prove.cpp

@@ -10,12 +10,19 @@ Prove::initContext() {
     unsigned char* zkproof = (unsigned char*)malloc(GROTH_PROOF_SIZE);
     unsigned char* inputs = (unsigned char*)"this is payment address, so let's get started it.";
 
-    librust_proof(ctx, inputs, zkproof);
+    bool proof_ret = librust_proof(ctx, inputs, zkproof);
+    std::cout << "proof ret: " << std::boolalpha << proof_ret << std::endl;
+    std::cout << "proof : " << zkproof << std::endl;
+    
+    librust_proving_ctx_free(ctx);
 
     auto ctx_verify = librust_verification_ctx_init();
-    bool check_ret = librust_verification_check(ctx_verify, (const char*)zkproof, (const char*)inputs);
-    std::cout << "proof check result: " << std::boolalpha << check_ret << std::endl;
+
+    bool check_ret = false;
+    std::cout << "check_ret init status = " << std::boolalpha << check_ret << std::endl;
+    check_ret = librust_verification_check(ctx_verify, (const char*)zkproof, (const char*)inputs);
+    std::cout << "update check result: " << std::boolalpha << check_ret << std::endl;
+
     librust_verification_ctx_free(ctx_verify);
 
-    librust_proving_ctx_free(ctx);
 }

src/rust/Cargo.toml

@@ -15,6 +15,7 @@ bls12_381 = "0.5"
 sha2 = "0.9.5"
 rand = "0.8.4"
 libc = "0.2.97"
+ff = "0.10"
 
 
 # https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html

src/rust/examples/tx.rs

@@ -0,0 +1,5 @@
+use crate::proof;
+
+pub fn main() {
+
+}

src/rust/include/librustbellman.h

@@ -4,8 +4,6 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-    void hello_world();
-
     /// Creates a proving context. Please free this when you're done.
     void * librust_proving_ctx_init(); 
 
@@ -21,11 +19,13 @@ extern "C" {
 
     /// Checks the validity of the
     /// transaction given the binding signature.
-    bool librust_verification_check(void *, const char* proof, const char* inputs);
+    bool librust_verification_check(void *ctx, const char* proof, const char* inputs);
 
     /// Frees a verification context.
     void librust_verification_ctx_free(void *);
 
+    void hello_world();
+
 #ifdef __cplusplus
 }
 #endif

src/rust/src/circuit/tx.rs

@@ -9,13 +9,38 @@ use bellman::{
     groth16, Circuit, ConstraintSystem, SynthesisError,
 };
 use sha2::{Digest, Sha256};
+use ff::PrimeField;
 
 pub struct Amount {
     // pub pay_address: Option<[u8; 2]>,
     // pub value: String,
     // pub out_address: String,
 }
 
+fn sha256d<Scalar: PrimeField, CS: ConstraintSystem<Scalar>>(
+    mut cs: CS,
+    data: &[Boolean],
+) -> Result<Vec<Boolean>, SynthesisError> {
+    // Flip endianness of each input byte
+    let input: Vec<_> = data
+        .chunks(8)
+        .map(|c| c.iter().rev())
+        .flatten()
+        .cloned()
+        .collect();
+
+    let mid = sha256(cs.namespace(|| "SHA-256(input)"), &input)?;
+    let res = sha256(cs.namespace(|| "SHA-256(mid)"), &mid)?;
+
+    // Flip endianness of each output byte
+    Ok(res
+        .chunks(8)
+        .map(|c| c.iter().rev())
+        .flatten()
+        .cloned()
+        .collect())
+}
+
 pub struct Tx {
     // pub hash: String,
     // pub amount: Amount,
@@ -55,14 +80,7 @@ impl Circuit<bls12_381::Scalar> for Tx {
             .collect::<Result<Vec<_>, _>>()?;
 
         // Compute hash = SHA-256(preimage).
-        let hash = sha256(cs.namespace(|| "SHA-256(mid)"), &preimage_bits)?;
-
-        // let public_input = hash
-        // .chunks(8)
-        // .map(|c| c.iter().rev())
-        // .flatten()
-        // .cloned()
-        // .collect();
+        let hash = sha256d(cs.namespace(|| "SHA-256(preimage)"), &preimage_bits)?;
 
         // Expose the vector of 32 boolean variables as compact public inputs.
         multipack::pack_into_inputs(cs.namespace(|| "pack hash"), &hash)

src/rust/src/lib.rs

@@ -1,8 +1,3 @@
-#[no_mangle]
-pub extern "C" fn hello_world() {
-    println!("Hello world from Bellman.");
-}
-
 #[cfg(test)]
 mod tests {
     #[test]

src/rust/src/librustbellman.rs

@@ -1,13 +1,10 @@
-
-use crate::circuit::tx::Tx;
 use bellman::groth16;
 use bls12_381::Bls12;
-use rand::rngs::OsRng;
-use sha2::{Digest, Sha256};
 use libc::{c_char, c_uchar};
 use std::ffi::CStr;
 use crate::proof::VerificationContext;
 use crate::proof::ProvingContext;
+use std::io::{self, Write};
 
 static mut PVK: Option<groth16::PreparedVerifyingKey<Bls12>> = None;
 
@@ -27,13 +24,13 @@ pub extern "C" fn librust_proving_ctx_init() -> *mut ProvingContext {
 
 #[no_mangle]
 pub extern "C" fn librust_proof(ctx: *mut ProvingContext, inputs: *const c_char, zkproof: *mut [c_uchar; GROTH_PROOF_SIZE]) -> bool {
-
     let s = unsafe {
         CStr::from_ptr(inputs).to_string_lossy().into_owned()
     };
 
     let mut a: [u8; 33] = [0u8;33];
     a.copy_from_slice(&s.as_bytes()[0..33]);
+    println!("inputs : {:?}", a);
 
     let (proof, pvk) = unsafe { &mut *ctx }.spend_proof(a);
 
@@ -42,6 +39,8 @@ pub extern "C" fn librust_proof(ctx: *mut ProvingContext, inputs: *const c_char,
     .write(&mut (unsafe { &mut *zkproof })[..])
     .expect("should be able to serialize a proof");
 
+    // println!("zkproof : {:?}", zkproof);
+
     // Write pvk out to caller
     // use of mutable static is unsafe and requires unsafe function or block
     unsafe {
@@ -61,12 +60,8 @@ pub extern "C" fn librust_proving_ctx_free(ctx: *mut ProvingContext) {
     }
 }
 
-////
-/// 
-/// 
-
 #[no_mangle]
-pub extern "C" fn librust_verification_ctx_init()  -> *mut VerificationContext {
+pub extern "C" fn librust_verification_ctx_init() -> *mut VerificationContext {
     let ctx = Box::new(VerificationContext::new());
 
     Box::into_raw(ctx)
@@ -78,7 +73,10 @@ pub extern "C" fn librust_verification_check(ctx: *mut VerificationContext, proo
     let proof = unsafe { CStr::from_ptr(proof) };
     let inputs = unsafe { CStr::from_ptr(inputs) };
 
-    unsafe { &mut *ctx }.verify_proof(pvk, proof.to_bytes(), inputs.to_bytes())
+    let proof  = proof.to_bytes();
+    let inputs = inputs.to_bytes();
+
+    unsafe { &mut *ctx }.verify_proof(pvk, proof, inputs)
 }
 
 #[no_mangle]
@@ -88,4 +86,9 @@ pub extern "C" fn librust_verification_ctx_free(ctx: *mut VerificationContext) {
     unsafe {
         drop(Box::from_raw(ctx));
     }
+}
+
+#[no_mangle]
+pub extern "C" fn hello_world() {
+    println!("Hello world from Bellman.");
 }

src/rust/src/proof.rs

@@ -21,8 +21,6 @@ impl ProvingContext {
     }
 
     pub fn spend_proof(&self, inputs: [u8; 33]) -> (groth16::Proof<Bls12>, groth16::PreparedVerifyingKey<Bls12>) {
-        println!("spend proof.");
-
         let preimage = inputs;
 
         // Create parameters for our circuit. In a production deployment these would
@@ -36,16 +34,66 @@ impl ProvingContext {
         let pvk = groth16::prepare_verifying_key(&params.vk);
 
         // Pick a preimage and compute its hash.
-        let hash = Sha256::digest(&preimage);
+        let hash = Sha256::digest(&Sha256::digest(&preimage));
 
         // Create an instance of our circuit (with the preimage as a witness).
         let c = Tx {
             pay_address: Some(preimage),
         };
 
+        // let hash_bits = multipack::bytes_to_bits_le(&hash);
+        // let inputs = multipack::compute_multipacking(&hash_bits);
+    
+        // Check the proof!
+        let p = groth16::create_random_proof(c, &params, &mut OsRng).unwrap();
+        // let ret = groth16::verify_proof(&pvk, &p, &inputs[..]).is_ok();
+        // assert!(ret);
+
+        // let c = Tx {
+        //     pay_address: None,
+        // };
+
         // Create a Groth16 proof with our parameters.
-        (groth16::create_random_proof(c, &params, &mut OsRng).unwrap(), pvk)
+        (p, pvk)
     }
+
+    // pub fn spend_proof(&self, inputs: [u8; 33]) -> (groth16::Proof<Bls12>, groth16::PreparedVerifyingKey<Bls12>) {
+    //     let params = {
+    //         let c = Tx { pay_address: None };
+    //         groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap()
+    //     };
+    
+    //     // Prepare the verification key (for proof verification).
+    //     let pvk = groth16::prepare_verifying_key(&params.vk);
+    
+    //     // Pick a preimage and compute its hash.
+    //     let preimage = [42; 33];
+    //     let hash = Sha256::digest(&Sha256::digest(&preimage));
+    
+    //     // Create an instance of our circuit (with the preimage as a witness).
+    //     let c = Tx {
+    //         pay_address: Some(preimage),
+    //     };
+    
+    //     // Create a Groth16 proof with our parameters.
+    //     let proof = groth16::create_random_proof(c, &params, &mut OsRng).unwrap();
+    
+    //     // Pack the hash as inputs for proof verification.
+    //     let hash_bits = multipack::bytes_to_bits_le(&hash);
+    //     let inputs = multipack::compute_multipacking(&hash_bits);
+    
+    //     // Check the proof!
+    //     assert!(groth16::verify_proof(&pvk, &proof, &inputs).is_ok());
+
+        
+    //     let c = Tx {
+    //         pay_address: None,
+    //     };
+
+    //     // Create a Groth16 proof with our parameters.
+    //     (groth16::create_random_proof(c, &params, &mut OsRng).unwrap(), pvk)
+
+    // }
 }
 
 pub struct VerificationContext {}
@@ -55,15 +103,27 @@ impl VerificationContext {
     }
 
     pub fn verify_proof(&self, pvk: &groth16::PreparedVerifyingKey<Bls12>, proof: &[u8], inputs: &[u8]) -> bool {
-        let proof_data = groth16::Proof::<Bls12>::read(&(unsafe { &*proof })[..]);
-        if let Ok(proof) = proof_data {
-            let hash_bits = multipack::bytes_to_bits_le(&inputs);
+        println!("----------");
+
+        let proof_data = groth16::Proof::read( &*proof );
+        if let Ok(proof) = proof_data {            
+            let mut a: [u8; 33] = [0u8;33];
+            a.copy_from_slice(&inputs[0..33]);
+            
+            let hash = Sha256::digest(&Sha256::digest(&a));
+
+            let hash_bits = multipack::bytes_to_bits_le(&hash);
             let inputs = multipack::compute_multipacking(&hash_bits);
 
+            println!("is ok");
             // Check the proof!
             return groth16::verify_proof(&pvk, &proof, &inputs).is_ok();    
+        } else {
+            println!("read proof error.");
         }
 
-        return false;
+        println!("is false");
+
+        false
     }
 }