First dummy example of MUL opcode handling

.gitmodules

@@ -4,3 +4,9 @@
 [submodule "evm-benchmarks"]
 	path = test/evm-benchmarks
 	url = https://github.com/ipsilon/evm-benchmarks
+[submodule "lib/blueprint"]
+	path = lib/blueprint
+	url = ../../NilFoundation/zkllvm-blueprint.git
+[submodule "lib/crypto3"]
+	path = lib/crypto3
+	url = ../../NilFoundation/crypto3.git

cmake/cable/CableCompilerSettings.cmake

@@ -84,8 +84,10 @@ macro(cable_configure_compiler)
                 add_compile_options(-Wpedantic)
             endif()
 
-            # Enable basing warnings set and treat them as errors.
-            add_compile_options(-Werror -Wall -Wextra -Wshadow)
+            if (ENABLE_WARNINGS)
+                # Enable basing warnings set and treat them as errors.
+                add_compile_options(-Werror -Wall -Wextra -Wshadow)
+            endif()
 
             if(NOT cable_NO_CONVERSION_WARNINGS)
                 # Enable conversion warnings if not explicitly disabled.

lib/CMakeLists.txt

@@ -6,4 +6,6 @@ hunter_add_package(intx)
 find_package(intx CONFIG REQUIRED)
 
 add_subdirectory(fprinter)
+add_subdirectory(crypto3)
+add_subdirectory(blueprint)
 add_subdirectory(evmone)

lib/evmone/CMakeLists.txt

@@ -30,7 +30,7 @@ add_library(evmone ${evmone_sources})
 get_target_property(FPRINTER_DIR fprinter SOURCE_DIR)
 
 target_compile_features(evmone PUBLIC cxx_std_20)
-target_link_libraries(evmone PUBLIC evmc::evmc intx::intx PRIVATE ethash::keccak)
+target_link_libraries(evmone PUBLIC evmc::evmc intx::intx PRIVATE ethash::keccak crypto3::blueprint)
 target_include_directories(evmone PUBLIC
     $<BUILD_INTERFACE:${include_dir}>$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
     ${FPRINTER_DIR}
@@ -42,7 +42,7 @@ if(EVMONE_X86_64_ARCH_LEVEL GREATER_EQUAL 2)
     set_source_files_properties(cpu_check.cpp PROPERTIES COMPILE_DEFINITIONS EVMONE_X86_64_ARCH_LEVEL=${EVMONE_X86_64_ARCH_LEVEL})
 endif()
 
-if(CABLE_COMPILER_GNULIKE)
+if(CABLE_COMPILER_GNULIKE AND DISABLE_EXCEPTIONS)
     target_compile_options(
         evmone PRIVATE
         -fno-exceptions

lib/evmone/execution_state.hpp

@@ -3,11 +3,17 @@
 // SPDX-License-Identifier: Apache-2.0
 #pragma once
 
+#include "instructions_opcodes.hpp"
 #include <evmc/evmc.hpp>
 #include <intx/intx.hpp>
 #include <string>
 #include <vector>
 
+#include <nil/crypto3/zk/snark/arithmetization/plonk/params.hpp>
+#include <nil/crypto3/zk/snark/arithmetization/plonk/constraint_system.hpp>
+#include <nil/crypto3/algebra/curves/pallas.hpp>
+#include <nil/blueprint/blueprint/plonk/assignment.hpp>
+
 namespace evmone
 {
 namespace baseline
@@ -19,6 +25,32 @@ using uint256 = intx::uint256;
 using bytes = std::basic_string<uint8_t>;
 using bytes_view = std::basic_string_view<uint8_t>;
 
+using ArithmetizationParams = nil::crypto3::zk::snark::plonk_arithmetization_params;
+using BlueprintFieldType = nil::crypto3::algebra::curves::pallas::base_field_type;
+using ArithmetizationType = nil::crypto3::zk::snark::plonk_constraint_system<BlueprintFieldType>;
+using var =
+    nil::crypto3::zk::snark::plonk_variable<typename BlueprintFieldType::value_type>;
+constexpr size_t WitnessAmount = 5;
+constexpr size_t PublicInputAmount = 2;
+constexpr size_t ConstantAmount = 1;
+constexpr size_t SelectorAmount = 30;
+using AssignmentType = nil::blueprint::assignment<ArithmetizationType>;
+
+class EVMAssignerState
+{
+public:
+    EVMAssignerState()
+    {
+        for (size_t i = 0; i < 30; ++i)
+        {
+           assignment_tables.emplace_back(WitnessAmount, PublicInputAmount, ConstantAmount, SelectorAmount);
+        }
+
+        // Fill public input here
+    }
+    std::vector<AssignmentType> assignment_tables;
+};
+
 
 /// Provides memory for EVM stack.
 class StackSpace
@@ -138,6 +170,8 @@ class ExecutionState
     size_t output_offset = 0;
     size_t output_size = 0;
 
+    EVMAssignerState assigner_state;
+
 private:
     evmc_tx_context m_tx = {};
 
@@ -195,5 +229,18 @@ class ExecutionState
             m_tx = host.get_tx_context();
         return m_tx;
     }
+
+    template <Opcode Op>
+    std::vector<var> get_assigner_input_variables(size_t table_idx)
+    {
+        // Default template specialization does nothing
+        return {};
+    }
+
+    template <Opcode Op>
+    void write_assignment_result(size_t table_idx, BlueprintFieldType::value_type value)
+    {
+        // Default template specialization does nothing
+    }
 };
 }  // namespace evmone

lib/evmone/instructions.hpp

@@ -15,6 +15,7 @@
 namespace evmone
 {
 using code_iterator = const uint8_t*;
+using nil::blueprint::var_value;
 
 /// Represents the pointer to the stack top item
 /// and allows retrieving stack items and manipulating the pointer.
@@ -137,6 +138,20 @@ inline bool check_memory(
     return check_memory(gas_left, memory, offset, static_cast<uint64_t>(size));
 }
 
+// Template specializations for MUL opcode
+template <>
+inline std::vector<var> ExecutionState::get_assigner_input_variables<Opcode::OP_MUL>(size_t table_idx)
+{
+    // TODO: Replace with meaningful input selection
+    return {var(), var()};
+}
+
+template <>
+inline void ExecutionState::write_assignment_result<Opcode::OP_MUL>(size_t table_idx, BlueprintFieldType::value_type value) {
+    // TODO: Replace with meaningful result var selection
+    assigner_state.assignment_tables[table_idx].witness(3, 4) = value;
+}
+
 namespace instr::core
 {
 
@@ -166,9 +181,13 @@ inline void add(StackTop stack) noexcept
     stack.top() += stack.pop();
 }
 
-inline void mul(StackTop stack) noexcept
+inline void mul(StackTop stack, ExecutionState& state) noexcept
 {
-    stack.top() *= stack.pop();
+    size_t table_idx = 0;
+    AssignmentType &table = state.assigner_state.assignment_tables[table_idx];
+    std::vector<var> inputs = state.get_assigner_input_variables<Opcode::OP_MUL>(table_idx);
+    auto mul = var_value(table, inputs[0]) * var_value(table, inputs[1]);
+    state.write_assignment_result<Opcode::OP_MUL>(table_idx, mul);
 }
 
 inline void sub(StackTop stack) noexcept