add larger poseidon merkle tree example

Author: CblPOK-git

examples/cpp/CMakeLists.txt

@@ -147,6 +147,7 @@ add_example_with_proving(arithmetics_cpp_example SOURCES arithmetics.cpp INPUT a
 add_example_with_proving(integer_arithmetics_cpp_example SOURCES integer_arithmetics.cpp INPUT integer_arithmetics.inp CURVE_TYPE pallas TBL_GEN_SPEED fast)
 add_example_with_proving(poseidon_cpp_example SOURCES poseidon.cpp INPUT poseidon.inp CURVE_TYPE pallas TBL_GEN_SPEED fast)
 add_example_with_proving_and_recursion(merkle_tree_poseidon_cpp_example SOURCES merkle_tree_poseidon.cpp INPUT merkle_tree_poseidon.inp CURVE_TYPE pallas TBL_GEN_SPEED fast)
+# add_example_with_proving(merkle_tree_poseidon_large_cpp_example SOURCES merkle_tree_poseidon_large.cpp INPUT merkle_tree_poseidon_large.inp CURVE_TYPE pallas TBL_GEN_SPEED fast)
 add_example_with_proving(merkle_poseidon_1prover_cpp_example SOURCES merkle_poseidon_1prover.cpp INPUT merkle_poseidon_1prover_public.inp PRIVATE_INPUT merkle_poseidon_1prover_private.inp CURVE_TYPE pallas TBL_GEN_SPEED fast)
 add_example_with_proving(merkle_poseidon_2provers_cpp_example SOURCES merkle_poseidon_2provers.cpp INPUT merkle_poseidon_2provers_public.inp PRIVATE_INPUT merkle_poseidon_2provers_private.inp CURVE_TYPE pallas MAX_NUM_PROVERS 2 TBL_GEN_SPEED fast)
 add_example_with_proving_and_recursion(merkle_poseidon_3provers_cpp_example SOURCES merkle_poseidon_3provers.cpp INPUT merkle_poseidon_3provers_public.inp PRIVATE_INPUT merkle_poseidon_3provers_private.inp CURVE_TYPE pallas MAX_NUM_PROVERS 3 TBL_GEN_SPEED fast)

examples/cpp/merkle_tree_poseidon.cpp

@@ -7,7 +7,7 @@ using namespace nil::crypto3::algebra::curves;
 
 [[circuit]] pallas::base_field_type::value_type merkle_tree_poseidon (
     std::array<typename pallas::base_field_type::value_type, 0x20> layer_0_leaves) {
-        
+
         std::array<typename pallas::base_field_type::value_type, 0x10> layer_1_leaves;
         std::size_t layer_1_size = 0x10;
         std::array<typename pallas::base_field_type::value_type, 0x8> layer_2_leaves;
@@ -41,4 +41,4 @@ using namespace nil::crypto3::algebra::curves;
     root = hash<hashes::poseidon>(layer_4_leaves[0], layer_4_leaves[1]);
 
     return root;
-}
+}

examples/cpp/merkle_tree_poseidon_large.cpp

@@ -0,0 +1,86 @@
+
+#include <nil/crypto3/hash/algorithm/hash.hpp>
+#include <nil/crypto3/hash/poseidon.hpp>
+
+using namespace nil::crypto3;
+using namespace nil::crypto3::algebra::curves;
+
+[[circuit]] pallas::base_field_type::value_type merkle_tree_poseidon (
+    std::array<typename pallas::base_field_type::value_type, 0x800> input) {
+
+        std::array<typename pallas::base_field_type::value_type, 0x400> layer_400_leaves;
+        std::size_t layer_400_size = 0x400;
+        std::array<typename pallas::base_field_type::value_type, 0x200> layer_200_leaves;
+        std::size_t layer_200_size = 0x200;
+        std::array<typename pallas::base_field_type::value_type, 0x100> layer_100_leaves;
+        std::size_t layer_100_size = 0x100;
+        std::array<typename pallas::base_field_type::value_type, 0x080> layer_080_leaves;
+        std::size_t layer_080_size = 0x080;
+        std::array<typename pallas::base_field_type::value_type, 0x040> layer_040_leaves;
+        std::size_t layer_040_size = 0x040;
+        std::array<typename pallas::base_field_type::value_type, 0x020> layer_020_leaves;
+        std::size_t layer_020_size = 0x020;
+        std::array<typename pallas::base_field_type::value_type, 0x010> layer_010_leaves;
+        std::size_t layer_010_size = 0x010;
+        std::array<typename pallas::base_field_type::value_type, 0x008> layer_008_leaves;
+        std::size_t layer_008_size = 0x008;
+        std::array<typename pallas::base_field_type::value_type, 0x004> layer_004_leaves;
+        std::size_t layer_004_size = 0x004;
+        std::array<typename pallas::base_field_type::value_type, 0x002> layer_002_leaves;
+        std::size_t layer_002_size = 0x002;
+        typename pallas::base_field_type::value_type root;
+
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_400_size; leaf_index++) {
+        layer_400_leaves[leaf_index] =
+            hash<hashes::poseidon>(input[2 * leaf_index], input[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_200_size; leaf_index++) {
+        layer_200_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_400_leaves[2 * leaf_index], layer_400_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_100_size; leaf_index++) {
+        layer_100_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_200_leaves[2 * leaf_index], layer_200_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_080_size; leaf_index++) {
+        layer_080_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_100_leaves[2 * leaf_index], layer_100_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_040_size; leaf_index++) {
+        layer_040_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_080_leaves[2 * leaf_index], layer_080_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_020_size; leaf_index++) {
+        layer_020_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_040_leaves[2 * leaf_index], layer_040_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_010_size; leaf_index++) {
+        layer_010_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_020_leaves[2 * leaf_index], layer_020_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_008_size; leaf_index++) {
+        layer_008_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_010_leaves[2 * leaf_index], layer_010_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_004_size; leaf_index++) {
+        layer_004_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_008_leaves[2 * leaf_index], layer_008_leaves[2 * leaf_index + 1]);
+    }
+
+    for (std::size_t leaf_index = 0; leaf_index < layer_002_size; leaf_index++) {
+        layer_002_leaves[leaf_index] =
+            hash<hashes::poseidon>(layer_004_leaves[2 * leaf_index], layer_004_leaves[2 * leaf_index + 1]);
+    }
+
+    typename pallas::base_field_type::value_type real_root = hash<hashes::poseidon>(layer_002_leaves[0], layer_002_leaves[1]);
+    return real_root;
+}

examples/inputs/merkle_tree_poseidon.inp

@@ -30,4 +30,4 @@
     {"field":29},
     {"field":30},
     {"field":31},
-    {"field":32}] } ]
+    {"field":32}] } ]