fixing commit, removing unneeded values in prover_server

src/circuits/blake2s/blake2s_comp.hpp

@@ -59,15 +59,10 @@ class BLAKE2s_256_comp : public libsnark::gadget<FieldT> {
 
     // Helper functions
     void setup_constants();
-
     void setup_h();
-
     void setup_counter(size_t len_input_block); 
-
     void setup_v();
-
     void setup_gadgets();
-
 };
 
 } // libzeth

src/circuits/blake2s/blake2s_comp.tcc

@@ -61,7 +61,6 @@ void BLAKE2s_256_comp<FieldT>::generate_r1cs_constraints(const bool ensure_outpu
 
 template<typename FieldT>
 void BLAKE2s_256_comp<FieldT>::generate_r1cs_witness(){
-
     // Format two 256 bit long big endian inputs into one 512 long little endian input (with padding if necessary)
     size_t input_size = input_block.bits.size();
     // We do not use block_size because the value might not be entered 

src/circuits/blake2s/blake2s_setup.tcc

@@ -76,7 +76,6 @@ void BLAKE2s_256_comp<FieldT>::setup_constants() {
 
 template<typename FieldT>
 void BLAKE2s_256_comp<FieldT>::setup_h() {
-
     // parameter block, size set to 32 bytes, fanout and depth set to serial mode
     std::array<std::array<FieldT,32>, 8> parameter_block;
     parameter_block[0] = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1};
@@ -91,7 +90,6 @@ void BLAKE2s_256_comp<FieldT>::setup_h() {
     for (size_t i = 0; i < 8; i++) {
         std::array<FieldT, 32> pb_swapped = swap_byte32_endianness(parameter_block[i]);
         std::array<FieldT, 32> IVi = IV[i];
-
         h[i] = binaryFieldXOR(pb_swapped, IVi);
     }
 }
@@ -128,7 +126,6 @@ void BLAKE2s_256_comp<FieldT>::setup_counter(size_t len_input_block) {
 
 template<typename FieldT>
 void BLAKE2s_256_comp<FieldT>::setup_v(){
-
     for (size_t i = 0; i < 8; i++) {
         std::vector<FieldT> temp_field_vector(h[i].begin(), h[i].end());
         v[0][i].fill_with_field_elements(this->pb, temp_field_vector);
@@ -240,7 +237,7 @@ void BLAKE2s_256_comp<FieldT>::setup_gadgets() {
             FMT(this->annotation_prefix, " xor_output_%zu", i)
         );
     }
-};
+}
 
 } //libzeth
 

src/circuits/blake2s/g_primitive.hpp

@@ -57,5 +57,4 @@ class g_primitive : public libsnark::gadget<FieldT> {
 } // libzeth
 #include "g_primitive.tcc"
 
-
 #endif // __ZETH_G_PRIMITIVE_HPP__

src/circuits/blake2s/g_primitive.tcc

@@ -73,6 +73,6 @@ void g_primitive<FieldT>::generate_r1cs_witness(){
     b1_xor_gadget->generate_r1cs_witness();
 };
 
-}
+} //namespace
 
 #endif // __ZETH_G_PRIMITIVE_TCC__

src/circuits/circuits-util.tcc

@@ -108,7 +108,6 @@ std::array<FieldT, BitLen> binaryFieldAdditionNoCarry(std::array<FieldT, BitLen>
     }
 
     std::array<FieldT, BitLen> sum = FieldT("0");
-
     FieldT carry = 0;
     for(size_t i = 0; i < BitLen; i++){
         sum[i] = A[i] + B[i] + carry - FieldT(2)*A[i]*B[i] - FieldT(2)*A[i]*carry - FieldT(2)*B[i]*carry + FieldT(4)*A[i]*B[i]*carry;
@@ -129,7 +128,6 @@ std::array<FieldT, BitLen> binaryFieldXOR(std::array<FieldT, BitLen> A, std::arr
 
     std::array<FieldT, BitLen> xor_array;
     xor_array.fill(FieldT("0"));
-
     for(size_t i = 0; i < BitLen; i++){
         xor_array[i] = A[i] + B[i] - FieldT(2)*A[i]*B[i]; // c is carry
     }

src/circuits/joinsplit.tcc

@@ -303,7 +303,7 @@ class joinsplit_gadget : libsnark::gadget<FieldT> {
                 ));
             }
 
-            // Ouput note gadgets for commitments as well as PRF gadgets for the rho_is
+            // Output note gadgets for commitments as well as PRF gadgets for the rho_is
             for (size_t i = 0; i < NumOutputs; i++) {
                 rho_i_gadgets[i].reset(new PRF_rho_gadget<FieldT, HashT>(
                     pb,

src/circuits/simple_gadgets.hpp

@@ -12,8 +12,7 @@ namespace libzeth {
 
 template<typename FieldT>
 class xor_gadget : public libsnark::gadget<FieldT> {
-    // Computes res = a XOR b
-
+// Computes res = a XOR b
 private:
     const libsnark::pb_variable_array<FieldT> a;
     const libsnark::pb_variable_array<FieldT> b;
@@ -35,7 +34,7 @@ class xor_gadget : public libsnark::gadget<FieldT> {
 
 template<typename FieldT>
 class xor_constant_gadget : public libsnark::gadget<FieldT> {
-    // Computes res = a XOR b XOR c with c constant
+// Computes res = a XOR b XOR c with c constant
 private:
     const libsnark::pb_variable_array<FieldT> a;
     const libsnark::pb_variable_array<FieldT> b;
@@ -59,8 +58,7 @@ class xor_constant_gadget : public libsnark::gadget<FieldT> {
 
 template<typename FieldT>
 class xor_rot_gadget : public libsnark::gadget<FieldT> {
-    // Computes a XOR b and rotate it by shift
-
+// Computes a XOR b and rotate it by shift
 private:
     const libsnark::pb_variable_array<FieldT> a;
     const libsnark::pb_variable_array<FieldT> b;
@@ -84,10 +82,10 @@ class xor_rot_gadget : public libsnark::gadget<FieldT> {
 
 template<typename FieldT>
 class double_bit32_sum_eq_gadget : public libsnark::gadget<FieldT> {
-    /*
-    Gadget checking that res = a + b % 2**32
-    with a, b and res being modulo bit long arrays
-    */
+/*
+Gadget checking that res = a + b % 2**32
+with a, b and res being modulo bit long arrays
+*/
 private:
     libsnark::pb_variable_array<FieldT> a;
     libsnark::pb_variable_array<FieldT> b;
@@ -102,12 +100,10 @@ class double_bit32_sum_eq_gadget : public libsnark::gadget<FieldT> {
                 const std::string &annotation_prefix = "double_bit32_sum_eq_gadget");
 
     void generate_r1cs_constraints(bool enforce_boolean = true);
-
     void generate_r1cs_witness(); 
 };
 
 } // libzeth
 #include "simple_gadgets.tcc"
 
-
 #endif // __ZZETH_SIMPLE_GADGETS_HPP__

src/circuits/simple_gadgets.tcc

@@ -27,16 +27,15 @@ xor_gadget<FieldT>::xor_gadget(
 template<typename FieldT>
 void xor_gadget<FieldT>::generate_r1cs_constraints() {
     // 32 constraints
-
     for (size_t i = 0; i < a.size(); i++) {
         this->pb.add_r1cs_constraint(
             libsnark::r1cs_constraint<FieldT>(
                 -2*a[i],
                 b[i],
                 res[i] - a[i] - b[i]
-                ),
-                FMT(this->annotation_prefix, " rotated_xored_bits_%zu", i)
-            );
+            ),
+            FMT(this->annotation_prefix, " rotated_xored_bits_%zu", i)
+        );
     }
 };
 
@@ -72,7 +71,6 @@ xor_constant_gadget<FieldT>::xor_constant_gadget(
 template<typename FieldT>
 void xor_constant_gadget<FieldT>::generate_r1cs_constraints() {
     // 32 constraints
-
     for (size_t i = 0; i < a.size(); i++) {
         this->pb.add_r1cs_constraint(
             libsnark::r1cs_constraint<FieldT>(
@@ -120,7 +118,6 @@ xor_rot_gadget<FieldT>::xor_rot_gadget(
 template<typename FieldT>
 void xor_rot_gadget<FieldT>::generate_r1cs_constraints() {
     // 32 constraints
-
     for (size_t i = 0; i < a.size(); i++) {
         this->pb.add_r1cs_constraint(
             libsnark::r1cs_constraint<FieldT>(
@@ -136,7 +133,6 @@ void xor_rot_gadget<FieldT>::generate_r1cs_constraints() {
 template<typename FieldT>
 void xor_rot_gadget<FieldT>::generate_r1cs_witness(){
     // 32 constraints
-
     for (size_t i = 0; i < a.size(); i++) {
         if ( this->pb.val(a[i]) == FieldT("1") && this->pb.val(b[i]) == FieldT("1")){
             this->pb.val(res[(i + shift) % a.size()]) = FieldT("0");
@@ -165,7 +161,6 @@ double_bit32_sum_eq_gadget<FieldT>::double_bit32_sum_eq_gadget(
 template<typename FieldT>
 void double_bit32_sum_eq_gadget<FieldT>::generate_r1cs_constraints(bool enforce_boolean) {
     // 33 constraints (32 +1)
-
     if (enforce_boolean){
         for (size_t i = 0; i < 32; i++) {
             libsnark::generate_boolean_r1cs_constraint<FieldT>(
@@ -198,15 +193,12 @@ void double_bit32_sum_eq_gadget<FieldT>::generate_r1cs_witness()
     }
 
     bits32 left_side_acc = binaryAdditionNoCarry<32>(a_bits32, b_bits32);
-
     res.fill_with_bits(
         this->pb,
         get_vector_from_bits32(left_side_acc)
     );
 };
 
-
 } // libzeth
 
-
 #endif // __ZZETH_SIMPLE_GADGETS_TCC__

src/test/prover_test.cpp

@@ -104,19 +104,18 @@ bool TestValidJS2In2Case1(
     libff::enter_block("[BEGIN] Create JSOutput/ZethNote", true);
     bits64 value_out_bits64 = get_bits64_from_vector(hexadecimal_str_to_binary_vector("1800000000000008"));
     bits256 a_pk_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("7777f753bfe21ba2219ced74875b8dbd8c114c3c79d7e41306dd82118de1895b"));
-    bits256 rho0_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("f5ebdbbce5b5c18079210e050e34bd541c8a441205c855ad76fb4b007ce67f93"));
-    bits256 rho1_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("5677133e3ea3cf98f7562fb7ad9b833a57da76866dd15694ca2de4da89e601f5"));
+    bits256 rho_out_bits256;
     bits384 trap_r_out_bits384 = get_bits384_from_vector(hexadecimal_str_to_binary_vector("11000000000000990000000000000099000000000000007700000000000000FF00000000000000FF0000000000000777"));
     ZethNote note_output(
         a_pk_out_bits256,
         value_out_bits64,
-        rho0_out_bits256,
+        rho_out_bits256,
         trap_r_out_bits384
     );
     ZethNote note_dummy_output(
         a_pk_out_bits256,
         get_bits64_from_vector(hexadecimal_str_to_binary_vector("0000000000000000")),
-        rho1_out_bits256,
+        rho_out_bits256,
         trap_r_out_bits384
     );
     bits64 value_pub_out_bits64 = get_bits64_from_vector(hexadecimal_str_to_binary_vector("1700000000000007"));
@@ -226,7 +225,7 @@ bool TestValidJS2In2Case2(
 
     libff::enter_block("[BEGIN] Create JSOutput/ZethNote", true);
     bits256 a_pk_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("7777f753bfe21ba2219ced74875b8dbd8c114c3c79d7e41306dd82118de1895b"));
-    bits256 rho_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("1111000000000000000000000000000000000000000000000000000000009777"));
+    bits256 rho_out_bits256;
     bits384 trap_r_out_bits384 = get_bits384_from_vector(hexadecimal_str_to_binary_vector("11000000000000990000000000000099000000000000007700000000000000FF00000000000000FF0000000000000777"));
     ZethNote note_output0(
         a_pk_out_bits256,
@@ -344,7 +343,7 @@ bool TestValidJS2In2Case3(
 
     libff::enter_block("[BEGIN] Create JSOutput/ZethNote", true);
     bits256 a_pk_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("7777f753bfe21ba2219ced74875b8dbd8c114c3c79d7e41306dd82118de1895b"));
-    bits256 rho_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("1111000000000000000000000000000000000000000000000000000000009777"));
+    bits256 rho_out_bits256;
     bits384 trap_r_out_bits384 = get_bits384_from_vector(hexadecimal_str_to_binary_vector("11000000000000990000000000000099000000000000007700000000000000FF00000000000000FF0000000000000777"));
     ZethNote note_output0(
         a_pk_out_bits256,
@@ -460,7 +459,7 @@ bool TestValidJS2In2Deposit(
 
     libff::enter_block("[BEGIN] Create JSOutput/ZethNote", true);
     bits256 a_pk_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("7777f753bfe21ba2219ced74875b8dbd8c114c3c79d7e41306dd82118de1895b"));
-    bits256 rho_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("1111000000000000000000000000000000000000000000000000000000009777"));
+    bits256 rho_out_bits256;
     bits384 trap_r_out_bits384 = get_bits384_from_vector(hexadecimal_str_to_binary_vector("11000000000000990000000000000099000000000000007700000000000000FF00000000000000FF0000000000000777"));
     ZethNote note_output0(
         a_pk_out_bits256,
@@ -578,7 +577,7 @@ bool TestInvalidJS2In2(
 
     libff::enter_block("[BEGIN] Create JSOutput/ZethNote", true);
     bits256 a_pk_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("7777f753bfe21ba2219ced74875b8dbd8c114c3c79d7e41306dd82118de1895b"));
-    bits256 rho_out_bits256 = get_bits256_from_vector(hexadecimal_digest_to_binary_vector("1111000000000000000000000000000000000000000000000000000000009777"));
+    bits256 rho_out_bits256;
     bits384 trap_r_out_bits384 = get_bits384_from_vector(hexadecimal_str_to_binary_vector("11000000000000990000000000000099000000000000007700000000000000FF00000000000000FF0000000000000777"));
     ZethNote note_output0(
         a_pk_out_bits256,

src/test/simple_gadget_test.cpp

@@ -59,10 +59,8 @@ TEST(TestXOR, TestTrue) {
     );
 
     ASSERT_EQ(expected.get_bits(pb), xored.get_bits(pb));
-
 }
 
-
 TEST(TestXORConstant, TestTrue) {
     libsnark::protoboard<FieldT> pb;
     libsnark::pb_variable<FieldT> ZERO;
@@ -101,7 +99,6 @@ TEST(TestXORConstant, TestTrue) {
     xor_constant_gadget<FieldT> xor_c_gadget(pb, a, b, c, xored);
     xor_c_gadget.generate_r1cs_constraints();
     xor_c_gadget.generate_r1cs_witness();
-
 
     libsnark::pb_variable_array<FieldT> expected = from_bits(
         {
@@ -111,9 +108,8 @@ TEST(TestXORConstant, TestTrue) {
             1, 0, 1, 0, 1, 0, 1, 0  // AA
         }, ZERO
     );  
-
-    ASSERT_EQ(expected.get_bits(pb), xored.get_bits(pb));
 
+    ASSERT_EQ(expected.get_bits(pb), xored.get_bits(pb));
 }
 
 TEST(Testxor_rot, TestTrue) {
@@ -217,7 +213,6 @@ TEST(Testxor_rot, TestTrue) {
     ASSERT_EQ(expected16.get_bits(pb), rot16.get_bits(pb));
     ASSERT_EQ(expected24.get_bits(pb), rot24.get_bits(pb));
     ASSERT_EQ(expected0.get_bits(pb), rot32.get_bits(pb));
-
 }
 
 TEST(Testdouble_packed, TestTrue) {
@@ -259,6 +254,7 @@ TEST(Testdouble_packed, TestTrue) {
             1, 1, 1, 0, 0, 0, 0, 0  // E0
         }, ZERO
     );
+
     ASSERT_EQ(expected.get_bits(pb), add.get_bits(pb));
 }