PC is looked up in bytecode table #325

Author: ETatuzova

libs/blueprint/include/nil/blueprint/components/hashes/keccak/keccak_dynamic.hpp

@@ -37,6 +37,8 @@
 #include <nil/blueprint/components/hashes/keccak/util.hpp>
 #include <nil/blueprint/components/hashes/keccak/keccak_round.hpp>
 
+
+
 namespace nil {
     namespace blueprint {
         namespace components {
@@ -867,8 +869,8 @@ namespace nil {
                         hash = std::get<1>(instance_input.input[input_idx]);
                         input_idx++;
                     } else {
-                        msg = {0};
-                        hash = {0xbc36789e7a1e281436464229828f817d_cppui_modular254, 0x6612f7b477d66591ff96a9e064bcc98a_cppui_modular254};
+                        msg = {};
+                        hash = keccak_component_hash<BlueprintFieldType>(msg);
                     }
                     auto padded_msg = msg;
                     padded_msg.push_back(1);

libs/blueprint/include/nil/blueprint/components/hashes/keccak/keccak_table.hpp

@@ -43,6 +43,18 @@
 namespace nil {
     namespace blueprint {
         namespace components {
+            template <typename BlueprintFieldType>
+            std::pair<typename BlueprintFieldType::value_type, typename BlueprintFieldType::value_type> keccak_component_hash(const std::vector<uint8_t> &buffer){
+                using value_type = typename BlueprintFieldType::value_type;
+                nil::crypto3::hashes::keccak_1600<256>::digest_type d = nil::crypto3::hash<nil::crypto3::hashes::keccak_1600<256>>(buffer);
+                nil::crypto3::algebra::fields::field<256>::integral_type n(d);
+                std::pair<value_type, value_type> hash_value;
+
+                hash_value.first = (n & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000_cppui_modular257) >> 128;
+                hash_value.second = n & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui_modular257;
+                return hash_value;
+            }
+
             template<typename ArithmetizationType>
             class keccak_table;
 
@@ -148,14 +160,7 @@ namespace nil {
                     }
 
                     void new_buffer(const std::vector<std::uint8_t> buffer){
-                        nil::crypto3::hashes::keccak_1600<256>::digest_type d = nil::crypto3::hash<nil::crypto3::hashes::keccak_1600<256>>(buffer);
-                        nil::crypto3::algebra::fields::field<256>::integral_type n(d);
-                        std::pair<value_type, value_type> hash_value;
-
-                        hash_value.first = (n & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000_cppui_modular257) >> 128;
-                        hash_value.second = n & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui_modular257;
-
-                        input.push_back({buffer, hash_value});
+                        input.push_back({buffer, keccak_component_hash<BlueprintFieldType>(buffer)});
                     }
 
                     data_type input;
@@ -206,44 +211,37 @@ namespace nil {
                     &instance_input,
                 const std::uint32_t start_row_index
             ) {
-                std::cout << "Keccak table generate assignments" << std::endl;
                 using component_type = plonk_keccak_table<BlueprintFieldType>;
                 using value_type = typename BlueprintFieldType::value_type;
 
-                std::cout << instance_input.rlc_challenge << std::endl;
                 value_type theta = var_value(assignment, instance_input.rlc_challenge);
                 std::size_t input_idx = 0;
                 std::size_t block_counter = 0;
                 std::vector<std::uint8_t> msg;
                 std::pair<value_type, value_type> hash;
                 typename component_type::keccak_table_map t(component);
-                std::cout << "Keccak table generate assignments" << std::endl;
                 while( block_counter < component.max_blocks ) {
                     if( input_idx < instance_input.input.size() ){
                         msg = std::get<0>(instance_input.input[input_idx]);
                         hash = std::get<1>(instance_input.input[input_idx]);
                         input_idx++;
                     } else {
-                        msg = {0};
-                        hash = {0xbc36789e7a1e281436464229828f817d_cppui_modular254, 0x6612f7b477d66591ff96a9e064bcc98a_cppui_modular254};
+                        msg = {};
+                        hash = keccak_component_hash<BlueprintFieldType>(msg);
                     }
                     value_type RLC = calculateRLC<BlueprintFieldType>(msg, theta);
                     for( std::size_t block = 0; block < std::ceil(float(msg.size() + 1)/136); block++){
                         if( block != std::ceil(float(msg.size() + 1)/136) - 1){
-                            std::cout << "0 ";
                             assignment.witness(t.is_last.index, start_row_index + block_counter) = 0;
                         } else {
-                            std::cout << "1 ";
                             assignment.witness(t.is_last.index, start_row_index + block_counter) = 1;
                         }
-                        std::cout << std::hex << RLC << " " << hash.first << " " << hash.second << std::dec << std::endl;
                         assignment.witness(t.RLC.index, start_row_index + block_counter) = RLC;
                         assignment.witness(t.hash_hi.index, start_row_index + block_counter) = hash.first;
                         assignment.witness(t.hash_lo.index, start_row_index + block_counter) = hash.second;
                         block_counter++;
                     }
                 }
-                std::cout << "Keccak table assignments generated" << std::endl;
                 return typename component_type::result_type(component, start_row_index);
 	        }
 
@@ -259,12 +257,10 @@ namespace nil {
             ) {
                 using component_type = plonk_keccak_table<BlueprintFieldType>;
                 using var = typename component_type::var;
-                std::cout << "Keccak table generate circuit" << std::endl;
 
                 bp.register_dynamic_table("keccak_table");
                 std::size_t selector_index = bp.get_dynamic_lookup_table_selector();
                 assignment.enable_selector(selector_index, start_row_index, start_row_index + component.rows_amount - 1);
-                std::cout << "Keccak table selector index " << selector_index << std::endl;
 
                 crypto3::zk::snark::plonk_lookup_table<BlueprintFieldType> keccak_table;
                 typename component_type::keccak_table_map t(component);

libs/blueprint/include/nil/blueprint/utils/satisfiability_check.hpp

@@ -74,17 +74,16 @@ namespace nil {
             const assignment<crypto3::zk::snark::plonk_constraint_system<BlueprintFieldType>> &assignments,
             std::size_t table_id
         ){
-            std::cout << "Load dynamic lookup" << std::endl;
             std::set<std::vector<typename BlueprintFieldType::value_type>> result;
-            BOOST_ASSERT(table_id < bp.lookup_tables().size());
+            if( table_id > bp.lookup_tables().size() )
+                std::cout << table_id << " >= " << bp.lookup_tables().size() << std::endl;
+            BOOST_ASSERT(table_id <= bp.lookup_tables().size());
             auto &table = bp.lookup_tables()[table_id-1];
 
-            std::cout << "Table found" << table.tag_index << std::endl;
             crypto3::zk::snark::plonk_column<BlueprintFieldType> selector =
                 assignments.crypto3::zk::snark::
                     template plonk_assignment_table<BlueprintFieldType>::selector(table.tag_index);
 
-            std::cout << "Selector found" << std::endl;
             for( std::size_t selector_row = 0; selector_row < assignments.rows_amount(); selector_row++ ){
                 if( selector_row < selector.size() && !selector[selector_row].is_zero() ){
                     for( std::size_t op = 0; op < table.lookup_options.size(); op++){
@@ -98,7 +97,6 @@ namespace nil {
                 }
             }
 
-            std::cout << "Dynamic lookup loaded" << std::endl;
             return result;
         }
 
@@ -121,7 +119,6 @@ namespace nil {
             std::map<std::string, std::set<std::vector<typename BlueprintFieldType::value_type>>> used_dynamic_tables;
 
             for (const auto& i : used_gates) {
-                std::cout << "Gate " << i << std::endl;
                 crypto3::zk::snark::plonk_column<BlueprintFieldType> selector =
                     assignments.crypto3::zk::snark::
                         template plonk_assignment_table<BlueprintFieldType>::selector(
@@ -158,25 +155,23 @@ namespace nil {
             }
 
             for (const auto& i : used_lookup_gates) {
-                std::cout << "Lookup gate " << i << std::endl;
                 crypto3::zk::snark::plonk_column<BlueprintFieldType> selector =
                     assignments.crypto3::zk::snark::
                         template plonk_assignment_table<BlueprintFieldType>::selector(
                             lookup_gates[i].tag_index);
 
                 for (const auto& selector_row : selector_rows) {
                     if (selector_row < selector.size() && !selector[selector_row].is_zero()) {
-                        std::cout << "Selected row " << selector_row << std::endl;
                         for (std::size_t j = 0; j < lookup_gates[i].constraints.size(); j++) {
                             std::vector<typename BlueprintFieldType::value_type> input_values;
                             input_values.reserve(lookup_gates[i].constraints[j].lookup_input.size());
                             for (std::size_t k = 0; k < lookup_gates[i].constraints[j].lookup_input.size(); k++) {
                                 input_values.emplace_back(lookup_gates[i].constraints[j].lookup_input[k].evaluate(
                                     selector_row, assignments));
                             }
+
                             const auto table_name =
                                 bp.get_reserved_indices_right().at(lookup_gates[i].constraints[j].table_id);
-                            std::cout << table_name << std::endl;
                             try {
                                 if( bp.get_reserved_dynamic_tables().find(table_name) != bp.get_reserved_dynamic_tables().end() ){
                                     if( used_dynamic_tables.find(table_name) == used_dynamic_tables.end()){

libs/blueprint/include/nil/blueprint/zkevm/bytecode.hpp

@@ -342,13 +342,17 @@ namespace nil {
                 };
                 std::size_t selector_id = bp.get_dynamic_table_definition("zkevm_bytecode")->lookup_table.tag_index;
 
+                // TODO: review after lookup argument update
+                // It may be jsut constant for the fixed curve
+                auto zerohash = keccak_component_hash<BlueprintFieldType>({});
+
                 lookup_constraint_type hash_table_constraint = {
                     lookup_tables_indices.at("keccak_table"),
                     {
-                        m.tag() * (1 - m.tag.next()),
-                        m.tag() * (1 - m.tag.next()) * m.value_rlc() + (1 - m.tag() * (1 - m.tag.next())) *  0x109057df9cba2ae4cc6f2c8c33de834267af65e2b2ea38088d571b0c4e5fcb5c_cppui_modular257,
-                        m.tag() * (1 - m.tag.next()) * m.hash_hi() + (1 - m.tag() * (1 - m.tag.next())) *  0x97cea80fc2260ca27ded02e6d09f19a3_cppui_modular257,
-                        m.tag() * (1 - m.tag.next()) * m.hash_lo() + (1 - m.tag() * (1 - m.tag.next())) *  0x9853f3bc764790709249eb48cc9375fd_cppui_modular257
+                        m.tag() + 1 - m.tag(), // TODO: update math::expression constructor with constant parameter
+                        m.tag() * (1 - m.tag.next()) * m.value_rlc(),
+                        m.tag() * (1 - m.tag.next()) * m.hash_hi() + (1 - m.tag() * (1 - m.tag.next())) * zerohash.first,
+                        m.tag() * (1 - m.tag.next()) * m.hash_lo() + (1 - m.tag() * (1 - m.tag.next())) * zerohash.second
                     }
                 };
 

libs/blueprint/include/nil/blueprint/zkevm/bytecode_table.hpp

@@ -163,28 +163,7 @@ namespace nil {
                         return result;
                     }
                 };
-/*
-                template<typename ContainerType>
-                explicit zkevm_bytecode_table(ContainerType witness, std::size_t _max_bytecode_size) :
-                    component_type(witness, {}, {}, get_manifest()), max_bytecode_size(_max_bytecode_size)
-                    {};
-
-                template<typename WitnessContainerType, typename ConstantContainerType,
-                         typename PublicInputContainerType>
-                zkevm_bytecode_table(WitnessContainerType witness, ConstantContainerType constant,
-                    PublicInputContainerType public_input,
-                    std::size_t _max_bytecode_size
-                ) : component_type(witness, constant, public_input, get_manifest()), max_bytecode_size(_max_bytecode_size) {};
 
-                zkevm_bytecode_table(
-                    std::initializer_list<typename component_type::witness_container_type::value_type> witnesses,
-                    std::initializer_list<typename component_type::constant_container_type::value_type>
-                        constants,
-                    std::initializer_list<typename component_type::public_input_container_type::value_type>
-                        public_inputs,
-                    std::size_t _max_bytecode_size
-                ) : component_type(witnesses, constants, public_inputs, get_manifest()), max_bytecode_size(_max_bytecode_size){};
-*/
                 zkevm_bytecode_table(
                     const typename component_type::witness_container_type  &witnesses,
                     const typename component_type::constant_container_type &constants,
@@ -269,7 +248,6 @@ namespace nil {
 
                 std::size_t selector_index = bp.get_dynamic_lookup_table_selector();
                 assignment.enable_selector(selector_index, start_row_index, start_row_index + component.rows_amount - 1);
-                std::cout << "Bytecode table selector index = " << selector_index << std::endl;
 
                 crypto3::zk::snark::plonk_lookup_table<BlueprintFieldType> bytecode_table;
                 bytecode_table.tag_index = selector_index;

libs/blueprint/include/nil/blueprint/zkevm/state.hpp

@@ -71,10 +71,13 @@ namespace nil {
             state_var stack_size;
             state_var memory_size;
             state_var gas;
-            state_var opcode;
+            state_var opcode;               // it's Id in the list of used opcodes
+            state_var real_opcode;          // real_opcode is real opcode that will be looked up in bytecode table
+            state_var bytecode_hash_hi;     // will be looked up in bytecode table
+            state_var bytecode_hash_lo;     // will be lookup up in bytecode table
 
-            state_var row_counter;           // Decreasing row counter
-            state_var step_start;             // 1 in first line of new opcode, 0 otherwise
+            state_var row_counter;          // Decreasing row counter
+            state_var step_start;           // 1 in first line of new opcode, 0 otherwise
             state_var row_counter_inv;
             state_var last_row_indicator;   // Do we really need it? I don't think so. Last opcode should be RETURN, err or padding.
             state_var opcode_parity;        // opcode%2