Merge pull request #21 from ZencashOfficial/issue#19/return_constant

Issue#19/return constant

Author: albertog78

api/src/ginger_calls.rs

@@ -251,12 +251,6 @@ pub fn create_naive_threshold_sig_proof(
     //Compute b as v-t and convert it to field element
     let b = read_field_element_from_u64(valid_signatures - threshold);
 
-    //Compute wcert_sysdata_hash
-    let wcert_sysdata_hash = compute_wcert_sysdata_hash(valid_signatures, &mr_bt, &prev_end_epoch_mc_b_hash, &end_epoch_mc_b_hash)?;
-
-    //Compute pks_threshold_hash
-    let pks_threshold_hash = compute_pks_threshold_hash(pks, threshold)?;
-
     //Convert affine pks to projective
     let pks = pks.iter().map(|&pk| pk.into_projective()).collect::<Vec<_>>();
 
@@ -265,8 +259,7 @@ pub fn create_naive_threshold_sig_proof(
 
     let c = NaiveTresholdSignature::<FieldElement>::new(
         pks, sigs, threshold, b, end_epoch_mc_b_hash,
-        prev_end_epoch_mc_b_hash, mr_bt, pks_threshold_hash,
-        wcert_sysdata_hash, max_pks,
+        prev_end_epoch_mc_b_hash, mr_bt, max_pks,
     );
 
     //Read proving key
@@ -278,48 +271,27 @@ pub fn create_naive_threshold_sig_proof(
     Ok((proof, valid_signatures))
 }
 
-//Return (wcert_sysdata_hash, pk_threshold_hash)
-pub fn get_public_inputs_for_naive_threshold_sig_proof(
-    pks:                      &[SchnorrPk],
-    threshold:                u64,
+pub fn verify_naive_threshold_sig_proof(
+    constant:                 &FieldElement,
     end_epoch_mc_b_hash:      &[u8; 32],
     prev_end_epoch_mc_b_hash: &[u8; 32],
     bt_list:                  &[BackwardTransfer],
     valid_sigs:               u64,
-) -> Result<(FieldElement, FieldElement), Error> {
-
+    proof:                    &SCProof,
+    vk_path:                  &str,
+) -> Result<bool, Error>
+{
+    //Compute wcert_sysdata_hash
     let end_epoch_mc_b_hash = read_field_element_from_buffer_with_padding(&end_epoch_mc_b_hash[..])?;
     let prev_end_epoch_mc_b_hash = read_field_element_from_buffer_with_padding(&prev_end_epoch_mc_b_hash[..])?;
     let (mr_bt, _) = compute_msg_to_sign(&end_epoch_mc_b_hash, &prev_end_epoch_mc_b_hash, bt_list)?;
     let wcert_sysdata_hash = compute_wcert_sysdata_hash(valid_sigs, &mr_bt, &prev_end_epoch_mc_b_hash, &end_epoch_mc_b_hash)?;
-    let pks_threshold_hash = compute_pks_threshold_hash(pks, threshold)?;
+    let aggregated_input = compute_poseidon_hash(&[*constant, wcert_sysdata_hash])?;
 
-    Ok((wcert_sysdata_hash, pks_threshold_hash))
-}
-
-pub fn verify_naive_threshold_sig_proof(
-    pks:                      &[SchnorrPk],
-    threshold:                u64,
-    end_epoch_mc_b_hash:      &[u8; 32],
-    prev_end_epoch_mc_b_hash: &[u8; 32],
-    bt_list:                  &[BackwardTransfer],
-    valid_sigs:               u64,
-    proof:                    SCProof,
-    vk_path:                  &str,
-) -> Result<bool, Error>
-{
     //Verify proof
-    let (wcert_sysdata_hash, pks_threshold_hash) = get_public_inputs_for_naive_threshold_sig_proof(
-        &pks,
-        threshold,
-        &end_epoch_mc_b_hash,
-        &prev_end_epoch_mc_b_hash,
-        bt_list,
-        valid_sigs
-    )?;
     let vk = read_from_file(vk_path)?;
     let pvk = prepare_verifying_key(&vk); //Get verifying key
-    let is_verified = verify_proof(&pvk, &proof, &[pks_threshold_hash, wcert_sysdata_hash])?;
+    let is_verified = verify_proof(&pvk, &proof, &[aggregated_input])?;
 
     Ok(is_verified)
 }
@@ -387,7 +359,7 @@ pub fn vrf_proof_to_hash(msg: &FieldElement, pk: &VRFPk, proof: &VRFProof) -> Re
 pub struct FieldBasedMerkleTreeParams;
 
 impl FieldBasedMerkleTreeConfig for FieldBasedMerkleTreeParams {
-    const HEIGHT: usize = 9;
+    const HEIGHT: usize = 13;
     type H = MNT4PoseidonHash;
 }
 
@@ -429,6 +401,21 @@ mod test {
         Ok(())
     }
 
+    #[allow(dead_code)]
+    fn into_i8(v: Vec<u8>) -> Vec<i8> {
+        // first, make sure v's destructor doesn't free the data
+        // it thinks it owns when it goes out of scope
+        let mut v = std::mem::ManuallyDrop::new(v);
+
+        // then, pick apart the existing Vec
+        let p = v.as_mut_ptr();
+        let len = v.len();
+        let cap = v.capacity();
+
+        // finally, adopt the data into a new Vec
+        unsafe { Vec::from_raw_parts(p as *mut i8, len, cap) }
+    }
+
     #[test]
     fn create_sample_naive_threshold_sig_circuit() {
         //assume to have 3 pks, threshold = 2
@@ -478,6 +465,8 @@ mod test {
         sigs.push(None);
         sigs.push(Some(schnorr_sign(&msg, &sks[2], &pks[2]).unwrap()));
 
+        let constant = compute_pks_threshold_hash(pks.as_slice(), threshold).unwrap();
+
         //Create and serialize proof
         let (proof, quality) = create_naive_threshold_sig_proof(
             pks.as_slice(),
@@ -492,27 +481,27 @@ mod test {
         write_to_file(&proof, proof_path).unwrap();
 
         //Verify proof
-        let (wcert_sysdata_hash, pks_threshold_hash) = get_public_inputs_for_naive_threshold_sig_proof(
-            &pks,
-            threshold,
+        assert!(verify_naive_threshold_sig_proof(
+            &constant,
             &end_epoch_mc_b_hash,
             &prev_end_epoch_mc_b_hash,
             bt_list.as_slice(),
-            quality
-        ).unwrap();
-        let pvk = prepare_verifying_key(&params.vk); //Get verifying key
-        assert!(verify_proof(&pvk, &proof, &[pks_threshold_hash, wcert_sysdata_hash]).unwrap()); //Assert proof verification passes
+            quality,
+            &proof,
+            "./sample_vk",
+        ).unwrap());
 
-        //Generate wrong public inputs by changing threshold and valid sigs and assert proof verification doesn't pass
-        let (wrong_wcert_sysdata_hash, wrong_pks_threshold_hash) = get_public_inputs_for_naive_threshold_sig_proof(
-            &pks,
-            1,
+
+        //Generate wrong public inputs by changing quality and assert proof verification doesn't pass
+        assert!(!verify_naive_threshold_sig_proof(
+            &constant,
             &end_epoch_mc_b_hash,
             &prev_end_epoch_mc_b_hash,
             bt_list.as_slice(),
-            quality - 1
-        ).unwrap();
-        assert!(!verify_proof(&pvk, &proof, &[wrong_pks_threshold_hash, wrong_wcert_sysdata_hash]).unwrap()); //Assert proof verification passes
+            quality - 1,
+            &proof,
+            "./sample_vk",
+        ).unwrap());
     }
 
     #[test]

api/src/lib.rs

@@ -1007,6 +1007,58 @@ pub extern "system" fn Java_com_horizen_vrfnative_VRFPublicKey_nativeProofToHash
     *result
 }
 
+//Naive threshold signature proof functions
+#[no_mangle]
+pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_nativeGetConstant(
+    _env: JNIEnv,
+    // this is the class that owns our
+    // static method. Not going to be
+    // used, but still needs to have
+    // an argument slot
+    _class: JClass,
+    _schnorr_pks_list: jobjectArray,
+    _threshold: jlong,
+) -> jobject
+{
+    //Extract Schnorr pks
+    let mut pks = vec![];
+
+    let pks_list_size = _env.get_array_length(_schnorr_pks_list)
+        .expect("Should be able to get schnorr_pks_list size");
+
+    for i in 0..pks_list_size {
+
+        let pk_object = _env.get_object_array_element(_schnorr_pks_list, i)
+            .expect(format!("Should be able to get elem {} of schnorr_pks_list", i).as_str());
+
+        let pk = _env.get_field(pk_object, "publicKeyPointer", "J")
+            .expect("Should be able to get field publicKeyPointer");
+
+        pks.push(*read_raw_pointer(pk.j().unwrap() as *const SchnorrPk));
+    }
+
+    //Extract threshold
+    let threshold = _threshold as u64;
+
+    //Compute constant
+    let constant = match compute_pks_threshold_hash(pks.as_slice(), threshold){
+        Ok(constant) => constant,
+        Err(_) => return std::ptr::null::<jobject>() as jobject //CRYPTO_ERROR
+    };
+
+    //Return constant
+    let field_ptr: jlong = jlong::from(Box::into_raw(Box::new(constant)) as i64);
+
+    let field_class =  _env.find_class("com/horizen/librustsidechains/FieldElement")
+        .expect("Should be able to find FieldElement class");
+
+    let result = _env.new_object(field_class, "(J)V", &[
+        JValue::Long(field_ptr)]).expect("Should be able to create new long for FieldElement");
+
+    *result
+}
+
+
 #[no_mangle]
 pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_nativeCreateMsgToSign(
     _env: JNIEnv,
@@ -1101,7 +1153,6 @@ pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_na
     *result
 }
 
-//Naive threshold signature proof functions
 #[no_mangle]
 pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_nativeCreateProof(
     _env: JNIEnv,
@@ -1270,10 +1321,9 @@ pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_na
     // an argument slot
     _class: JClass,
     _bt_list: jobjectArray,
-    _schnorr_pks_list:  jobjectArray,
     _end_epoch_block_hash: jbyteArray,
     _prev_end_epoch_block_hash: jbyteArray,
-    _threshold: jlong,
+    _constant: JObject,
     _quality: jlong,
     _sc_proof_bytes: jbyteArray,
     _verification_key_path: JString
@@ -1310,23 +1360,6 @@ pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_na
         bt_list.push(BackwardTransfer::new(pk, a));
     }
 
-    //Extract Schnorr pks
-    let mut pks = vec![];
-
-    let pks_list_size = _env.get_array_length(_schnorr_pks_list)
-        .expect("Should be able to get schnorr_pks_list size");
-
-    for i in 0..pks_list_size {
-
-        let pk_object = _env.get_object_array_element(_schnorr_pks_list, i)
-            .expect(format!("Should be able to get elem {} of schnorr_pks_list", i).as_str());
-
-        let pk = _env.get_field(pk_object, "publicKeyPointer", "J")
-            .expect("Should be able to get field publicKeyPointer");
-
-        pks.push(*read_raw_pointer(pk.j().unwrap() as *const SchnorrPk));
-    }
-
     //Extract block hashes
     let end_epoch_block_hash = {
         let t = _env.convert_byte_array(_end_epoch_block_hash)
@@ -1352,8 +1385,16 @@ pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_na
         prev_end_epoch_block_hash_bytes
     };
 
-    //Extract threshold and quality
-    let threshold = _threshold as u64;
+    //Extract constant
+    let constant = {
+
+        let c =_env.get_field(_constant, "fieldElementPointer", "J")
+            .expect("Should be able to get field fieldElementPointer");
+
+        read_raw_pointer(c.j().unwrap() as *const FieldElement)
+    };
+
+    //Extract quality
     let quality = _quality as u64;
 
     //Extract proof
@@ -1370,13 +1411,12 @@ pub extern "system" fn Java_com_horizen_sigproofnative_NaiveThresholdSigProof_na
 
     //Verify proof
     match verify_naive_threshold_sig_proof(
-        pks.as_slice(),
-        threshold,
+        constant,
         &end_epoch_block_hash,
         &prev_end_epoch_block_hash,
         bt_list.as_slice(),
         quality,
-        proof,
+        &proof,
         vk_path.to_str().unwrap()
     ) {
         Ok(result) => if result { JNI_TRUE } else { JNI_FALSE },

build_jar.sh

@@ -0,0 +1,14 @@
+cargo clean
+
+cargo build --release --target=x86_64-pc-windows-gnu
+cargo build --release --target=x86_64-unknown-linux-gnu
+
+
+mkdir -p jni/src/main/resources/native/linux64
+cp target/x86_64-unknown-linux-gnu/release/libzendoo_sc.so jni/src/main/resources/native/linux64/libzendoo_sc.so
+
+mkdir -p jni/src/main/resources/native/windows64
+cp target/x86_64-pc-windows-gnu/release/zendoo_sc.dll jni/src/main/resources/native/windows64/zendoo_sc.dll
+
+cd jni
+mvn clean package