136 zkevm operations in bbf

crypto3/libs/blueprint/CMakeLists.txt

@@ -12,6 +12,7 @@ set_target_properties(${CMAKE_WORKSPACE_NAME}_${CURRENT_PROJECT_NAME} PROPERTIES
         EXPORT_NAME ${CURRENT_PROJECT_NAME})
 
 target_include_directories(${CMAKE_WORKSPACE_NAME}_${CURRENT_PROJECT_NAME} INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../test_tools/include>
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
         $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>)
 

crypto3/libs/blueprint/include/nil/blueprint/bbf/generic.hpp

@@ -325,7 +325,7 @@ namespace nil {
 
                 void allocate(TYPE &C, size_t col, size_t row, column_type t) {
                     if (is_allocated(col, row, t)) {
-                        BOOST_LOG_TRIVIAL(warning) << "RE-allocation of " << t << " cell at col = " << col << ", row = " << row << ".\n";
+                     //   BOOST_LOG_TRIVIAL(warning) << "RE-allocation of " << t << " cell at col = " << col << ", row = " << row << ".\n";
                     }
                     if (t == column_type::constant) {
                         auto [has_vars, min_row, max_row] = expression_row_range_visitor<var>::row_range(C);
@@ -413,6 +413,16 @@ namespace nil {
                     add_constraint(C_rel, get_row(row));
                 }
 
+                void relative_constrain(TYPE C_rel, std::size_t start_row,  std::size_t end_row) {
+                    if (!is_relative(C_rel)) {
+                        std::stringstream ss;
+                        ss << "Constraint " << C_rel << " has absolute variables, cannot constrain.";
+                        throw std::logic_error(ss.str());
+                    }
+                    add_constraint(C_rel, get_row(start_row),  get_row(end_row));
+                }
+
+
                 void lookup(std::vector<TYPE> &C, std::string table_name) {
                     std::set<std::size_t> base_rows = {};
 
@@ -470,6 +480,17 @@ namespace nil {
                     add_lookup_constraint(table_name, C, row);
                 }
 
+                void relative_lookup(std::vector<TYPE> &C, std::string table_name, std::size_t start_row, std::size_t end_row) {
+                    for(const TYPE c_part : C) {
+                        if (!is_relative(c_part)) {
+                            std::stringstream ss;
+                            ss << "Constraint " << c_part << " has absolute variables, cannot constrain.";
+                            throw std::logic_error(ss.str());
+                        }
+                    }
+                    add_lookup_constraint(table_name, C, start_row, end_row);
+                }
+
                 void lookup_table(std::string name, std::vector<std::size_t> W, std::size_t from_row, std::size_t num_rows) {
                     if (lookup_tables->find(name) != lookup_tables->end()) {
                         BOOST_LOG_TRIVIAL(error) << "Double declaration of dynamic lookup table '" << name << "'!\n";
@@ -600,6 +621,16 @@ namespace nil {
                     constraints->at(C_id).second.set_row(stored_row);
                 }
 
+                void add_constraint(TYPE &C_rel, std::size_t start_row, std::size_t end_row) {
+                    std::size_t stored_start_row = start_row - (is_fresh ? row_shift : 0);
+                    std::size_t stored_end_row = end_row - (is_fresh ? row_shift : 0);
+                    constraint_id_type C_id = constraint_id_type(C_rel);
+                    if (constraints->find(C_id) == constraints->end()) {
+                        constraints->insert({C_id, {C_rel, row_selector<>(desc.rows_amount)}});
+                    }
+                    constraints->at(C_id).second.set_interval(stored_start_row, stored_end_row);
+                }
+
                 void add_lookup_constraint(
                         std::string table_name, const lookup_input_constraints_type &C_rel, std::size_t row) {
                     std::size_t stored_row = row - (is_fresh ? row_shift : 0);
@@ -614,6 +645,16 @@ namespace nil {
                     lookup_constraints->at(key).second.set_row(stored_row);
                 }
 
+                void add_lookup_constraint(std::string table_name, std::vector<TYPE> &C_rel, std::size_t start_row, std::size_t end_row) {
+                    std::size_t stored_start_row = start_row - (is_fresh ? row_shift : 0);
+                    std::size_t stored_end_row = end_row - (is_fresh ? row_shift : 0);
+                    constraint_id_type C_id = constraint_id_type(C_rel);
+                    if (lookup_constraints->find({table_name,C_id}) == lookup_constraints->end()) {
+                        lookup_constraints->insert({{table_name,C_id}, {lookup_input_constraints_type(C_rel), row_selector<>(desc.rows_amount)}});
+                    }
+                    lookup_constraints->at({table_name,C_id}).second.set_interval(stored_start_row, stored_end_row);
+                }
+
                 void add_lookup_constraint(std::string table_name, std::vector<TYPE> &C_rel, std::size_t row) {
                     add_lookup_constraint(table_name, lookup_input_constraints_type(C_rel), row);
                 }

crypto3/libs/blueprint/include/nil/blueprint/bbf/is_zero.hpp

@@ -84,7 +84,6 @@ namespace nil {
                         res = R;
                     };
             };
-
         } // namespace bbf
     } // namespace blueprint
 } // namespace nil