diff --git a/barretenberg/cpp/pil/avm/gadgets/mem_slice.pil b/barretenberg/cpp/pil/avm/gadgets/mem_slice.pil new file mode 100644 index 000000000000..463e9815fc77 --- /dev/null +++ b/barretenberg/cpp/pil/avm/gadgets/mem_slice.pil @@ -0,0 +1,39 @@ +include "../main.pil"; + +namespace slice(256); + + pol commit clk; + + pol commit sel_start_cd_cpy; // Selector to indicate the start of calldatacopy. Used in permutation with the main trace. + pol commit sel_cd_cpy; // Selector for any row involved in a callatacopy operation. + pol commit cnt; // Decreasing counter to track the number of memory operations. + pol commit space_id; // Copied from main trace. + pol commit addr; // Address pertaining to the memory operation. + pol commit val; // Value pertaining to the memory operation. + pol commit cd_offset; // Offset of the calldata element. It is used to get the correct value from calldata. + pol commit one_min_inv; // Helper column to assert zero/non-zero equality of cnt; + + sel_cd_cpy * (1 - sel_cd_cpy) = 0; + // TODO: might not be required + sel_start_cd_cpy * (1 - sel_start_cd_cpy) = 0; + + // Show that cnt != 0 <==> sel_cd_cpy == 1 + // one_min_inv == 1 - cnt^(-1) if cnt != 0 else == 0 + #[SLICE_CNT_ZERO_TEST1] + cnt * (1 - one_min_inv) - sel_cd_cpy = 0; + #[SLICE_CNT_ZERO_TEST2] + (1 - sel_cd_cpy) * one_min_inv = 0; + + #[SLICE_CNT_DECREMENT] + sel_cd_cpy * (cnt - 1 - cnt') = 0; + + #[ADDR_CNT_INCREMENT] + sel_cd_cpy * (addr + 1 - addr') = 0; + #[CD_OFFSET_INCREMENT] + sel_cd_cpy * (cd_offset + 1 - cd_offset') = 0; + + #[LOOKUP_CD_VALUE] + sel_cd_cpy {cd_offset, val} in main.sel_calldata {main.clk, main.calldata}; + + #[PERM_CD_MEM] + sel_cd_cpy {clk, space_id, addr, val} is mem.sel_op_cd_cpy {mem.clk, mem.space_id, mem.addr, mem.val}; diff --git a/barretenberg/cpp/pil/avm/main.pil b/barretenberg/cpp/pil/avm/main.pil index 7858269448b4..353fedab47f9 100644 --- a/barretenberg/cpp/pil/avm/main.pil +++ b/barretenberg/cpp/pil/avm/main.pil @@ -11,6 +11,7 @@ include "gadgets/sha256.pil"; include "gadgets/poseidon2.pil"; include "gadgets/keccakf1600.pil"; include "gadgets/pedersen.pil"; +include "gadgets/mem_slice.pil"; namespace main(256); //===== CONSTANT POLYNOMIALS ================================================== @@ -20,6 +21,7 @@ namespace main(256); //===== PUBLIC COLUMNS========================================================= pol public calldata; + pol commit sel_calldata; // Selector used for lookup in calldata. TODO: Might be removed or made constant. //===== KERNEL INPUTS ========================================================= // Kernel lookup selector opcodes @@ -139,6 +141,9 @@ namespace main(256); pol commit sel_op_keccak; pol commit sel_op_pedersen; + //===== Memory Slice Gadget Selectors ========================================= + pol commit sel_op_calldata_copy; + //===== Fix Range Checks Selectors============================================= // We re-use the clk column for the lookup values of 8-bit resp. 16-bit range check. pol commit sel_rng_8; // Boolean selector for the 8-bit range check lookup @@ -321,6 +326,8 @@ namespace main(256); sel_op_halt * (1 - sel_op_halt) = 0; sel_op_external_call * (1 - sel_op_external_call) = 0; + sel_op_calldata_copy * (1 - sel_op_calldata_copy) = 0; + // Might be removed if derived from opcode based on a lookup of constants sel_op_mov * ( 1 - sel_op_mov) = 0; sel_op_cmov * ( 1 - sel_op_cmov) = 0; @@ -473,12 +480,13 @@ namespace main(256); pol SEL_ALL_BINARY = sel_op_and + sel_op_or + sel_op_xor; pol SEL_ALL_GADGET = sel_op_radix_le + sel_op_sha256 + sel_op_poseidon2 + sel_op_keccak + sel_op_pedersen; pol SEL_ALL_MEMORY = sel_op_cmov + sel_op_mov; + pol SEL_ALL_MEM_SLICE = sel_op_calldata_copy; pol OPCODE_SELECTORS = sel_op_fdiv + SEL_ALU_ALL + SEL_ALL_BINARY + SEL_ALL_MEMORY + SEL_ALL_GADGET - + KERNEL_INPUT_SELECTORS + KERNEL_OUTPUT_SELECTORS + SEL_ALL_LEFTGAS; + + KERNEL_INPUT_SELECTORS + KERNEL_OUTPUT_SELECTORS + SEL_ALL_LEFTGAS + SEL_ALL_MEM_SLICE; // TODO: sel_gas_accounting_active is activating gas accounting on a given row. All opcode with selectors // are activated through the relation below. The other opcodes which are implemented purely - // through memory sub-operations such as CALLDATACOPY, RETURN, SET are activated by + // through memory sub-operations such as RETURN, SET are activated by // setting a newly introduced boolean sel_mem_op_activate_gas which is set in witness generation. // We should remove this shortcut and constrain this activation through bytecode decomposition. // Alternatively, we introduce a boolean selector for the three opcodes mentioned above. @@ -656,13 +664,20 @@ namespace main(256); // We increment the side effect counter by 1 KERNEL_OUTPUT_SELECTORS * (kernel.side_effect_counter' - (kernel.side_effect_counter + 1)) = 0; + //===== Memory Slice Constraints ============================================ + pol commit sel_cd_cpy_gadget; // Selector to activate the calldatacopy operation in the gadget (#[PERM_MAIN_CD_COPY]). + + // Activate only if tag_err is disabled + sel_cd_cpy_gadget = sel_op_calldata_copy * (1 - tag_err); + + //====== Inter-table Constraints ============================================ + #[KERNEL_OUTPUT_LOOKUP] sel_q_kernel_output_lookup {kernel.kernel_out_offset, ia, kernel.side_effect_counter, ib} in kernel.q_public_input_kernel_out_add_to_table {clk, kernel.kernel_value_out, kernel.kernel_side_effect_out, kernel.kernel_metadata_out}; #[LOOKUP_INTO_KERNEL] sel_q_kernel_lookup { main.ia, kernel.kernel_in_offset } in kernel.q_public_input_kernel_add_to_table { kernel.kernel_inputs, clk }; - //====== Inter-table Constraints ============================================ #[INCL_MAIN_TAG_ERR] mem.tag_err {mem.clk} in tag_err {clk}; @@ -723,6 +738,11 @@ namespace main(256); is pedersen.sel_pedersen {pedersen.clk, pedersen.input}; + #[PERM_MAIN_CD_COPY] + sel_cd_cpy_gadget {ia, ib, mem_addr_c} + is + slice.sel_start_cd_cpy {slice.cd_offset, slice.cnt, slice.addr}; + #[PERM_MAIN_MEM_A] sel_mem_op_a {clk, space_id, mem_addr_a, ia, rwa, r_in_tag, w_in_tag, sel_mov_ia_to_ic, sel_op_cmov} is diff --git a/barretenberg/cpp/pil/avm/mem.pil b/barretenberg/cpp/pil/avm/mem.pil index 0cb9d7c491ae..400723d15299 100644 --- a/barretenberg/cpp/pil/avm/mem.pil +++ b/barretenberg/cpp/pil/avm/mem.pil @@ -32,6 +32,9 @@ namespace mem(256); pol commit sel_resolve_ind_addr_c; pol commit sel_resolve_ind_addr_d; + // Selector for calldata_copy memory operations triggered from memory slice gadget. + pol commit sel_op_cd_cpy; + // Selectors related to MOV/CMOV opcodes (copied from main trace for loading operation on intermediated register ia/ib) // Boolean constraint is performed in main trace. pol commit sel_mov_ia_to_ic; @@ -57,6 +60,7 @@ namespace mem(256); sel_op_b * (1 - sel_op_b) = 0; sel_op_c * (1 - sel_op_c) = 0; sel_op_d * (1 - sel_op_d) = 0; + sel_op_cd_cpy * (1 - sel_op_cd_cpy) = 0; sel_resolve_ind_addr_a * (1 - sel_resolve_ind_addr_a) = 0; sel_resolve_ind_addr_b * (1 - sel_resolve_ind_addr_b) = 0; sel_resolve_ind_addr_c * (1 - sel_resolve_ind_addr_c) = 0; @@ -66,8 +70,9 @@ namespace mem(256); // 2) Ensure that tag, r_in_tag, w_in_tag are properly constrained by the main trace and/or bytecode decomposition // Definition of sel_mem - sel_mem = sel_op_a + sel_op_b + sel_op_c + sel_op_d + - sel_resolve_ind_addr_a + sel_resolve_ind_addr_b + sel_resolve_ind_addr_c + sel_resolve_ind_addr_d; + sel_mem = sel_op_a + sel_op_b + sel_op_c + sel_op_d + + sel_resolve_ind_addr_a + sel_resolve_ind_addr_b + sel_resolve_ind_addr_c + sel_resolve_ind_addr_d + + sel_op_cd_cpy; // Maximum one memory operation enabled per row sel_mem * (sel_mem - 1) = 0; // TODO: might be infered by the main trace @@ -99,6 +104,11 @@ namespace mem(256); pol SUB_CLK = sel_mem * (sel_resolve_ind_addr_b + sel_op_b + 2 * (sel_resolve_ind_addr_c + sel_op_c) + 3 * (sel_resolve_ind_addr_d + sel_op_d) + 4 * (1 - IND_OP + rw)); // We need the sel_mem factor as the right factor is not zero when all columns are zero. + // Calldata_copy memory slice operations will have a sub_clk value of 8 as rw == 1 which is outside of the range of + // indirect memory operations. This is crucial as a main trace entry for calldata_copy triggers an indirect memory + // load operation for intermediate register c. The write slice memory operations will have the same sub_clk which in + // this particular case is not a problem as all addresses are different. + #[TIMESTAMP] tsp = NUM_SUB_CLK * clk + SUB_CLK; @@ -154,6 +164,7 @@ namespace mem(256); #[MEM_ZERO_INIT] lastAccess * (1 - rw') * val' = 0; + // TODO: Verfiy that skip_check_tag cannot be enabled maliciously by the prover. // Skip check tag #[SKIP_CHECK_TAG] skip_check_tag = sel_op_cmov * (sel_op_d + sel_op_a * (1-sel_mov_ia_to_ic) + sel_op_b * (1-sel_mov_ib_to_ic)); @@ -207,6 +218,10 @@ namespace mem(256); sel_resolve_ind_addr_c * rw = 0; sel_resolve_ind_addr_d * rw = 0; + //====== CALLDATACOPY specific constraints ================================== + sel_op_cd_cpy * (rw - 1) = 0; + sel_op_cd_cpy * (w_in_tag - 6) = 0; // Only write elements of type FF + //====== MOV/CMOV Opcode Tag Constraint ===================================== // The following constraint ensures that the r_in_tag is set to tag for // the load operation pertaining to Ia resp. Ib. diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp index f0c272ca4f7f..7dedfa78eaad 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -184,6 +184,8 @@ [[maybe_unused]] auto main_rwd = View(new_term.main_rwd); \ [[maybe_unused]] auto main_sel_alu = View(new_term.main_sel_alu); \ [[maybe_unused]] auto main_sel_bin = View(new_term.main_sel_bin); \ + [[maybe_unused]] auto main_sel_calldata = View(new_term.main_sel_calldata); \ + [[maybe_unused]] auto main_sel_cd_cpy_gadget = View(new_term.main_sel_cd_cpy_gadget); \ [[maybe_unused]] auto main_sel_gas_accounting_active = View(new_term.main_sel_gas_accounting_active); \ [[maybe_unused]] auto main_sel_last = View(new_term.main_sel_last); \ [[maybe_unused]] auto main_sel_mem_op_a = View(new_term.main_sel_mem_op_a); \ @@ -197,6 +199,7 @@ [[maybe_unused]] auto main_sel_op_address = View(new_term.main_sel_op_address); \ [[maybe_unused]] auto main_sel_op_and = View(new_term.main_sel_op_and); \ [[maybe_unused]] auto main_sel_op_block_number = View(new_term.main_sel_op_block_number); \ + [[maybe_unused]] auto main_sel_op_calldata_copy = View(new_term.main_sel_op_calldata_copy); \ [[maybe_unused]] auto main_sel_op_cast = View(new_term.main_sel_op_cast); \ [[maybe_unused]] auto main_sel_op_chain_id = View(new_term.main_sel_op_chain_id); \ [[maybe_unused]] auto main_sel_op_cmov = View(new_term.main_sel_op_cmov); \ @@ -273,6 +276,7 @@ [[maybe_unused]] auto mem_sel_op_a = View(new_term.mem_sel_op_a); \ [[maybe_unused]] auto mem_sel_op_b = View(new_term.mem_sel_op_b); \ [[maybe_unused]] auto mem_sel_op_c = View(new_term.mem_sel_op_c); \ + [[maybe_unused]] auto mem_sel_op_cd_cpy = View(new_term.mem_sel_op_cd_cpy); \ [[maybe_unused]] auto mem_sel_op_cmov = View(new_term.mem_sel_op_cmov); \ [[maybe_unused]] auto mem_sel_op_d = View(new_term.mem_sel_op_d); \ [[maybe_unused]] auto mem_sel_resolve_ind_addr_a = View(new_term.mem_sel_resolve_ind_addr_a); \ @@ -301,11 +305,22 @@ [[maybe_unused]] auto sha256_output = View(new_term.sha256_output); \ [[maybe_unused]] auto sha256_sel_sha256_compression = View(new_term.sha256_sel_sha256_compression); \ [[maybe_unused]] auto sha256_state = View(new_term.sha256_state); \ + [[maybe_unused]] auto slice_addr = View(new_term.slice_addr); \ + [[maybe_unused]] auto slice_cd_offset = View(new_term.slice_cd_offset); \ + [[maybe_unused]] auto slice_clk = View(new_term.slice_clk); \ + [[maybe_unused]] auto slice_cnt = View(new_term.slice_cnt); \ + [[maybe_unused]] auto slice_one_min_inv = View(new_term.slice_one_min_inv); \ + [[maybe_unused]] auto slice_sel_cd_cpy = View(new_term.slice_sel_cd_cpy); \ + [[maybe_unused]] auto slice_sel_start_cd_cpy = View(new_term.slice_sel_start_cd_cpy); \ + [[maybe_unused]] auto slice_space_id = View(new_term.slice_space_id); \ + [[maybe_unused]] auto slice_val = View(new_term.slice_val); \ + [[maybe_unused]] auto perm_cd_mem = View(new_term.perm_cd_mem); \ [[maybe_unused]] auto perm_main_alu = View(new_term.perm_main_alu); \ [[maybe_unused]] auto perm_main_bin = View(new_term.perm_main_bin); \ [[maybe_unused]] auto perm_main_conv = View(new_term.perm_main_conv); \ [[maybe_unused]] auto perm_main_pos2_perm = View(new_term.perm_main_pos2_perm); \ [[maybe_unused]] auto perm_main_pedersen = View(new_term.perm_main_pedersen); \ + [[maybe_unused]] auto perm_main_cd_copy = View(new_term.perm_main_cd_copy); \ [[maybe_unused]] auto perm_main_mem_a = View(new_term.perm_main_mem_a); \ [[maybe_unused]] auto perm_main_mem_b = View(new_term.perm_main_mem_b); \ [[maybe_unused]] auto perm_main_mem_c = View(new_term.perm_main_mem_c); \ @@ -316,6 +331,7 @@ [[maybe_unused]] auto perm_main_mem_ind_addr_d = View(new_term.perm_main_mem_ind_addr_d); \ [[maybe_unused]] auto lookup_byte_lengths = View(new_term.lookup_byte_lengths); \ [[maybe_unused]] auto lookup_byte_operations = View(new_term.lookup_byte_operations); \ + [[maybe_unused]] auto lookup_cd_value = View(new_term.lookup_cd_value); \ [[maybe_unused]] auto lookup_opcode_gas = View(new_term.lookup_opcode_gas); \ [[maybe_unused]] auto range_check_l2_gas_hi = View(new_term.range_check_l2_gas_hi); \ [[maybe_unused]] auto range_check_l2_gas_lo = View(new_term.range_check_l2_gas_lo); \ @@ -357,6 +373,7 @@ [[maybe_unused]] auto lookup_div_u16_7 = View(new_term.lookup_div_u16_7); \ [[maybe_unused]] auto lookup_byte_lengths_counts = View(new_term.lookup_byte_lengths_counts); \ [[maybe_unused]] auto lookup_byte_operations_counts = View(new_term.lookup_byte_operations_counts); \ + [[maybe_unused]] auto lookup_cd_value_counts = View(new_term.lookup_cd_value_counts); \ [[maybe_unused]] auto lookup_opcode_gas_counts = View(new_term.lookup_opcode_gas_counts); \ [[maybe_unused]] auto range_check_l2_gas_hi_counts = View(new_term.range_check_l2_gas_hi_counts); \ [[maybe_unused]] auto range_check_l2_gas_lo_counts = View(new_term.range_check_l2_gas_lo_counts); \ @@ -468,4 +485,7 @@ [[maybe_unused]] auto mem_sel_mem_shift = View(new_term.mem_sel_mem_shift); \ [[maybe_unused]] auto mem_tag_shift = View(new_term.mem_tag_shift); \ [[maybe_unused]] auto mem_tsp_shift = View(new_term.mem_tsp_shift); \ - [[maybe_unused]] auto mem_val_shift = View(new_term.mem_val_shift); + [[maybe_unused]] auto mem_val_shift = View(new_term.mem_val_shift); \ + [[maybe_unused]] auto slice_addr_shift = View(new_term.slice_addr_shift); \ + [[maybe_unused]] auto slice_cd_offset_shift = View(new_term.slice_cd_offset_shift); \ + [[maybe_unused]] auto slice_cnt_shift = View(new_term.slice_cnt_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_cd_value.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_cd_value.hpp new file mode 100644 index 000000000000..a7fb1382dcc1 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_cd_value.hpp @@ -0,0 +1,67 @@ +#pragma once + +#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" + +#include +#include + +namespace bb { + +class lookup_cd_value_lookup_settings { + public: + static constexpr size_t READ_TERMS = 1; + static constexpr size_t WRITE_TERMS = 1; + static constexpr size_t READ_TERM_TYPES[READ_TERMS] = { 0 }; + static constexpr size_t WRITE_TERM_TYPES[WRITE_TERMS] = { 0 }; + static constexpr size_t LOOKUP_TUPLE_SIZE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; + static constexpr size_t READ_TERM_DEGREE = 0; + static constexpr size_t WRITE_TERM_DEGREE = 0; + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.slice_sel_cd_cpy == 1 || in.main_sel_calldata == 1); + } + + template + static inline auto compute_inverse_exists(const AllEntities& in) + { + using View = typename Accumulator::View; + const auto is_operation = View(in.slice_sel_cd_cpy); + const auto is_table_entry = View(in.main_sel_calldata); + return (is_operation + is_table_entry - is_operation * is_table_entry); + } + + template static inline auto get_const_entities(const AllEntities& in) + { + return std::forward_as_tuple(in.lookup_cd_value, + in.lookup_cd_value_counts, + in.slice_sel_cd_cpy, + in.main_sel_calldata, + in.slice_cd_offset, + in.slice_val, + in.main_clk, + in.main_calldata); + } + + template static inline auto get_nonconst_entities(AllEntities& in) + { + return std::forward_as_tuple(in.lookup_cd_value, + in.lookup_cd_value_counts, + in.slice_sel_cd_cpy, + in.main_sel_calldata, + in.slice_cd_offset, + in.slice_val, + in.main_clk, + in.main_calldata); + } +}; + +template +class lookup_cd_value_relation : public GenericLookupRelation { + public: + static constexpr const char* NAME = "lookup_cd_value"; +}; +template using lookup_cd_value = GenericLookup; + +} // namespace bb \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp index bb16f6812c35..82289efd5b28 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp @@ -56,6 +56,7 @@ template struct MainRow { FF main_rwd{}; FF main_sel_alu{}; FF main_sel_bin{}; + FF main_sel_cd_cpy_gadget{}; FF main_sel_first{}; FF main_sel_gas_accounting_active{}; FF main_sel_mem_op_a{}; @@ -69,6 +70,7 @@ template struct MainRow { FF main_sel_op_address{}; FF main_sel_op_and{}; FF main_sel_op_block_number{}; + FF main_sel_op_calldata_copy{}; FF main_sel_op_cast{}; FF main_sel_op_chain_id{}; FF main_sel_op_cmov{}; @@ -139,99 +141,99 @@ inline std::string get_relation_label_main(int index) return "L2_GAS_INACTIVE"; case 5: return "DA_GAS_INACTIVE"; - case 75: - return "OUTPUT_U8"; case 76: - return "SUBOP_FDIV"; + return "OUTPUT_U8"; case 77: - return "SUBOP_FDIV_ZERO_ERR1"; + return "SUBOP_FDIV"; case 78: - return "SUBOP_FDIV_ZERO_ERR2"; + return "SUBOP_FDIV_ZERO_ERR1"; case 79: - return "SUBOP_FDIV_R_IN_TAG_FF"; + return "SUBOP_FDIV_ZERO_ERR2"; case 80: - return "SUBOP_FDIV_W_IN_TAG_FF"; + return "SUBOP_FDIV_R_IN_TAG_FF"; case 81: - return "SUBOP_ERROR_RELEVANT_OP"; + return "SUBOP_FDIV_W_IN_TAG_FF"; case 82: - return "KERNEL_INPUT_ACTIVE_CHECK"; + return "SUBOP_ERROR_RELEVANT_OP"; case 83: - return "KERNEL_OUTPUT_ACTIVE_CHECK"; + return "KERNEL_INPUT_ACTIVE_CHECK"; case 84: - return "PC_JUMP"; + return "KERNEL_OUTPUT_ACTIVE_CHECK"; case 85: - return "PC_JUMPI"; + return "PC_JUMP"; case 86: + return "PC_JUMPI"; + case 87: return "RETURN_POINTER_INCREMENT"; - case 92: + case 93: return "RETURN_POINTER_DECREMENT"; - case 98: - return "PC_INCREMENT"; case 99: - return "INTERNAL_RETURN_POINTER_CONSISTENCY"; + return "PC_INCREMENT"; case 100: - return "SPACE_ID_INTERNAL"; + return "INTERNAL_RETURN_POINTER_CONSISTENCY"; case 101: - return "SPACE_ID_STANDARD_OPCODES"; + return "SPACE_ID_INTERNAL"; case 102: - return "CMOV_CONDITION_RES_1"; + return "SPACE_ID_STANDARD_OPCODES"; case 103: + return "CMOV_CONDITION_RES_1"; + case 104: return "CMOV_CONDITION_RES_2"; - case 106: - return "MOV_SAME_VALUE_A"; case 107: - return "MOV_SAME_VALUE_B"; + return "MOV_SAME_VALUE_A"; case 108: + return "MOV_SAME_VALUE_B"; + case 109: return "MOV_MAIN_SAME_TAG"; - case 112: - return "L2GASLEFT"; case 113: - return "DAGASLEFT"; + return "L2GASLEFT"; case 114: - return "ADDRESS_KERNEL"; + return "DAGASLEFT"; case 115: - return "STORAGE_ADDRESS_KERNEL"; + return "ADDRESS_KERNEL"; case 116: - return "SENDER_KERNEL"; + return "STORAGE_ADDRESS_KERNEL"; case 117: - return "FUNCTION_SELECTOR_KERNEL"; + return "SENDER_KERNEL"; case 118: - return "FEE_TRANSACTION_FEE_KERNEL"; + return "FUNCTION_SELECTOR_KERNEL"; case 119: - return "CHAIN_ID_KERNEL"; + return "FEE_TRANSACTION_FEE_KERNEL"; case 120: - return "VERSION_KERNEL"; + return "CHAIN_ID_KERNEL"; case 121: - return "BLOCK_NUMBER_KERNEL"; + return "VERSION_KERNEL"; case 122: - return "TIMESTAMP_KERNEL"; + return "BLOCK_NUMBER_KERNEL"; case 123: - return "COINBASE_KERNEL"; + return "TIMESTAMP_KERNEL"; case 124: - return "FEE_DA_GAS_KERNEL"; + return "COINBASE_KERNEL"; case 125: - return "FEE_L2_GAS_KERNEL"; + return "FEE_DA_GAS_KERNEL"; case 126: + return "FEE_L2_GAS_KERNEL"; + case 127: return "NOTE_HASH_KERNEL_OUTPUT"; - case 128: + case 129: return "EMIT_NOTE_HASH_KERNEL_OUTPUT"; - case 130: + case 131: return "NULLIFIER_EXISTS_KERNEL_OUTPUT"; - case 133: + case 134: return "EMIT_NULLIFIER_KERNEL_OUTPUT"; - case 135: + case 136: return "L1_TO_L2_MSG_EXISTS_KERNEL_OUTPUT"; - case 137: + case 138: return "EMIT_UNENCRYPTED_LOG_KERNEL_OUTPUT"; - case 139: + case 140: return "EMIT_L2_TO_L1_MSGS_KERNEL_OUTPUT"; - case 141: + case 142: return "SLOAD_KERNEL_OUTPUT"; - case 143: + case 144: return "SSTORE_KERNEL_OUTPUT"; - case 146: + case 148: return "BIN_SEL_1"; - case 147: + case 149: return "BIN_SEL_2"; } return std::to_string(index); @@ -241,11 +243,12 @@ template class mainImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { - 3, 3, 3, 3, 3, 3, 5, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 5, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2 + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { + 3, 3, 3, 3, 3, 3, 5, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 2, 5, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2 }; template @@ -671,174 +674,181 @@ template class mainImpl { // Contribution 58 { Avm_DECLARE_VIEWS(58); - auto tmp = (main_sel_op_mov * (-main_sel_op_mov + FF(1))); + auto tmp = (main_sel_op_calldata_copy * (-main_sel_op_calldata_copy + FF(1))); tmp *= scaling_factor; std::get<58>(evals) += tmp; } // Contribution 59 { Avm_DECLARE_VIEWS(59); - auto tmp = (main_sel_op_cmov * (-main_sel_op_cmov + FF(1))); + auto tmp = (main_sel_op_mov * (-main_sel_op_mov + FF(1))); tmp *= scaling_factor; std::get<59>(evals) += tmp; } // Contribution 60 { Avm_DECLARE_VIEWS(60); - auto tmp = (main_op_err * (-main_op_err + FF(1))); + auto tmp = (main_sel_op_cmov * (-main_sel_op_cmov + FF(1))); tmp *= scaling_factor; std::get<60>(evals) += tmp; } // Contribution 61 { Avm_DECLARE_VIEWS(61); - auto tmp = (main_tag_err * (-main_tag_err + FF(1))); + auto tmp = (main_op_err * (-main_op_err + FF(1))); tmp *= scaling_factor; std::get<61>(evals) += tmp; } // Contribution 62 { Avm_DECLARE_VIEWS(62); - auto tmp = (main_id_zero * (-main_id_zero + FF(1))); + auto tmp = (main_tag_err * (-main_tag_err + FF(1))); tmp *= scaling_factor; std::get<62>(evals) += tmp; } // Contribution 63 { Avm_DECLARE_VIEWS(63); - auto tmp = (main_sel_mem_op_a * (-main_sel_mem_op_a + FF(1))); + auto tmp = (main_id_zero * (-main_id_zero + FF(1))); tmp *= scaling_factor; std::get<63>(evals) += tmp; } // Contribution 64 { Avm_DECLARE_VIEWS(64); - auto tmp = (main_sel_mem_op_b * (-main_sel_mem_op_b + FF(1))); + auto tmp = (main_sel_mem_op_a * (-main_sel_mem_op_a + FF(1))); tmp *= scaling_factor; std::get<64>(evals) += tmp; } // Contribution 65 { Avm_DECLARE_VIEWS(65); - auto tmp = (main_sel_mem_op_c * (-main_sel_mem_op_c + FF(1))); + auto tmp = (main_sel_mem_op_b * (-main_sel_mem_op_b + FF(1))); tmp *= scaling_factor; std::get<65>(evals) += tmp; } // Contribution 66 { Avm_DECLARE_VIEWS(66); - auto tmp = (main_sel_mem_op_d * (-main_sel_mem_op_d + FF(1))); + auto tmp = (main_sel_mem_op_c * (-main_sel_mem_op_c + FF(1))); tmp *= scaling_factor; std::get<66>(evals) += tmp; } // Contribution 67 { Avm_DECLARE_VIEWS(67); - auto tmp = (main_rwa * (-main_rwa + FF(1))); + auto tmp = (main_sel_mem_op_d * (-main_sel_mem_op_d + FF(1))); tmp *= scaling_factor; std::get<67>(evals) += tmp; } // Contribution 68 { Avm_DECLARE_VIEWS(68); - auto tmp = (main_rwb * (-main_rwb + FF(1))); + auto tmp = (main_rwa * (-main_rwa + FF(1))); tmp *= scaling_factor; std::get<68>(evals) += tmp; } // Contribution 69 { Avm_DECLARE_VIEWS(69); - auto tmp = (main_rwc * (-main_rwc + FF(1))); + auto tmp = (main_rwb * (-main_rwb + FF(1))); tmp *= scaling_factor; std::get<69>(evals) += tmp; } // Contribution 70 { Avm_DECLARE_VIEWS(70); - auto tmp = (main_rwd * (-main_rwd + FF(1))); + auto tmp = (main_rwc * (-main_rwc + FF(1))); tmp *= scaling_factor; std::get<70>(evals) += tmp; } // Contribution 71 { Avm_DECLARE_VIEWS(71); - auto tmp = (main_sel_resolve_ind_addr_a * (-main_sel_resolve_ind_addr_a + FF(1))); + auto tmp = (main_rwd * (-main_rwd + FF(1))); tmp *= scaling_factor; std::get<71>(evals) += tmp; } // Contribution 72 { Avm_DECLARE_VIEWS(72); - auto tmp = (main_sel_resolve_ind_addr_b * (-main_sel_resolve_ind_addr_b + FF(1))); + auto tmp = (main_sel_resolve_ind_addr_a * (-main_sel_resolve_ind_addr_a + FF(1))); tmp *= scaling_factor; std::get<72>(evals) += tmp; } // Contribution 73 { Avm_DECLARE_VIEWS(73); - auto tmp = (main_sel_resolve_ind_addr_c * (-main_sel_resolve_ind_addr_c + FF(1))); + auto tmp = (main_sel_resolve_ind_addr_b * (-main_sel_resolve_ind_addr_b + FF(1))); tmp *= scaling_factor; std::get<73>(evals) += tmp; } // Contribution 74 { Avm_DECLARE_VIEWS(74); - auto tmp = (main_sel_resolve_ind_addr_d * (-main_sel_resolve_ind_addr_d + FF(1))); + auto tmp = (main_sel_resolve_ind_addr_c * (-main_sel_resolve_ind_addr_c + FF(1))); tmp *= scaling_factor; std::get<74>(evals) += tmp; } // Contribution 75 { Avm_DECLARE_VIEWS(75); - auto tmp = (((main_sel_op_eq + main_sel_op_lte) + main_sel_op_lt) * (main_w_in_tag - FF(1))); + auto tmp = (main_sel_resolve_ind_addr_d * (-main_sel_resolve_ind_addr_d + FF(1))); tmp *= scaling_factor; std::get<75>(evals) += tmp; } // Contribution 76 { Avm_DECLARE_VIEWS(76); - auto tmp = ((main_sel_op_fdiv * (-main_op_err + FF(1))) * ((main_ic * main_ib) - main_ia)); + auto tmp = (((main_sel_op_eq + main_sel_op_lte) + main_sel_op_lt) * (main_w_in_tag - FF(1))); tmp *= scaling_factor; std::get<76>(evals) += tmp; } // Contribution 77 { Avm_DECLARE_VIEWS(77); - auto tmp = ((main_sel_op_fdiv + main_sel_op_div) * (((main_ib * main_inv) - FF(1)) + main_op_err)); + auto tmp = ((main_sel_op_fdiv * (-main_op_err + FF(1))) * ((main_ic * main_ib) - main_ia)); tmp *= scaling_factor; std::get<77>(evals) += tmp; } // Contribution 78 { Avm_DECLARE_VIEWS(78); - auto tmp = (((main_sel_op_fdiv + main_sel_op_div) * main_op_err) * (-main_inv + FF(1))); + auto tmp = ((main_sel_op_fdiv + main_sel_op_div) * (((main_ib * main_inv) - FF(1)) + main_op_err)); tmp *= scaling_factor; std::get<78>(evals) += tmp; } // Contribution 79 { Avm_DECLARE_VIEWS(79); - auto tmp = (main_sel_op_fdiv * (main_r_in_tag - FF(6))); + auto tmp = (((main_sel_op_fdiv + main_sel_op_div) * main_op_err) * (-main_inv + FF(1))); tmp *= scaling_factor; std::get<79>(evals) += tmp; } // Contribution 80 { Avm_DECLARE_VIEWS(80); - auto tmp = (main_sel_op_fdiv * (main_w_in_tag - FF(6))); + auto tmp = (main_sel_op_fdiv * (main_r_in_tag - FF(6))); tmp *= scaling_factor; std::get<80>(evals) += tmp; } // Contribution 81 { Avm_DECLARE_VIEWS(81); - auto tmp = (main_op_err * ((main_sel_op_fdiv + main_sel_op_div) - FF(1))); + auto tmp = (main_sel_op_fdiv * (main_w_in_tag - FF(6))); tmp *= scaling_factor; std::get<81>(evals) += tmp; } // Contribution 82 { Avm_DECLARE_VIEWS(82); + auto tmp = (main_op_err * ((main_sel_op_fdiv + main_sel_op_div) - FF(1))); + tmp *= scaling_factor; + std::get<82>(evals) += tmp; + } + // Contribution 83 + { + Avm_DECLARE_VIEWS(83); auto tmp = ((((((((((((main_sel_op_address + main_sel_op_storage_address) + main_sel_op_sender) + main_sel_op_function_selector) + main_sel_op_transaction_fee) + @@ -851,11 +861,11 @@ template class mainImpl { main_sel_op_fee_per_da_gas) * (-main_sel_q_kernel_lookup + FF(1))); tmp *= scaling_factor; - std::get<82>(evals) += tmp; + std::get<83>(evals) += tmp; } - // Contribution 83 + // Contribution 84 { - Avm_DECLARE_VIEWS(83); + Avm_DECLARE_VIEWS(84); auto tmp = (((((((main_sel_op_note_hash_exists + main_sel_op_emit_note_hash) + main_sel_op_nullifier_exists) + main_sel_op_emit_nullifier) + @@ -864,151 +874,207 @@ template class mainImpl { main_sel_op_emit_l2_to_l1_msg) * (-main_sel_q_kernel_output_lookup + FF(1))); tmp *= scaling_factor; - std::get<83>(evals) += tmp; - } - // Contribution 84 - { - Avm_DECLARE_VIEWS(84); - auto tmp = (main_sel_op_jump * (main_pc_shift - main_ia)); - tmp *= scaling_factor; std::get<84>(evals) += tmp; } // Contribution 85 { Avm_DECLARE_VIEWS(85); - auto tmp = (main_sel_op_jumpi * (((-main_id_zero + FF(1)) * (main_pc_shift - main_ia)) + - (main_id_zero * ((main_pc_shift - main_pc) - FF(1))))); + auto tmp = (main_sel_op_jump * (main_pc_shift - main_ia)); tmp *= scaling_factor; std::get<85>(evals) += tmp; } // Contribution 86 { Avm_DECLARE_VIEWS(86); - auto tmp = - (main_sel_op_internal_call * (main_internal_return_ptr_shift - (main_internal_return_ptr + FF(1)))); + auto tmp = (main_sel_op_jumpi * (((-main_id_zero + FF(1)) * (main_pc_shift - main_ia)) + + (main_id_zero * ((main_pc_shift - main_pc) - FF(1))))); tmp *= scaling_factor; std::get<86>(evals) += tmp; } // Contribution 87 { Avm_DECLARE_VIEWS(87); - auto tmp = (main_sel_op_internal_call * (main_internal_return_ptr - main_mem_addr_b)); + auto tmp = + (main_sel_op_internal_call * (main_internal_return_ptr_shift - (main_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<87>(evals) += tmp; } // Contribution 88 { Avm_DECLARE_VIEWS(88); - auto tmp = (main_sel_op_internal_call * (main_pc_shift - main_ia)); + auto tmp = (main_sel_op_internal_call * (main_internal_return_ptr - main_mem_addr_b)); tmp *= scaling_factor; std::get<88>(evals) += tmp; } // Contribution 89 { Avm_DECLARE_VIEWS(89); - auto tmp = (main_sel_op_internal_call * ((main_pc + FF(1)) - main_ib)); + auto tmp = (main_sel_op_internal_call * (main_pc_shift - main_ia)); tmp *= scaling_factor; std::get<89>(evals) += tmp; } // Contribution 90 { Avm_DECLARE_VIEWS(90); - auto tmp = (main_sel_op_internal_call * (main_rwb - FF(1))); + auto tmp = (main_sel_op_internal_call * ((main_pc + FF(1)) - main_ib)); tmp *= scaling_factor; std::get<90>(evals) += tmp; } // Contribution 91 { Avm_DECLARE_VIEWS(91); - auto tmp = (main_sel_op_internal_call * (main_sel_mem_op_b - FF(1))); + auto tmp = (main_sel_op_internal_call * (main_rwb - FF(1))); tmp *= scaling_factor; std::get<91>(evals) += tmp; } // Contribution 92 { Avm_DECLARE_VIEWS(92); - auto tmp = - (main_sel_op_internal_return * (main_internal_return_ptr_shift - (main_internal_return_ptr - FF(1)))); + auto tmp = (main_sel_op_internal_call * (main_sel_mem_op_b - FF(1))); tmp *= scaling_factor; std::get<92>(evals) += tmp; } // Contribution 93 { Avm_DECLARE_VIEWS(93); - auto tmp = (main_sel_op_internal_return * ((main_internal_return_ptr - FF(1)) - main_mem_addr_a)); + auto tmp = + (main_sel_op_internal_return * (main_internal_return_ptr_shift - (main_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<93>(evals) += tmp; } // Contribution 94 { Avm_DECLARE_VIEWS(94); - auto tmp = (main_sel_op_internal_return * (main_pc_shift - main_ia)); + auto tmp = (main_sel_op_internal_return * ((main_internal_return_ptr - FF(1)) - main_mem_addr_a)); tmp *= scaling_factor; std::get<94>(evals) += tmp; } // Contribution 95 { Avm_DECLARE_VIEWS(95); - auto tmp = (main_sel_op_internal_return * main_rwa); + auto tmp = (main_sel_op_internal_return * (main_pc_shift - main_ia)); tmp *= scaling_factor; std::get<95>(evals) += tmp; } // Contribution 96 { Avm_DECLARE_VIEWS(96); - auto tmp = (main_sel_op_internal_return * (main_sel_mem_op_a - FF(1))); + auto tmp = (main_sel_op_internal_return * main_rwa); tmp *= scaling_factor; std::get<96>(evals) += tmp; } // Contribution 97 { Avm_DECLARE_VIEWS(97); - auto tmp = - (((((main_sel_gas_accounting_active - - (((((((main_sel_op_fdiv + - ((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + - main_sel_op_not) + - main_sel_op_eq) + - main_sel_op_lt) + - main_sel_op_lte) + - main_sel_op_shr) + - main_sel_op_shl) + - main_sel_op_cast)) + - ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)) + - (main_sel_op_cmov + main_sel_op_mov)) + - ((((main_sel_op_radix_le + main_sel_op_sha256) + main_sel_op_poseidon2) + main_sel_op_keccak) + - main_sel_op_pedersen)) + - (((((((((((main_sel_op_address + main_sel_op_storage_address) + main_sel_op_sender) + - main_sel_op_function_selector) + - main_sel_op_transaction_fee) + - main_sel_op_chain_id) + - main_sel_op_version) + - main_sel_op_block_number) + - main_sel_op_coinbase) + - main_sel_op_timestamp) + - main_sel_op_fee_per_l2_gas) + - main_sel_op_fee_per_da_gas)) + - ((((((main_sel_op_note_hash_exists + main_sel_op_emit_note_hash) + - main_sel_op_nullifier_exists) + - main_sel_op_emit_nullifier) + - main_sel_op_l1_to_l2_msg_exists) + - main_sel_op_emit_unencrypted_log) + - main_sel_op_emit_l2_to_l1_msg)) + - (main_sel_op_dagasleft + main_sel_op_l2gasleft))) - - (((main_sel_op_jump + main_sel_op_jumpi) + main_sel_op_internal_call) + - main_sel_op_internal_return)) - - main_sel_op_sload) - - main_sel_op_sstore) - - main_sel_mem_op_activate_gas); + auto tmp = (main_sel_op_internal_return * (main_sel_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<97>(evals) += tmp; } // Contribution 98 { Avm_DECLARE_VIEWS(98); + auto tmp = (((((main_sel_gas_accounting_active - + ((((((((main_sel_op_fdiv + + ((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + + main_sel_op_not) + + main_sel_op_eq) + + main_sel_op_lt) + + main_sel_op_lte) + + main_sel_op_shr) + + main_sel_op_shl) + + main_sel_op_cast)) + + ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)) + + (main_sel_op_cmov + main_sel_op_mov)) + + ((((main_sel_op_radix_le + main_sel_op_sha256) + main_sel_op_poseidon2) + + main_sel_op_keccak) + + main_sel_op_pedersen)) + + (((((((((((main_sel_op_address + main_sel_op_storage_address) + main_sel_op_sender) + + main_sel_op_function_selector) + + main_sel_op_transaction_fee) + + main_sel_op_chain_id) + + main_sel_op_version) + + main_sel_op_block_number) + + main_sel_op_coinbase) + + main_sel_op_timestamp) + + main_sel_op_fee_per_l2_gas) + + main_sel_op_fee_per_da_gas)) + + ((((((main_sel_op_note_hash_exists + main_sel_op_emit_note_hash) + + main_sel_op_nullifier_exists) + + main_sel_op_emit_nullifier) + + main_sel_op_l1_to_l2_msg_exists) + + main_sel_op_emit_unencrypted_log) + + main_sel_op_emit_l2_to_l1_msg)) + + (main_sel_op_dagasleft + main_sel_op_l2gasleft)) + + main_sel_op_calldata_copy)) - + (((main_sel_op_jump + main_sel_op_jumpi) + main_sel_op_internal_call) + + main_sel_op_internal_return)) - + main_sel_op_sload) - + main_sel_op_sstore) - + main_sel_mem_op_activate_gas); + tmp *= scaling_factor; + std::get<98>(evals) += tmp; + } + // Contribution 99 + { + Avm_DECLARE_VIEWS(99); auto tmp = ((((-main_sel_first + FF(1)) * (-main_sel_op_halt + FF(1))) * - (((((((main_sel_op_fdiv + + ((((((((main_sel_op_fdiv + + ((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + + main_sel_op_not) + + main_sel_op_eq) + + main_sel_op_lt) + + main_sel_op_lte) + + main_sel_op_shr) + + main_sel_op_shl) + + main_sel_op_cast)) + + ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)) + + (main_sel_op_cmov + main_sel_op_mov)) + + ((((main_sel_op_radix_le + main_sel_op_sha256) + main_sel_op_poseidon2) + main_sel_op_keccak) + + main_sel_op_pedersen)) + + (((((((((((main_sel_op_address + main_sel_op_storage_address) + main_sel_op_sender) + + main_sel_op_function_selector) + + main_sel_op_transaction_fee) + + main_sel_op_chain_id) + + main_sel_op_version) + + main_sel_op_block_number) + + main_sel_op_coinbase) + + main_sel_op_timestamp) + + main_sel_op_fee_per_l2_gas) + + main_sel_op_fee_per_da_gas)) + + ((((((main_sel_op_note_hash_exists + main_sel_op_emit_note_hash) + main_sel_op_nullifier_exists) + + main_sel_op_emit_nullifier) + + main_sel_op_l1_to_l2_msg_exists) + + main_sel_op_emit_unencrypted_log) + + main_sel_op_emit_l2_to_l1_msg)) + + (main_sel_op_dagasleft + main_sel_op_l2gasleft)) + + main_sel_op_calldata_copy)) * + (main_pc_shift - (main_pc + FF(1)))); + tmp *= scaling_factor; + std::get<99>(evals) += tmp; + } + // Contribution 100 + { + Avm_DECLARE_VIEWS(100); + auto tmp = + ((-(((main_sel_first + main_sel_op_internal_call) + main_sel_op_internal_return) + main_sel_op_halt) + + FF(1)) * + (main_internal_return_ptr_shift - main_internal_return_ptr)); + tmp *= scaling_factor; + std::get<100>(evals) += tmp; + } + // Contribution 101 + { + Avm_DECLARE_VIEWS(101); + auto tmp = ((main_sel_op_internal_call + main_sel_op_internal_return) * (main_space_id - FF(255))); + tmp *= scaling_factor; + std::get<101>(evals) += tmp; + } + // Contribution 102 + { + Avm_DECLARE_VIEWS(102); + auto tmp = + (((((((((main_sel_op_fdiv + ((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + main_sel_op_not) + main_sel_op_eq) + @@ -1036,117 +1102,64 @@ template class mainImpl { main_sel_op_l1_to_l2_msg_exists) + main_sel_op_emit_unencrypted_log) + main_sel_op_emit_l2_to_l1_msg)) + - (main_sel_op_dagasleft + main_sel_op_l2gasleft))) * - (main_pc_shift - (main_pc + FF(1)))); - tmp *= scaling_factor; - std::get<98>(evals) += tmp; - } - // Contribution 99 - { - Avm_DECLARE_VIEWS(99); - auto tmp = - ((-(((main_sel_first + main_sel_op_internal_call) + main_sel_op_internal_return) + main_sel_op_halt) + - FF(1)) * - (main_internal_return_ptr_shift - main_internal_return_ptr)); - tmp *= scaling_factor; - std::get<99>(evals) += tmp; - } - // Contribution 100 - { - Avm_DECLARE_VIEWS(100); - auto tmp = ((main_sel_op_internal_call + main_sel_op_internal_return) * (main_space_id - FF(255))); - tmp *= scaling_factor; - std::get<100>(evals) += tmp; - } - // Contribution 101 - { - Avm_DECLARE_VIEWS(101); - auto tmp = - ((((((((main_sel_op_fdiv + - ((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + - main_sel_op_not) + - main_sel_op_eq) + - main_sel_op_lt) + - main_sel_op_lte) + - main_sel_op_shr) + - main_sel_op_shl) + - main_sel_op_cast)) + - ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)) + - (main_sel_op_cmov + main_sel_op_mov)) + - ((((main_sel_op_radix_le + main_sel_op_sha256) + main_sel_op_poseidon2) + main_sel_op_keccak) + - main_sel_op_pedersen)) + - (((((((((((main_sel_op_address + main_sel_op_storage_address) + main_sel_op_sender) + - main_sel_op_function_selector) + - main_sel_op_transaction_fee) + - main_sel_op_chain_id) + - main_sel_op_version) + - main_sel_op_block_number) + - main_sel_op_coinbase) + - main_sel_op_timestamp) + - main_sel_op_fee_per_l2_gas) + - main_sel_op_fee_per_da_gas)) + - ((((((main_sel_op_note_hash_exists + main_sel_op_emit_note_hash) + main_sel_op_nullifier_exists) + - main_sel_op_emit_nullifier) + - main_sel_op_l1_to_l2_msg_exists) + - main_sel_op_emit_unencrypted_log) + - main_sel_op_emit_l2_to_l1_msg)) + - (main_sel_op_dagasleft + main_sel_op_l2gasleft)) * + (main_sel_op_dagasleft + main_sel_op_l2gasleft)) + + main_sel_op_calldata_copy) * (main_call_ptr - main_space_id)); tmp *= scaling_factor; - std::get<101>(evals) += tmp; - } - // Contribution 102 - { - Avm_DECLARE_VIEWS(102); - auto tmp = ((main_sel_op_cmov + main_sel_op_jumpi) * (((main_id * main_inv) - FF(1)) + main_id_zero)); - tmp *= scaling_factor; std::get<102>(evals) += tmp; } // Contribution 103 { Avm_DECLARE_VIEWS(103); - auto tmp = (((main_sel_op_cmov + main_sel_op_jumpi) * main_id_zero) * (-main_inv + FF(1))); + auto tmp = ((main_sel_op_cmov + main_sel_op_jumpi) * (((main_id * main_inv) - FF(1)) + main_id_zero)); tmp *= scaling_factor; std::get<103>(evals) += tmp; } // Contribution 104 { Avm_DECLARE_VIEWS(104); - auto tmp = (main_sel_mov_ia_to_ic - (main_sel_op_mov + (main_sel_op_cmov * (-main_id_zero + FF(1))))); + auto tmp = (((main_sel_op_cmov + main_sel_op_jumpi) * main_id_zero) * (-main_inv + FF(1))); tmp *= scaling_factor; std::get<104>(evals) += tmp; } // Contribution 105 { Avm_DECLARE_VIEWS(105); - auto tmp = (main_sel_mov_ib_to_ic - (main_sel_op_cmov * main_id_zero)); + auto tmp = (main_sel_mov_ia_to_ic - (main_sel_op_mov + (main_sel_op_cmov * (-main_id_zero + FF(1))))); tmp *= scaling_factor; std::get<105>(evals) += tmp; } // Contribution 106 { Avm_DECLARE_VIEWS(106); - auto tmp = (main_sel_mov_ia_to_ic * (main_ia - main_ic)); + auto tmp = (main_sel_mov_ib_to_ic - (main_sel_op_cmov * main_id_zero)); tmp *= scaling_factor; std::get<106>(evals) += tmp; } // Contribution 107 { Avm_DECLARE_VIEWS(107); - auto tmp = (main_sel_mov_ib_to_ic * (main_ib - main_ic)); + auto tmp = (main_sel_mov_ia_to_ic * (main_ia - main_ic)); tmp *= scaling_factor; std::get<107>(evals) += tmp; } // Contribution 108 { Avm_DECLARE_VIEWS(108); - auto tmp = ((main_sel_op_mov + main_sel_op_cmov) * (main_r_in_tag - main_w_in_tag)); + auto tmp = (main_sel_mov_ib_to_ic * (main_ib - main_ic)); tmp *= scaling_factor; std::get<108>(evals) += tmp; } // Contribution 109 { Avm_DECLARE_VIEWS(109); + auto tmp = ((main_sel_op_mov + main_sel_op_cmov) * (main_r_in_tag - main_w_in_tag)); + tmp *= scaling_factor; + std::get<109>(evals) += tmp; + } + // Contribution 110 + { + Avm_DECLARE_VIEWS(110); auto tmp = (main_sel_alu - ((((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + main_sel_op_not) + @@ -1159,11 +1172,11 @@ template class mainImpl { (-main_tag_err + FF(1))) * (-main_op_err + FF(1)))); tmp *= scaling_factor; - std::get<109>(evals) += tmp; + std::get<110>(evals) += tmp; } - // Contribution 110 + // Contribution 111 { - Avm_DECLARE_VIEWS(110); + Avm_DECLARE_VIEWS(111); auto tmp = ((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + main_sel_op_not) + main_sel_op_eq) + @@ -1173,258 +1186,258 @@ template class mainImpl { main_sel_op_shl) * (main_alu_in_tag - main_r_in_tag)); tmp *= scaling_factor; - std::get<110>(evals) += tmp; - } - // Contribution 111 - { - Avm_DECLARE_VIEWS(111); - auto tmp = (main_sel_op_cast * (main_alu_in_tag - main_w_in_tag)); - tmp *= scaling_factor; std::get<111>(evals) += tmp; } // Contribution 112 { Avm_DECLARE_VIEWS(112); - auto tmp = (main_sel_op_l2gasleft * (main_ia - main_l2_gas_remaining_shift)); + auto tmp = (main_sel_op_cast * (main_alu_in_tag - main_w_in_tag)); tmp *= scaling_factor; std::get<112>(evals) += tmp; } // Contribution 113 { Avm_DECLARE_VIEWS(113); - auto tmp = (main_sel_op_dagasleft * (main_ia - main_da_gas_remaining_shift)); + auto tmp = (main_sel_op_l2gasleft * (main_ia - main_l2_gas_remaining_shift)); tmp *= scaling_factor; std::get<113>(evals) += tmp; } // Contribution 114 { Avm_DECLARE_VIEWS(114); - auto tmp = (main_sel_op_address * (kernel_kernel_in_offset - FF(1))); + auto tmp = (main_sel_op_dagasleft * (main_ia - main_da_gas_remaining_shift)); tmp *= scaling_factor; std::get<114>(evals) += tmp; } // Contribution 115 { Avm_DECLARE_VIEWS(115); - auto tmp = (main_sel_op_storage_address * (kernel_kernel_in_offset - FF(1))); + auto tmp = (main_sel_op_address * (kernel_kernel_in_offset - FF(1))); tmp *= scaling_factor; std::get<115>(evals) += tmp; } // Contribution 116 { Avm_DECLARE_VIEWS(116); - auto tmp = (main_sel_op_sender * kernel_kernel_in_offset); + auto tmp = (main_sel_op_storage_address * (kernel_kernel_in_offset - FF(1))); tmp *= scaling_factor; std::get<116>(evals) += tmp; } // Contribution 117 { Avm_DECLARE_VIEWS(117); - auto tmp = (main_sel_op_function_selector * (kernel_kernel_in_offset - FF(2))); + auto tmp = (main_sel_op_sender * kernel_kernel_in_offset); tmp *= scaling_factor; std::get<117>(evals) += tmp; } // Contribution 118 { Avm_DECLARE_VIEWS(118); - auto tmp = (main_sel_op_transaction_fee * (kernel_kernel_in_offset - FF(39))); + auto tmp = (main_sel_op_function_selector * (kernel_kernel_in_offset - FF(2))); tmp *= scaling_factor; std::get<118>(evals) += tmp; } // Contribution 119 { Avm_DECLARE_VIEWS(119); - auto tmp = (main_sel_op_chain_id * (kernel_kernel_in_offset - FF(28))); + auto tmp = (main_sel_op_transaction_fee * (kernel_kernel_in_offset - FF(39))); tmp *= scaling_factor; std::get<119>(evals) += tmp; } // Contribution 120 { Avm_DECLARE_VIEWS(120); - auto tmp = (main_sel_op_version * (kernel_kernel_in_offset - FF(29))); + auto tmp = (main_sel_op_chain_id * (kernel_kernel_in_offset - FF(28))); tmp *= scaling_factor; std::get<120>(evals) += tmp; } // Contribution 121 { Avm_DECLARE_VIEWS(121); - auto tmp = (main_sel_op_block_number * (kernel_kernel_in_offset - FF(30))); + auto tmp = (main_sel_op_version * (kernel_kernel_in_offset - FF(29))); tmp *= scaling_factor; std::get<121>(evals) += tmp; } // Contribution 122 { Avm_DECLARE_VIEWS(122); - auto tmp = (main_sel_op_timestamp * (kernel_kernel_in_offset - FF(31))); + auto tmp = (main_sel_op_block_number * (kernel_kernel_in_offset - FF(30))); tmp *= scaling_factor; std::get<122>(evals) += tmp; } // Contribution 123 { Avm_DECLARE_VIEWS(123); - auto tmp = (main_sel_op_coinbase * (kernel_kernel_in_offset - FF(32))); + auto tmp = (main_sel_op_timestamp * (kernel_kernel_in_offset - FF(31))); tmp *= scaling_factor; std::get<123>(evals) += tmp; } // Contribution 124 { Avm_DECLARE_VIEWS(124); - auto tmp = (main_sel_op_fee_per_da_gas * (kernel_kernel_in_offset - FF(34))); + auto tmp = (main_sel_op_coinbase * (kernel_kernel_in_offset - FF(32))); tmp *= scaling_factor; std::get<124>(evals) += tmp; } // Contribution 125 { Avm_DECLARE_VIEWS(125); - auto tmp = (main_sel_op_fee_per_l2_gas * (kernel_kernel_in_offset - FF(35))); + auto tmp = (main_sel_op_fee_per_da_gas * (kernel_kernel_in_offset - FF(34))); tmp *= scaling_factor; std::get<125>(evals) += tmp; } // Contribution 126 { Avm_DECLARE_VIEWS(126); - auto tmp = (main_sel_op_note_hash_exists * - (kernel_kernel_out_offset - (kernel_note_hash_exist_write_offset + FF(0)))); + auto tmp = (main_sel_op_fee_per_l2_gas * (kernel_kernel_in_offset - FF(35))); tmp *= scaling_factor; std::get<126>(evals) += tmp; } // Contribution 127 { Avm_DECLARE_VIEWS(127); - auto tmp = (main_sel_first * kernel_note_hash_exist_write_offset); + auto tmp = (main_sel_op_note_hash_exists * + (kernel_kernel_out_offset - (kernel_note_hash_exist_write_offset + FF(0)))); tmp *= scaling_factor; std::get<127>(evals) += tmp; } // Contribution 128 { Avm_DECLARE_VIEWS(128); - auto tmp = (main_sel_op_emit_note_hash * - (kernel_kernel_out_offset - (kernel_emit_note_hash_write_offset + FF(128)))); + auto tmp = (main_sel_first * kernel_note_hash_exist_write_offset); tmp *= scaling_factor; std::get<128>(evals) += tmp; } // Contribution 129 { Avm_DECLARE_VIEWS(129); - auto tmp = (main_sel_first * kernel_emit_note_hash_write_offset); + auto tmp = (main_sel_op_emit_note_hash * + (kernel_kernel_out_offset - (kernel_emit_note_hash_write_offset + FF(128)))); tmp *= scaling_factor; std::get<129>(evals) += tmp; } // Contribution 130 { Avm_DECLARE_VIEWS(130); - auto tmp = (main_sel_op_nullifier_exists * - (kernel_kernel_out_offset - - ((main_ib * (kernel_nullifier_exists_write_offset + FF(16))) + - ((-main_ib + FF(1)) * (kernel_nullifier_non_exists_write_offset + FF(32)))))); + auto tmp = (main_sel_first * kernel_emit_note_hash_write_offset); tmp *= scaling_factor; std::get<130>(evals) += tmp; } // Contribution 131 { Avm_DECLARE_VIEWS(131); - auto tmp = (main_sel_first * kernel_nullifier_exists_write_offset); + auto tmp = (main_sel_op_nullifier_exists * + (kernel_kernel_out_offset - + ((main_ib * (kernel_nullifier_exists_write_offset + FF(16))) + + ((-main_ib + FF(1)) * (kernel_nullifier_non_exists_write_offset + FF(32)))))); tmp *= scaling_factor; std::get<131>(evals) += tmp; } // Contribution 132 { Avm_DECLARE_VIEWS(132); - auto tmp = (main_sel_first * kernel_nullifier_non_exists_write_offset); + auto tmp = (main_sel_first * kernel_nullifier_exists_write_offset); tmp *= scaling_factor; std::get<132>(evals) += tmp; } // Contribution 133 { Avm_DECLARE_VIEWS(133); - auto tmp = (main_sel_op_emit_nullifier * - (kernel_kernel_out_offset - (kernel_emit_nullifier_write_offset + FF(144)))); + auto tmp = (main_sel_first * kernel_nullifier_non_exists_write_offset); tmp *= scaling_factor; std::get<133>(evals) += tmp; } // Contribution 134 { Avm_DECLARE_VIEWS(134); - auto tmp = (main_sel_first * kernel_emit_nullifier_write_offset); + auto tmp = (main_sel_op_emit_nullifier * + (kernel_kernel_out_offset - (kernel_emit_nullifier_write_offset + FF(144)))); tmp *= scaling_factor; std::get<134>(evals) += tmp; } // Contribution 135 { Avm_DECLARE_VIEWS(135); - auto tmp = (main_sel_op_l1_to_l2_msg_exists * - (kernel_kernel_out_offset - (kernel_l1_to_l2_msg_exists_write_offset + FF(48)))); + auto tmp = (main_sel_first * kernel_emit_nullifier_write_offset); tmp *= scaling_factor; std::get<135>(evals) += tmp; } // Contribution 136 { Avm_DECLARE_VIEWS(136); - auto tmp = (main_sel_first * kernel_l1_to_l2_msg_exists_write_offset); + auto tmp = (main_sel_op_l1_to_l2_msg_exists * + (kernel_kernel_out_offset - (kernel_l1_to_l2_msg_exists_write_offset + FF(48)))); tmp *= scaling_factor; std::get<136>(evals) += tmp; } // Contribution 137 { Avm_DECLARE_VIEWS(137); - auto tmp = (main_sel_op_emit_unencrypted_log * - (kernel_kernel_out_offset - (kernel_emit_unencrypted_log_write_offset + FF(162)))); + auto tmp = (main_sel_first * kernel_l1_to_l2_msg_exists_write_offset); tmp *= scaling_factor; std::get<137>(evals) += tmp; } // Contribution 138 { Avm_DECLARE_VIEWS(138); - auto tmp = (main_sel_first * kernel_emit_unencrypted_log_write_offset); + auto tmp = (main_sel_op_emit_unencrypted_log * + (kernel_kernel_out_offset - (kernel_emit_unencrypted_log_write_offset + FF(162)))); tmp *= scaling_factor; std::get<138>(evals) += tmp; } // Contribution 139 { Avm_DECLARE_VIEWS(139); - auto tmp = (main_sel_op_emit_l2_to_l1_msg * - (kernel_kernel_out_offset - (kernel_emit_l2_to_l1_msg_write_offset + FF(160)))); + auto tmp = (main_sel_first * kernel_emit_unencrypted_log_write_offset); tmp *= scaling_factor; std::get<139>(evals) += tmp; } // Contribution 140 { Avm_DECLARE_VIEWS(140); - auto tmp = (main_sel_first * kernel_emit_l2_to_l1_msg_write_offset); + auto tmp = (main_sel_op_emit_l2_to_l1_msg * + (kernel_kernel_out_offset - (kernel_emit_l2_to_l1_msg_write_offset + FF(160)))); tmp *= scaling_factor; std::get<140>(evals) += tmp; } // Contribution 141 { Avm_DECLARE_VIEWS(141); - auto tmp = (main_sel_op_sload * (kernel_kernel_out_offset - (kernel_sload_write_offset + FF(96)))); + auto tmp = (main_sel_first * kernel_emit_l2_to_l1_msg_write_offset); tmp *= scaling_factor; std::get<141>(evals) += tmp; } // Contribution 142 { Avm_DECLARE_VIEWS(142); - auto tmp = (main_sel_first * kernel_sload_write_offset); + auto tmp = (main_sel_op_sload * (kernel_kernel_out_offset - (kernel_sload_write_offset + FF(96)))); tmp *= scaling_factor; std::get<142>(evals) += tmp; } // Contribution 143 { Avm_DECLARE_VIEWS(143); - auto tmp = (main_sel_op_sstore * (kernel_kernel_out_offset - (kernel_sstore_write_offset + FF(64)))); + auto tmp = (main_sel_first * kernel_sload_write_offset); tmp *= scaling_factor; std::get<143>(evals) += tmp; } // Contribution 144 { Avm_DECLARE_VIEWS(144); - auto tmp = (main_sel_first * kernel_sstore_write_offset); + auto tmp = (main_sel_op_sstore * (kernel_kernel_out_offset - (kernel_sstore_write_offset + FF(64)))); tmp *= scaling_factor; std::get<144>(evals) += tmp; } // Contribution 145 { Avm_DECLARE_VIEWS(145); + auto tmp = (main_sel_first * kernel_sstore_write_offset); + tmp *= scaling_factor; + std::get<145>(evals) += tmp; + } + // Contribution 146 + { + Avm_DECLARE_VIEWS(146); auto tmp = (((((((main_sel_op_note_hash_exists + main_sel_op_emit_note_hash) + main_sel_op_nullifier_exists) + main_sel_op_emit_nullifier) + @@ -1433,21 +1446,28 @@ template class mainImpl { main_sel_op_emit_l2_to_l1_msg) * (kernel_side_effect_counter_shift - (kernel_side_effect_counter + FF(1)))); tmp *= scaling_factor; - std::get<145>(evals) += tmp; + std::get<146>(evals) += tmp; } - // Contribution 146 + // Contribution 147 { - Avm_DECLARE_VIEWS(146); + Avm_DECLARE_VIEWS(147); + auto tmp = (main_sel_cd_cpy_gadget - (main_sel_op_calldata_copy * (-main_tag_err + FF(1)))); + tmp *= scaling_factor; + std::get<147>(evals) += tmp; + } + // Contribution 148 + { + Avm_DECLARE_VIEWS(148); auto tmp = (main_bin_op_id - (main_sel_op_or + (main_sel_op_xor * FF(2)))); tmp *= scaling_factor; - std::get<146>(evals) += tmp; + std::get<148>(evals) += tmp; } - // Contribution 147 + // Contribution 149 { - Avm_DECLARE_VIEWS(147); + Avm_DECLARE_VIEWS(149); auto tmp = (main_sel_bin - ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)); tmp *= scaling_factor; - std::get<147>(evals) += tmp; + std::get<149>(evals) += tmp; } } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp index 232d79fe1906..2bfe89dd24e8 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp @@ -28,6 +28,7 @@ template struct MemRow { FF mem_sel_op_a{}; FF mem_sel_op_b{}; FF mem_sel_op_c{}; + FF mem_sel_op_cd_cpy{}; FF mem_sel_op_cmov{}; FF mem_sel_op_d{}; FF mem_sel_resolve_ind_addr_a{}; @@ -50,39 +51,39 @@ template struct MemRow { inline std::string get_relation_label_mem(int index) { switch (index) { - case 14: - return "MEM_CONTIGUOUS"; case 15: - return "MEM_FIRST_EMPTY"; + return "MEM_CONTIGUOUS"; case 16: + return "MEM_FIRST_EMPTY"; + case 17: return "MEM_LAST"; - case 18: - return "TIMESTAMP"; case 19: - return "GLOBAL_ADDR"; + return "TIMESTAMP"; case 20: - return "LAST_ACCESS_FIRST_ROW"; + return "GLOBAL_ADDR"; case 21: - return "MEM_LAST_ACCESS_DELIMITER"; + return "LAST_ACCESS_FIRST_ROW"; case 22: - return "DIFF_RNG_CHK_DEC"; + return "MEM_LAST_ACCESS_DELIMITER"; case 23: - return "MEM_READ_WRITE_VAL_CONSISTENCY"; + return "DIFF_RNG_CHK_DEC"; case 24: - return "MEM_READ_WRITE_TAG_CONSISTENCY"; + return "MEM_READ_WRITE_VAL_CONSISTENCY"; case 25: - return "MEM_ZERO_INIT"; + return "MEM_READ_WRITE_TAG_CONSISTENCY"; case 26: - return "SKIP_CHECK_TAG"; + return "MEM_ZERO_INIT"; case 27: - return "MEM_IN_TAG_CONSISTENCY_1"; + return "SKIP_CHECK_TAG"; case 28: - return "MEM_IN_TAG_CONSISTENCY_2"; + return "MEM_IN_TAG_CONSISTENCY_1"; case 29: + return "MEM_IN_TAG_CONSISTENCY_2"; + case 30: return "NO_TAG_ERR_WRITE_OR_SKIP"; - case 31: + case 32: return "NO_TAG_ERR_WRITE"; - case 40: + case 43: return "MOV_SAME_TAG"; } return std::to_string(index); @@ -92,9 +93,9 @@ template class memImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 3, - 4, 3, 4, 3, 4, 3, 3, 3, 4, 4, 4, 4, 4, 6, - 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 3, + 4, 3, 4, 3, 4, 3, 3, 3, 4, 4, 4, 4, 4, 6, 4, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; template void static accumulate(ContainerOverSubrelations& evals, @@ -161,81 +162,89 @@ template class memImpl { // Contribution 8 { Avm_DECLARE_VIEWS(8); - auto tmp = (mem_sel_resolve_ind_addr_a * (-mem_sel_resolve_ind_addr_a + FF(1))); + auto tmp = (mem_sel_op_cd_cpy * (-mem_sel_op_cd_cpy + FF(1))); tmp *= scaling_factor; std::get<8>(evals) += tmp; } // Contribution 9 { Avm_DECLARE_VIEWS(9); - auto tmp = (mem_sel_resolve_ind_addr_b * (-mem_sel_resolve_ind_addr_b + FF(1))); + auto tmp = (mem_sel_resolve_ind_addr_a * (-mem_sel_resolve_ind_addr_a + FF(1))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } // Contribution 10 { Avm_DECLARE_VIEWS(10); - auto tmp = (mem_sel_resolve_ind_addr_c * (-mem_sel_resolve_ind_addr_c + FF(1))); + auto tmp = (mem_sel_resolve_ind_addr_b * (-mem_sel_resolve_ind_addr_b + FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; } // Contribution 11 { Avm_DECLARE_VIEWS(11); - auto tmp = (mem_sel_resolve_ind_addr_d * (-mem_sel_resolve_ind_addr_d + FF(1))); + auto tmp = (mem_sel_resolve_ind_addr_c * (-mem_sel_resolve_ind_addr_c + FF(1))); tmp *= scaling_factor; std::get<11>(evals) += tmp; } // Contribution 12 { Avm_DECLARE_VIEWS(12); - auto tmp = - (mem_sel_mem - - (((((((mem_sel_op_a + mem_sel_op_b) + mem_sel_op_c) + mem_sel_op_d) + mem_sel_resolve_ind_addr_a) + - mem_sel_resolve_ind_addr_b) + - mem_sel_resolve_ind_addr_c) + - mem_sel_resolve_ind_addr_d)); + auto tmp = (mem_sel_resolve_ind_addr_d * (-mem_sel_resolve_ind_addr_d + FF(1))); tmp *= scaling_factor; std::get<12>(evals) += tmp; } // Contribution 13 { Avm_DECLARE_VIEWS(13); - auto tmp = (mem_sel_mem * (mem_sel_mem - FF(1))); + auto tmp = + (mem_sel_mem - + ((((((((mem_sel_op_a + mem_sel_op_b) + mem_sel_op_c) + mem_sel_op_d) + mem_sel_resolve_ind_addr_a) + + mem_sel_resolve_ind_addr_b) + + mem_sel_resolve_ind_addr_c) + + mem_sel_resolve_ind_addr_d) + + mem_sel_op_cd_cpy)); tmp *= scaling_factor; std::get<13>(evals) += tmp; } // Contribution 14 { Avm_DECLARE_VIEWS(14); - auto tmp = (((-main_sel_first + FF(1)) * mem_sel_mem_shift) * (-mem_sel_mem + FF(1))); + auto tmp = (mem_sel_mem * (mem_sel_mem - FF(1))); tmp *= scaling_factor; std::get<14>(evals) += tmp; } // Contribution 15 { Avm_DECLARE_VIEWS(15); - auto tmp = (main_sel_first * mem_sel_mem); + auto tmp = (((-main_sel_first + FF(1)) * mem_sel_mem_shift) * (-mem_sel_mem + FF(1))); tmp *= scaling_factor; std::get<15>(evals) += tmp; } // Contribution 16 { Avm_DECLARE_VIEWS(16); - auto tmp = (((-mem_last + FF(1)) * mem_sel_mem) * (-mem_sel_mem_shift + FF(1))); + auto tmp = (main_sel_first * mem_sel_mem); tmp *= scaling_factor; std::get<16>(evals) += tmp; } // Contribution 17 { Avm_DECLARE_VIEWS(17); - auto tmp = (mem_sel_rng_chk - (mem_sel_mem * (-mem_last + FF(1)))); + auto tmp = (((-mem_last + FF(1)) * mem_sel_mem) * (-mem_sel_mem_shift + FF(1))); tmp *= scaling_factor; std::get<17>(evals) += tmp; } // Contribution 18 { Avm_DECLARE_VIEWS(18); + auto tmp = (mem_sel_rng_chk - (mem_sel_mem * (-mem_last + FF(1)))); + tmp *= scaling_factor; + std::get<18>(evals) += tmp; + } + // Contribution 19 + { + Avm_DECLARE_VIEWS(19); auto tmp = (mem_tsp - ((mem_clk * FF(12)) + @@ -249,169 +258,183 @@ template class memImpl { mem_rw) * FF(4)))))); tmp *= scaling_factor; - std::get<18>(evals) += tmp; - } - // Contribution 19 - { - Avm_DECLARE_VIEWS(19); - auto tmp = (mem_glob_addr - ((mem_space_id * FF(4294967296UL)) + mem_addr)); - tmp *= scaling_factor; std::get<19>(evals) += tmp; } // Contribution 20 { Avm_DECLARE_VIEWS(20); - auto tmp = (main_sel_first * (-mem_lastAccess + FF(1))); + auto tmp = (mem_glob_addr - ((mem_space_id * FF(4294967296UL)) + mem_addr)); tmp *= scaling_factor; std::get<20>(evals) += tmp; } // Contribution 21 { Avm_DECLARE_VIEWS(21); - auto tmp = ((-mem_lastAccess + FF(1)) * (mem_glob_addr_shift - mem_glob_addr)); + auto tmp = (main_sel_first * (-mem_lastAccess + FF(1))); tmp *= scaling_factor; std::get<21>(evals) += tmp; } // Contribution 22 { Avm_DECLARE_VIEWS(22); - auto tmp = (mem_sel_rng_chk * (((((mem_lastAccess * (mem_glob_addr_shift - mem_glob_addr)) + - ((-mem_lastAccess + FF(1)) * (mem_tsp_shift - mem_tsp))) - - (mem_diff_hi * FF(4294967296UL))) - - (mem_diff_mid * FF(65536))) - - mem_diff_lo)); + auto tmp = ((-mem_lastAccess + FF(1)) * (mem_glob_addr_shift - mem_glob_addr)); tmp *= scaling_factor; std::get<22>(evals) += tmp; } // Contribution 23 { Avm_DECLARE_VIEWS(23); - auto tmp = (((-mem_lastAccess + FF(1)) * (-mem_rw_shift + FF(1))) * (mem_val_shift - mem_val)); + auto tmp = (mem_sel_rng_chk * (((((mem_lastAccess * (mem_glob_addr_shift - mem_glob_addr)) + + ((-mem_lastAccess + FF(1)) * (mem_tsp_shift - mem_tsp))) - + (mem_diff_hi * FF(4294967296UL))) - + (mem_diff_mid * FF(65536))) - + mem_diff_lo)); tmp *= scaling_factor; std::get<23>(evals) += tmp; } // Contribution 24 { Avm_DECLARE_VIEWS(24); - auto tmp = (((-mem_lastAccess + FF(1)) * (-mem_rw_shift + FF(1))) * (mem_tag_shift - mem_tag)); + auto tmp = (((-mem_lastAccess + FF(1)) * (-mem_rw_shift + FF(1))) * (mem_val_shift - mem_val)); tmp *= scaling_factor; std::get<24>(evals) += tmp; } // Contribution 25 { Avm_DECLARE_VIEWS(25); - auto tmp = ((mem_lastAccess * (-mem_rw_shift + FF(1))) * mem_val_shift); + auto tmp = (((-mem_lastAccess + FF(1)) * (-mem_rw_shift + FF(1))) * (mem_tag_shift - mem_tag)); tmp *= scaling_factor; std::get<25>(evals) += tmp; } // Contribution 26 { Avm_DECLARE_VIEWS(26); - auto tmp = (mem_skip_check_tag - - (mem_sel_op_cmov * ((mem_sel_op_d + (mem_sel_op_a * (-mem_sel_mov_ia_to_ic + FF(1)))) + - (mem_sel_op_b * (-mem_sel_mov_ib_to_ic + FF(1)))))); + auto tmp = ((mem_lastAccess * (-mem_rw_shift + FF(1))) * mem_val_shift); tmp *= scaling_factor; std::get<26>(evals) += tmp; } // Contribution 27 { Avm_DECLARE_VIEWS(27); - auto tmp = (((mem_tag * (-mem_skip_check_tag + FF(1))) * (-mem_rw + FF(1))) * - (((mem_r_in_tag - mem_tag) * (-mem_one_min_inv + FF(1))) - mem_tag_err)); + auto tmp = (mem_skip_check_tag - + (mem_sel_op_cmov * ((mem_sel_op_d + (mem_sel_op_a * (-mem_sel_mov_ia_to_ic + FF(1)))) + + (mem_sel_op_b * (-mem_sel_mov_ib_to_ic + FF(1)))))); tmp *= scaling_factor; std::get<27>(evals) += tmp; } // Contribution 28 { Avm_DECLARE_VIEWS(28); - auto tmp = ((mem_tag * (-mem_tag_err + FF(1))) * mem_one_min_inv); + auto tmp = (((mem_tag * (-mem_skip_check_tag + FF(1))) * (-mem_rw + FF(1))) * + (((mem_r_in_tag - mem_tag) * (-mem_one_min_inv + FF(1))) - mem_tag_err)); tmp *= scaling_factor; std::get<28>(evals) += tmp; } // Contribution 29 { Avm_DECLARE_VIEWS(29); - auto tmp = ((mem_skip_check_tag + mem_rw) * mem_tag_err); + auto tmp = ((mem_tag * (-mem_tag_err + FF(1))) * mem_one_min_inv); tmp *= scaling_factor; std::get<29>(evals) += tmp; } // Contribution 30 { Avm_DECLARE_VIEWS(30); - auto tmp = (mem_rw * (mem_w_in_tag - mem_tag)); + auto tmp = ((mem_skip_check_tag + mem_rw) * mem_tag_err); tmp *= scaling_factor; std::get<30>(evals) += tmp; } // Contribution 31 { Avm_DECLARE_VIEWS(31); - auto tmp = (mem_rw * mem_tag_err); + auto tmp = (mem_rw * (mem_w_in_tag - mem_tag)); tmp *= scaling_factor; std::get<31>(evals) += tmp; } // Contribution 32 { Avm_DECLARE_VIEWS(32); - auto tmp = (mem_sel_resolve_ind_addr_a * (mem_r_in_tag - FF(3))); + auto tmp = (mem_rw * mem_tag_err); tmp *= scaling_factor; std::get<32>(evals) += tmp; } // Contribution 33 { Avm_DECLARE_VIEWS(33); - auto tmp = (mem_sel_resolve_ind_addr_b * (mem_r_in_tag - FF(3))); + auto tmp = (mem_sel_resolve_ind_addr_a * (mem_r_in_tag - FF(3))); tmp *= scaling_factor; std::get<33>(evals) += tmp; } // Contribution 34 { Avm_DECLARE_VIEWS(34); - auto tmp = (mem_sel_resolve_ind_addr_c * (mem_r_in_tag - FF(3))); + auto tmp = (mem_sel_resolve_ind_addr_b * (mem_r_in_tag - FF(3))); tmp *= scaling_factor; std::get<34>(evals) += tmp; } // Contribution 35 { Avm_DECLARE_VIEWS(35); - auto tmp = (mem_sel_resolve_ind_addr_d * (mem_r_in_tag - FF(3))); + auto tmp = (mem_sel_resolve_ind_addr_c * (mem_r_in_tag - FF(3))); tmp *= scaling_factor; std::get<35>(evals) += tmp; } // Contribution 36 { Avm_DECLARE_VIEWS(36); - auto tmp = (mem_sel_resolve_ind_addr_a * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_d * (mem_r_in_tag - FF(3))); tmp *= scaling_factor; std::get<36>(evals) += tmp; } // Contribution 37 { Avm_DECLARE_VIEWS(37); - auto tmp = (mem_sel_resolve_ind_addr_b * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_a * mem_rw); tmp *= scaling_factor; std::get<37>(evals) += tmp; } // Contribution 38 { Avm_DECLARE_VIEWS(38); - auto tmp = (mem_sel_resolve_ind_addr_c * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_b * mem_rw); tmp *= scaling_factor; std::get<38>(evals) += tmp; } // Contribution 39 { Avm_DECLARE_VIEWS(39); - auto tmp = (mem_sel_resolve_ind_addr_d * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_c * mem_rw); tmp *= scaling_factor; std::get<39>(evals) += tmp; } // Contribution 40 { Avm_DECLARE_VIEWS(40); - auto tmp = ((mem_sel_mov_ia_to_ic + mem_sel_mov_ib_to_ic) * mem_tag_err); + auto tmp = (mem_sel_resolve_ind_addr_d * mem_rw); tmp *= scaling_factor; std::get<40>(evals) += tmp; } + // Contribution 41 + { + Avm_DECLARE_VIEWS(41); + auto tmp = (mem_sel_op_cd_cpy * (mem_rw - FF(1))); + tmp *= scaling_factor; + std::get<41>(evals) += tmp; + } + // Contribution 42 + { + Avm_DECLARE_VIEWS(42); + auto tmp = (mem_sel_op_cd_cpy * (mem_w_in_tag - FF(6))); + tmp *= scaling_factor; + std::get<42>(evals) += tmp; + } + // Contribution 43 + { + Avm_DECLARE_VIEWS(43); + auto tmp = ((mem_sel_mov_ia_to_ic + mem_sel_mov_ib_to_ic) * mem_tag_err); + tmp *= scaling_factor; + std::get<43>(evals) += tmp; + } } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem_slice.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem_slice.hpp new file mode 100644 index 000000000000..a5ab245a42a9 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem_slice.hpp @@ -0,0 +1,104 @@ +#pragma once + +#include "barretenberg/relations/generated/avm/declare_views.hpp" +#include "barretenberg/relations/relation_parameters.hpp" +#include "barretenberg/relations/relation_types.hpp" + +namespace bb::Avm_vm { + +template struct MemSliceRow { + FF slice_addr{}; + FF slice_addr_shift{}; + FF slice_cd_offset{}; + FF slice_cd_offset_shift{}; + FF slice_cnt{}; + FF slice_cnt_shift{}; + FF slice_one_min_inv{}; + FF slice_sel_cd_cpy{}; + FF slice_sel_start_cd_cpy{}; +}; + +inline std::string get_relation_label_mem_slice(int index) +{ + switch (index) { + case 2: + return "SLICE_CNT_ZERO_TEST1"; + case 3: + return "SLICE_CNT_ZERO_TEST2"; + case 4: + return "SLICE_CNT_DECREMENT"; + case 5: + return "ADDR_CNT_INCREMENT"; + case 6: + return "CD_OFFSET_INCREMENT"; + } + return std::to_string(index); +} + +template class mem_sliceImpl { + public: + using FF = FF_; + + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3 }; + + template + void static accumulate(ContainerOverSubrelations& evals, + const AllEntities& new_term, + [[maybe_unused]] const RelationParameters&, + [[maybe_unused]] const FF& scaling_factor) + { + // Contribution 0 + { + Avm_DECLARE_VIEWS(0); + auto tmp = (slice_sel_cd_cpy * (-slice_sel_cd_cpy + FF(1))); + tmp *= scaling_factor; + std::get<0>(evals) += tmp; + } + // Contribution 1 + { + Avm_DECLARE_VIEWS(1); + auto tmp = (slice_sel_start_cd_cpy * (-slice_sel_start_cd_cpy + FF(1))); + tmp *= scaling_factor; + std::get<1>(evals) += tmp; + } + // Contribution 2 + { + Avm_DECLARE_VIEWS(2); + auto tmp = ((slice_cnt * (-slice_one_min_inv + FF(1))) - slice_sel_cd_cpy); + tmp *= scaling_factor; + std::get<2>(evals) += tmp; + } + // Contribution 3 + { + Avm_DECLARE_VIEWS(3); + auto tmp = ((-slice_sel_cd_cpy + FF(1)) * slice_one_min_inv); + tmp *= scaling_factor; + std::get<3>(evals) += tmp; + } + // Contribution 4 + { + Avm_DECLARE_VIEWS(4); + auto tmp = (slice_sel_cd_cpy * ((slice_cnt - FF(1)) - slice_cnt_shift)); + tmp *= scaling_factor; + std::get<4>(evals) += tmp; + } + // Contribution 5 + { + Avm_DECLARE_VIEWS(5); + auto tmp = (slice_sel_cd_cpy * ((slice_addr + FF(1)) - slice_addr_shift)); + tmp *= scaling_factor; + std::get<5>(evals) += tmp; + } + // Contribution 6 + { + Avm_DECLARE_VIEWS(6); + auto tmp = (slice_sel_cd_cpy * ((slice_cd_offset + FF(1)) - slice_cd_offset_shift)); + tmp *= scaling_factor; + std::get<6>(evals) += tmp; + } + } +}; + +template using mem_slice = Relation>; + +} // namespace bb::Avm_vm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_cd_mem.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_cd_mem.hpp new file mode 100644 index 000000000000..fa14ab3a16ca --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_cd_mem.hpp @@ -0,0 +1,60 @@ +#pragma once + +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" + +#include +#include + +namespace bb { + +class perm_cd_mem_permutation_settings { + public: + // This constant defines how many columns are bundled together to form each set. + constexpr static size_t COLUMNS_PER_SET = 4; + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.slice_sel_cd_cpy == 1 || in.mem_sel_op_cd_cpy == 1); + } + + template static inline auto get_const_entities(const AllEntities& in) + { + return std::forward_as_tuple(in.perm_cd_mem, + in.slice_sel_cd_cpy, + in.slice_sel_cd_cpy, + in.mem_sel_op_cd_cpy, + in.slice_clk, + in.slice_space_id, + in.slice_addr, + in.slice_val, + in.mem_clk, + in.mem_space_id, + in.mem_addr, + in.mem_val); + } + + template static inline auto get_nonconst_entities(AllEntities& in) + { + return std::forward_as_tuple(in.perm_cd_mem, + in.slice_sel_cd_cpy, + in.slice_sel_cd_cpy, + in.mem_sel_op_cd_cpy, + in.slice_clk, + in.slice_space_id, + in.slice_addr, + in.slice_val, + in.mem_clk, + in.mem_space_id, + in.mem_addr, + in.mem_val); + } +}; + +template +class perm_cd_mem_relation : public GenericPermutationRelation { + public: + static constexpr const char* NAME = "perm_cd_mem"; +}; +template using perm_cd_mem = GenericPermutation; + +} // namespace bb \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cd_copy.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cd_copy.hpp new file mode 100644 index 000000000000..60111a5c2cdf --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cd_copy.hpp @@ -0,0 +1,56 @@ +#pragma once + +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" + +#include +#include + +namespace bb { + +class perm_main_cd_copy_permutation_settings { + public: + // This constant defines how many columns are bundled together to form each set. + constexpr static size_t COLUMNS_PER_SET = 3; + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.main_sel_cd_cpy_gadget == 1 || in.slice_sel_start_cd_cpy == 1); + } + + template static inline auto get_const_entities(const AllEntities& in) + { + return std::forward_as_tuple(in.perm_main_cd_copy, + in.main_sel_cd_cpy_gadget, + in.main_sel_cd_cpy_gadget, + in.slice_sel_start_cd_cpy, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.slice_cd_offset, + in.slice_cnt, + in.slice_addr); + } + + template static inline auto get_nonconst_entities(AllEntities& in) + { + return std::forward_as_tuple(in.perm_main_cd_copy, + in.main_sel_cd_cpy_gadget, + in.main_sel_cd_cpy_gadget, + in.slice_sel_start_cd_cpy, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.slice_cd_offset, + in.slice_cnt, + in.slice_addr); + } +}; + +template +class perm_main_cd_copy_relation : public GenericPermutationRelation { + public: + static constexpr const char* NAME = "perm_main_cd_copy"; +}; +template using perm_main_cd_copy = GenericPermutation; + +} // namespace bb \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.cpp index 59b0c41d9bac..241ee80c3578 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.cpp @@ -16,7 +16,7 @@ void AvmGasTraceBuilder::reset() std::vector AvmGasTraceBuilder::finalize() { return std::move(gas_trace); -}; +} void AvmGasTraceBuilder::set_initial_gas(uint32_t l2_gas, uint32_t da_gas) { diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.cpp index 231b62278a9b..99c3d10cac43 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.cpp @@ -3,7 +3,6 @@ #include #include "barretenberg/vm/avm_trace/avm_mem_trace.hpp" -#include "barretenberg/vm/generated/avm_circuit_builder.hpp" namespace bb::avm_trace { diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.cpp index e46fb93d6706..ecbe7b6c82a1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.cpp @@ -49,28 +49,29 @@ std::vector AvmMemTraceBuilder::finalize() * @param r_in_tag Read memory tag pertaining to the instruction * @param w_in_tag Write memory tag pertaining to the instruction * @param m_rw Boolean telling whether it is a load (false) or store operation (true). + * @param sel_op_cd_cpy Specific boolean selector for calldata_copy memory slice */ void AvmMemTraceBuilder::insert_in_mem_trace(uint8_t space_id, - uint32_t const m_clk, - uint32_t const m_sub_clk, - uint32_t const m_addr, + uint32_t m_clk, + uint32_t m_sub_clk, + uint32_t m_addr, FF const& m_val, - AvmMemoryTag const m_tag, - AvmMemoryTag const r_in_tag, - AvmMemoryTag const w_in_tag, - bool const m_rw) + AvmMemoryTag m_tag, + AvmMemoryTag r_in_tag, + AvmMemoryTag w_in_tag, + bool m_rw, + bool m_sel_op_cd_cpy) { - mem_trace.emplace_back(MemoryTraceEntry{ - .m_space_id = space_id, - .m_clk = m_clk, - .m_sub_clk = m_sub_clk, - .m_addr = m_addr, - .m_val = m_val, - .m_tag = m_tag, - .r_in_tag = r_in_tag, - .w_in_tag = w_in_tag, - .m_rw = m_rw, - }); + mem_trace.emplace_back(MemoryTraceEntry{ .m_space_id = space_id, + .m_clk = m_clk, + .m_sub_clk = m_sub_clk, + .m_addr = m_addr, + .m_val = m_val, + .m_tag = m_tag, + .r_in_tag = r_in_tag, + .w_in_tag = w_in_tag, + .m_rw = m_rw, + .m_sel_op_cd_cpy = m_sel_op_cd_cpy }); } // Memory operations need to be performed before the addition of the corresponding row in @@ -472,17 +473,34 @@ void AvmMemTraceBuilder::write_into_memory(uint8_t space_id, AvmMemoryTag r_in_tag, AvmMemoryTag w_in_tag) { - MemEntry memEntry{ val, w_in_tag }; - auto& mem_space = memory.at(space_id); - auto it = mem_space.find(addr); - if (it != mem_space.end()) { - it->second = memEntry; - } else { - mem_space.emplace(addr, memEntry); - } + write_in_simulated_mem_table(space_id, addr, val, w_in_tag); store_in_mem_trace(space_id, clk, interm_reg, addr, val, r_in_tag, w_in_tag); } +void AvmMemTraceBuilder::write_calldata_copy(std::vector const& calldata, + uint32_t clk, + uint8_t space_id, + uint32_t cd_offset, + uint32_t copy_size, + uint32_t direct_dst_offset) +{ + for (uint32_t i = 0; i < copy_size; i++) { + auto addr = direct_dst_offset + i; + auto val = calldata.at(cd_offset + i); + write_in_simulated_mem_table(space_id, addr, val, AvmMemoryTag::FF); + insert_in_mem_trace(space_id, + clk, + SUB_CLK_STORE_A, // Specific re-use of this value for calldatacopy write slice. + addr, + val, + AvmMemoryTag::FF, + AvmMemoryTag::U0, + AvmMemoryTag::FF, + true, + true); + } +} + bool AvmMemTraceBuilder::MemoryTraceEntry::operator<(const AvmMemTraceBuilder::MemoryTraceEntry& other) const { if (m_space_id < other.m_space_id) { @@ -514,4 +532,19 @@ bool AvmMemTraceBuilder::MemoryTraceEntry::operator<(const AvmMemTraceBuilder::M return m_sub_clk < other.m_sub_clk; } +void AvmMemTraceBuilder::write_in_simulated_mem_table(uint8_t space_id, + uint32_t addr, + FF const& val, + AvmMemoryTag w_in_tag) +{ + MemEntry memEntry{ val, w_in_tag }; + auto& mem_space = memory.at(space_id); + auto it = mem_space.find(addr); + if (it != mem_space.end()) { + it->second = memEntry; + } else { + mem_space.emplace(addr, memEntry); + } +} + } // namespace bb::avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.hpp index bd8e4b121e9c..23e8799f3c10 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.hpp @@ -43,6 +43,7 @@ class AvmMemTraceBuilder { bool m_sel_mov_ib_to_ic = false; bool m_sel_cmov = false; bool m_tag_err_count_relevant = false; + bool m_sel_op_cd_cpy = false; /** * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. We sort first by @@ -88,6 +89,12 @@ class AvmMemTraceBuilder { FF const& val, AvmMemoryTag r_in_tag, AvmMemoryTag w_in_tag); + void write_calldata_copy(std::vector const& calldata, + uint32_t clk, + uint8_t space_id, + uint32_t cd_offset, + uint32_t copy_size, + uint32_t direct_dst_offset); private: std::vector mem_trace; // Entries will be sorted by m_clk, m_sub_clk after finalize(). @@ -103,7 +110,8 @@ class AvmMemTraceBuilder { AvmMemoryTag m_tag, AvmMemoryTag r_in_tag, AvmMemoryTag w_in_tag, - bool m_rw); + bool m_rw, + bool m_sel_op_cd_cpy = false); void load_mismatch_tag_in_mem_trace(uint8_t space_id, uint32_t m_clk, @@ -128,5 +136,6 @@ class AvmMemTraceBuilder { FF const& val, AvmMemoryTag r_in_tag, AvmMemoryTag w_in_tag); + void write_in_simulated_mem_table(uint8_t space_id, uint32_t addr, FF const& val, AvmMemoryTag w_in_tag); }; } // namespace bb::avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index 805381a34e96..a03ad1ba28aa 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -23,6 +23,7 @@ #include "barretenberg/vm/avm_trace/avm_trace.hpp" #include "barretenberg/vm/avm_trace/fixed_gas.hpp" #include "barretenberg/vm/avm_trace/fixed_powers.hpp" +#include "barretenberg/vm/avm_trace/gadgets/avm_slice_trace.hpp" namespace bb::avm_trace { @@ -1638,108 +1639,49 @@ void AvmTraceBuilder::op_fee_per_da_gas(uint8_t indirect, uint32_t dst_offset) */ void AvmTraceBuilder::op_calldata_copy(uint8_t indirect, uint32_t cd_offset, uint32_t copy_size, uint32_t dst_offset) { - // We parallelize storing memory operations in chunk of 3, i.e., 1 per intermediate register. - // The variable pos is an index pointing to the first storing operation (pertaining to intermediate - // register Ia) relative to cd_offset: - // cd_offset + pos: Ia memory store operation - // cd_offset + pos + 1: Ib memory store operation - // cd_offset + pos + 2: Ic memory store operation + auto clk = static_cast(main_trace.size()) + 1; - uint32_t pos = 0; uint32_t direct_dst_offset = dst_offset; // Will be overwritten in indirect mode. - while (pos < copy_size) { - FF ib(0); - FF ic(0); - uint32_t mem_op_b(0); - uint32_t mem_op_c(0); - uint32_t mem_addr_b(0); - uint32_t mem_addr_c(0); - uint32_t rwb(0); - uint32_t rwc(0); - auto clk = static_cast(main_trace.size()) + 1; - - FF ia = calldata.at(cd_offset + pos); - uint32_t mem_op_a(1); - uint32_t rwa = 1; - - bool indirect_flag = false; - bool tag_match = true; - - if (pos == 0 && is_operand_indirect(indirect, 0)) { - indirect_flag = true; - auto ind_read = mem_trace_builder.indirect_read_and_load_from_memory( - call_ptr, clk, IndirectRegister::IND_A, dst_offset); - direct_dst_offset = uint32_t(ind_read.val); - tag_match = ind_read.tag_match; - } - - uint32_t mem_addr_a = direct_dst_offset + pos; - - // Storing from Ia - mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IA, mem_addr_a, ia, AvmMemoryTag::U0, AvmMemoryTag::FF); - - if (copy_size - pos > 1) { - ib = calldata.at(cd_offset + pos + 1); - mem_op_b = 1; - mem_addr_b = direct_dst_offset + pos + 1; - rwb = 1; - - // Storing from Ib - mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IB, mem_addr_b, ib, AvmMemoryTag::U0, AvmMemoryTag::FF); - } - - if (copy_size - pos > 2) { - ic = calldata.at(cd_offset + pos + 2); - mem_op_c = 1; - mem_addr_c = direct_dst_offset + pos + 2; - rwc = 1; - - // Storing from Ic - mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IC, mem_addr_c, ic, AvmMemoryTag::U0, AvmMemoryTag::FF); - } + bool indirect_flag = false; + bool tag_match = true; - // Constrain gas cost on the first row - if (pos == 0) { - gas_trace_builder.constrain_gas_lookup(clk, OpCode::CALLDATACOPY); - } + // The only memory operation performed from the main trace is a possible indirect load for resolving the + // direct destination offset stored in main_mem_addr_c. + // All the other memory operations are triggered by the slice gadget. - main_trace.push_back(Row{ - .main_clk = clk, - .main_call_ptr = call_ptr, - .main_ia = ia, - .main_ib = ib, - .main_ic = ic, - .main_ind_addr_a = indirect_flag ? FF(dst_offset) : FF(0), - .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_addr_a = FF(mem_addr_a), - .main_mem_addr_b = FF(mem_addr_b), - .main_mem_addr_c = FF(mem_addr_c), - .main_pc = FF(pc), - .main_rwa = FF(rwa), - .main_rwb = FF(rwb), - .main_rwc = FF(rwc), - .main_sel_mem_op_a = FF(mem_op_a), - .main_sel_mem_op_activate_gas = FF(static_cast( - pos == 0)), // TODO: remove in the long term. This activate gas only for the first row. - .main_sel_mem_op_b = FF(mem_op_b), - .main_sel_mem_op_c = FF(mem_op_c), - .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_flag)), - .main_tag_err = FF(static_cast(!tag_match)), - .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), - }); + if (is_operand_indirect(indirect, 0)) { + indirect_flag = true; + auto ind_read = + mem_trace_builder.indirect_read_and_load_from_memory(call_ptr, clk, IndirectRegister::IND_C, dst_offset); + direct_dst_offset = uint32_t(ind_read.val); + tag_match = ind_read.tag_match; + } - if (copy_size - pos > 2) { // Guard to prevent overflow if copy_size is close to uint32_t maximum value. - pos += 3; - } else { - pos = copy_size; - } + if (tag_match) { + slice_trace_builder.create_calldata_copy_slice( + calldata, clk, call_ptr, cd_offset, copy_size, direct_dst_offset); + mem_trace_builder.write_calldata_copy(calldata, clk, call_ptr, cd_offset, copy_size, direct_dst_offset); } - pc++; + // Constrain gas cost + gas_trace_builder.constrain_gas_lookup(clk, OpCode::CALLDATACOPY); + + main_trace.push_back(Row{ + .main_clk = clk, + .main_call_ptr = call_ptr, + .main_ia = cd_offset, + .main_ib = copy_size, + .main_ind_addr_c = indirect_flag ? dst_offset : 0, + .main_internal_return_ptr = FF(internal_return_ptr), + .main_mem_addr_c = direct_dst_offset, + .main_pc = pc++, + .main_sel_cd_cpy_gadget = static_cast(tag_match), + .main_sel_op_calldata_copy = 1, + .main_sel_resolve_ind_addr_c = static_cast(indirect_flag), + .main_tag_err = static_cast(!tag_match), + .main_w_in_tag = static_cast(AvmMemoryTag::FF), + }); } /************************************************************************************************** @@ -2310,7 +2252,6 @@ Row AvmTraceBuilder::create_kernel_output_opcode_with_set_metadata_output_from_h uint32_t data_offset, uint32_t metadata_offset) { - FF exists = execution_hints.get_side_effect_hints().at(side_effect_counter); // TODO: throw error if incorrect @@ -3407,11 +3348,11 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, std::vector points_inf_vec; std::vector scalars_vec; AddressWithMode coords_offset = resolved_points_offset; - // Loading the points is a bit more complex since we need to read the coordinates and the infinity flags separately - // The current circuit constraints does not allow for multiple memory tags to be loaded from within the same row. - // If we could we would be able to replace the following loops with a single read_slice_to_memory call. - // For now we load the coordinates first and then the infinity flags, and finally splice them together when creating - // the points + // Loading the points is a bit more complex since we need to read the coordinates and the infinity flags + // separately The current circuit constraints does not allow for multiple memory tags to be loaded from within + // the same row. If we could we would be able to replace the following loops with a single read_slice_to_memory + // call. For now we load the coordinates first and then the infinity flags, and finally splice them together + // when creating the points // Read the coordinates first, +2 since we read 2 points per row, the first load could be indirect for (uint32_t i = 0; i < num_points; i++) { @@ -3465,7 +3406,8 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, } // Scalar read length is num_points* 2 since scalars are stored as lo and hi limbs uint32_t scalar_read_length = num_points * 2; - // Scalars are easy to read since they are stored as [lo1, hi1, lo2, hi2, ...] with the types [FF, FF, FF,FF, ...] + // Scalars are easy to read since they are stored as [lo1, hi1, lo2, hi2, ...] with the types [FF, FF, FF,FF, + // ...] auto num_scalar_rows = read_slice_to_memory(call_ptr, clk, resolved_scalars_offset, @@ -3857,6 +3799,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c auto pedersen_trace = pedersen_trace_builder.finalize(); auto bin_trace = bin_trace_builder.finalize(); auto gas_trace = gas_trace_builder.finalize(); + auto slice_trace = slice_trace_builder.finalize(); const auto& fixed_gas_table = FixedGasTable::get(); size_t mem_trace_size = mem_trace.size(); size_t main_trace_size = main_trace.size(); @@ -3868,6 +3811,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c size_t pedersen_trace_size = pedersen_trace.size(); size_t bin_trace_size = bin_trace.size(); size_t gas_trace_size = gas_trace.size(); + size_t slice_trace_size = slice_trace.size(); // Data structure to collect all lookup counts pertaining to 16-bit/32-bit range checks in memory trace std::unordered_map mem_rng_check_lo_counts; @@ -3879,11 +3823,12 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c // 2**16 long) size_t const lookup_table_size = (bin_trace_size > 0 && range_check_required) ? 3 * (1 << 16) : 0; size_t const range_check_size = range_check_required ? UINT16_MAX + 1 : 0; - std::vector trace_sizes = { mem_trace_size, main_trace_size, alu_trace_size, - range_check_size, conv_trace_size, lookup_table_size, - sha256_trace_size, poseidon2_trace_size, pedersen_trace_size, - gas_trace_size + 1, KERNEL_INPUTS_LENGTH, KERNEL_OUTPUTS_LENGTH, - min_trace_size, fixed_gas_table.size() }; + std::vector trace_sizes = { mem_trace_size, main_trace_size, alu_trace_size, + range_check_size, conv_trace_size, lookup_table_size, + sha256_trace_size, poseidon2_trace_size, pedersen_trace_size, + gas_trace_size + 1, KERNEL_INPUTS_LENGTH, KERNEL_OUTPUTS_LENGTH, + min_trace_size, fixed_gas_table.size(), slice_trace_size, + calldata.size() }; auto trace_size = std::max_element(trace_sizes.begin(), trace_sizes.end()); // We only need to pad with zeroes to the size to the largest trace here, pow_2 padding is handled in the @@ -3925,40 +3870,44 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.mem_sel_mov_ia_to_ic = FF(static_cast(src.m_sel_mov_ia_to_ic)); dest.mem_sel_mov_ib_to_ic = FF(static_cast(src.m_sel_mov_ib_to_ic)); dest.mem_sel_op_cmov = FF(static_cast(src.m_sel_cmov)); + dest.mem_sel_op_cd_cpy = FF(static_cast(src.m_sel_op_cd_cpy)); dest.incl_mem_tag_err_counts = FF(static_cast(src.m_tag_err_count_relevant)); - switch (src.m_sub_clk) { - case AvmMemTraceBuilder::SUB_CLK_LOAD_A: - case AvmMemTraceBuilder::SUB_CLK_STORE_A: - dest.mem_sel_op_a = 1; - break; - case AvmMemTraceBuilder::SUB_CLK_LOAD_B: - case AvmMemTraceBuilder::SUB_CLK_STORE_B: - dest.mem_sel_op_b = 1; - break; - case AvmMemTraceBuilder::SUB_CLK_LOAD_C: - case AvmMemTraceBuilder::SUB_CLK_STORE_C: - dest.mem_sel_op_c = 1; - break; - case AvmMemTraceBuilder::SUB_CLK_LOAD_D: - case AvmMemTraceBuilder::SUB_CLK_STORE_D: - dest.mem_sel_op_d = 1; - break; - case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_A: - dest.mem_sel_resolve_ind_addr_a = 1; - break; - case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_B: - dest.mem_sel_resolve_ind_addr_b = 1; - break; - case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_C: - dest.mem_sel_resolve_ind_addr_c = 1; - break; - case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_D: - dest.mem_sel_resolve_ind_addr_d = 1; - break; - default: - break; + // Calldatacopy memory operations are handled differently and are activated by m_sel_op_cd. + if (!src.m_sel_op_cd_cpy) { + switch (src.m_sub_clk) { + case AvmMemTraceBuilder::SUB_CLK_LOAD_A: + case AvmMemTraceBuilder::SUB_CLK_STORE_A: + dest.mem_sel_op_a = 1; + break; + case AvmMemTraceBuilder::SUB_CLK_LOAD_B: + case AvmMemTraceBuilder::SUB_CLK_STORE_B: + dest.mem_sel_op_b = 1; + break; + case AvmMemTraceBuilder::SUB_CLK_LOAD_C: + case AvmMemTraceBuilder::SUB_CLK_STORE_C: + dest.mem_sel_op_c = 1; + break; + case AvmMemTraceBuilder::SUB_CLK_LOAD_D: + case AvmMemTraceBuilder::SUB_CLK_STORE_D: + dest.mem_sel_op_d = 1; + break; + case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_A: + dest.mem_sel_resolve_ind_addr_a = 1; + break; + case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_B: + dest.mem_sel_resolve_ind_addr_b = 1; + break; + case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_C: + dest.mem_sel_resolve_ind_addr_c = 1; + break; + case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_D: + dest.mem_sel_resolve_ind_addr_d = 1; + break; + default: + break; + } } if (src.m_sel_cmov) { @@ -4208,6 +4157,13 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.pedersen_sel_pedersen = FF(1); } + /********************************************************************************************** + * SLICE TRACE INCLUSION + **********************************************************************************************/ + for (size_t i = 0; i < slice_trace_size; i++) { + merge_into(main_trace.at(i), slice_trace.at(i)); + } + /********************************************************************************************** * BINARY TRACE INCLUSION **********************************************************************************************/ @@ -4648,9 +4604,15 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c std::get(kernel_trace_builder.public_inputs).at(i); } - // calldata column inclusion + // calldata column inclusion and selector for (size_t i = 0; i < calldata.size(); i++) { main_trace.at(i).main_calldata = calldata.at(i); + main_trace.at(i).main_sel_calldata = 1; + } + + // calldata loookup counts for calldatacopy operations + for (auto const& [cd_offset, count] : slice_trace_builder.cd_lookup_counts) { + main_trace.at(cd_offset).lookup_cd_value_counts = count; } // Get tag_err counts from the mem_trace_builder @@ -4692,6 +4654,7 @@ void AvmTraceBuilder::reset() poseidon2_trace_builder.reset(); keccak_trace_builder.reset(); pedersen_trace_builder.reset(); + slice_trace_builder.reset(); external_call_counter = 0; } diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp index 01392ef683ca..376bc7071dcc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp @@ -16,6 +16,7 @@ #include "barretenberg/vm/avm_trace/gadgets/avm_pedersen.hpp" #include "barretenberg/vm/avm_trace/gadgets/avm_poseidon2.hpp" #include "barretenberg/vm/avm_trace/gadgets/avm_sha256.hpp" +#include "barretenberg/vm/avm_trace/gadgets/avm_slice_trace.hpp" namespace bb::avm_trace { @@ -185,6 +186,7 @@ class AvmTraceBuilder { AvmKeccakTraceBuilder keccak_trace_builder; AvmPedersenTraceBuilder pedersen_trace_builder; AvmEccTraceBuilder ecc_trace_builder; + AvmSliceTraceBuilder slice_trace_builder; std::vector calldata{}; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.cpp new file mode 100644 index 000000000000..ebbbb0b2446f --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.cpp @@ -0,0 +1,48 @@ +#include "barretenberg/vm/avm_trace/gadgets/avm_slice_trace.hpp" + +#include +#include + +namespace bb::avm_trace { + +void AvmSliceTraceBuilder::reset() +{ + slice_trace.clear(); + cd_lookup_counts.clear(); +} + +std::vector AvmSliceTraceBuilder::finalize() +{ + return std::move(slice_trace); +} + +void AvmSliceTraceBuilder::create_calldata_copy_slice(std::vector const& calldata, + uint32_t clk, + uint8_t space_id, + uint32_t cd_offset, + uint32_t copy_size, + uint32_t direct_dst_offset) +{ + for (uint32_t i = 0; i < copy_size; i++) { + slice_trace.push_back({ .clk = clk, + .space_id = space_id, + .addr_ff = FF(direct_dst_offset + i), + .val = calldata.at(cd_offset + i), + .cd_offset = cd_offset + i, + .cnt = copy_size - i, + .one_min_inv = FF(1) - FF(copy_size - i).invert(), + .sel_start_cd_cpy = i == 0, + .sel_cd_cpy = true }); + cd_lookup_counts[cd_offset + i]++; + } + + // Last extra row for a calldatacopy operation. cnt is zero and we have to add extra dummy + // values for addr and cd_offset to satisfy the constraints: #[ADDR_CNT_INCREMENT] and #[CD_OFFSET_INCREMENT] + // Alternatively, we would have to increase the degree of these two relations. + // Note that addr = 2^32 would be a valid value here, therefore we do not wrap modulo 2^32. + // cd_offset is fine as the circuit trace cannot reach a size of 2^32. + slice_trace.emplace_back( + SliceTraceEntry{ .addr_ff = FF(direct_dst_offset + copy_size - 1) + 1, .cd_offset = cd_offset + copy_size }); +} + +} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.hpp new file mode 100644 index 000000000000..ddc7809fb574 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.hpp @@ -0,0 +1,59 @@ +#pragma once + +#include "barretenberg/vm/avm_trace/avm_common.hpp" + +#include + +namespace bb::avm_trace { + +class AvmSliceTraceBuilder { + + public: + // Keeps track of the number of times a calldata value is copied. + // cd_offset -> count + std::unordered_map cd_lookup_counts; + + struct SliceTraceEntry { + uint32_t clk = 0; + uint8_t space_id = 0; + FF addr_ff = 0; // Should normally be uint32_t but the last witness addr of a calldatacopy operation row might + // be FF(2^32). + FF val{}; + uint32_t cd_offset = 0; + uint32_t cnt = 0; + FF one_min_inv{}; + + bool sel_start_cd_cpy = false; + bool sel_cd_cpy = false; + }; + + AvmSliceTraceBuilder() = default; + + void reset(); + std::vector finalize(); + + void create_calldata_copy_slice(std::vector const& calldata, + uint32_t clk, + uint8_t space_id, + uint32_t cd_offset, + uint32_t copy_size, + uint32_t direct_dst_offset); + + private: + std::vector slice_trace; +}; + +template void merge_into(DestRow& dest, AvmSliceTraceBuilder::SliceTraceEntry const& src) +{ + dest.slice_clk = src.clk; + dest.slice_space_id = src.space_id; + dest.slice_addr = src.addr_ff; + dest.slice_val = src.val; + dest.slice_cd_offset = src.cd_offset; + dest.slice_cnt = src.cnt; + dest.slice_one_min_inv = src.one_min_inv; + dest.slice_sel_start_cd_cpy = src.sel_start_cd_cpy; + dest.slice_sel_cd_cpy = src.sel_cd_cpy; +} + +} // namespace bb::avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp new file mode 100644 index 000000000000..edc9470914ed --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp @@ -0,0 +1,839 @@ +#include "barretenberg/vm/generated/avm_circuit_builder.hpp" + +namespace bb { +namespace { + +template std::string field_to_string(const FF& ff) +{ + std::ostringstream os; + os << ff; + std::string raw = os.str(); + auto first_not_zero = raw.find_first_not_of('0', 2); + std::string result = "0x" + (first_not_zero != std::string::npos ? raw.substr(first_not_zero) : "0"); + return result; +} + +} // namespace + +template std::vector AvmFullRow::names() +{ + return { "main_clk", + "main_sel_first", + "kernel_kernel_inputs", + "kernel_kernel_value_out", + "kernel_kernel_side_effect_out", + "kernel_kernel_metadata_out", + "main_calldata", + "alu_a_hi", + "alu_a_lo", + "alu_b_hi", + "alu_b_lo", + "alu_borrow", + "alu_cf", + "alu_clk", + "alu_cmp_rng_ctr", + "alu_div_u16_r0", + "alu_div_u16_r1", + "alu_div_u16_r2", + "alu_div_u16_r3", + "alu_div_u16_r4", + "alu_div_u16_r5", + "alu_div_u16_r6", + "alu_div_u16_r7", + "alu_divisor_hi", + "alu_divisor_lo", + "alu_ff_tag", + "alu_ia", + "alu_ib", + "alu_ic", + "alu_in_tag", + "alu_op_add", + "alu_op_cast", + "alu_op_cast_prev", + "alu_op_div", + "alu_op_div_a_lt_b", + "alu_op_div_std", + "alu_op_eq", + "alu_op_eq_diff_inv", + "alu_op_lt", + "alu_op_lte", + "alu_op_mul", + "alu_op_not", + "alu_op_shl", + "alu_op_shr", + "alu_op_sub", + "alu_p_a_borrow", + "alu_p_b_borrow", + "alu_p_sub_a_hi", + "alu_p_sub_a_lo", + "alu_p_sub_b_hi", + "alu_p_sub_b_lo", + "alu_partial_prod_hi", + "alu_partial_prod_lo", + "alu_quotient_hi", + "alu_quotient_lo", + "alu_remainder", + "alu_res_hi", + "alu_res_lo", + "alu_sel_alu", + "alu_sel_cmp", + "alu_sel_div_rng_chk", + "alu_sel_rng_chk", + "alu_sel_rng_chk_lookup", + "alu_sel_shift_which", + "alu_shift_lt_bit_len", + "alu_t_sub_s_bits", + "alu_two_pow_s", + "alu_two_pow_t_sub_s", + "alu_u128_tag", + "alu_u16_r0", + "alu_u16_r1", + "alu_u16_r10", + "alu_u16_r11", + "alu_u16_r12", + "alu_u16_r13", + "alu_u16_r14", + "alu_u16_r2", + "alu_u16_r3", + "alu_u16_r4", + "alu_u16_r5", + "alu_u16_r6", + "alu_u16_r7", + "alu_u16_r8", + "alu_u16_r9", + "alu_u16_tag", + "alu_u32_tag", + "alu_u64_tag", + "alu_u8_r0", + "alu_u8_r1", + "alu_u8_tag", + "binary_acc_ia", + "binary_acc_ib", + "binary_acc_ic", + "binary_clk", + "binary_ia_bytes", + "binary_ib_bytes", + "binary_ic_bytes", + "binary_in_tag", + "binary_mem_tag_ctr", + "binary_mem_tag_ctr_inv", + "binary_op_id", + "binary_sel_bin", + "binary_start", + "byte_lookup_sel_bin", + "byte_lookup_table_byte_lengths", + "byte_lookup_table_in_tags", + "byte_lookup_table_input_a", + "byte_lookup_table_input_b", + "byte_lookup_table_op_id", + "byte_lookup_table_output", + "conversion_clk", + "conversion_input", + "conversion_num_limbs", + "conversion_radix", + "conversion_sel_to_radix_le", + "gas_da_gas_fixed_table", + "gas_l2_gas_fixed_table", + "gas_sel_gas_cost", + "keccakf1600_clk", + "keccakf1600_input", + "keccakf1600_output", + "keccakf1600_sel_keccakf1600", + "kernel_emit_l2_to_l1_msg_write_offset", + "kernel_emit_note_hash_write_offset", + "kernel_emit_nullifier_write_offset", + "kernel_emit_unencrypted_log_write_offset", + "kernel_kernel_in_offset", + "kernel_kernel_out_offset", + "kernel_l1_to_l2_msg_exists_write_offset", + "kernel_note_hash_exist_write_offset", + "kernel_nullifier_exists_write_offset", + "kernel_nullifier_non_exists_write_offset", + "kernel_q_public_input_kernel_add_to_table", + "kernel_q_public_input_kernel_out_add_to_table", + "kernel_side_effect_counter", + "kernel_sload_write_offset", + "kernel_sstore_write_offset", + "main_abs_da_rem_gas_hi", + "main_abs_da_rem_gas_lo", + "main_abs_l2_rem_gas_hi", + "main_abs_l2_rem_gas_lo", + "main_alu_in_tag", + "main_bin_op_id", + "main_call_ptr", + "main_da_gas_op_cost", + "main_da_gas_remaining", + "main_da_out_of_gas", + "main_ia", + "main_ib", + "main_ic", + "main_id", + "main_id_zero", + "main_ind_addr_a", + "main_ind_addr_b", + "main_ind_addr_c", + "main_ind_addr_d", + "main_internal_return_ptr", + "main_inv", + "main_l2_gas_op_cost", + "main_l2_gas_remaining", + "main_l2_out_of_gas", + "main_mem_addr_a", + "main_mem_addr_b", + "main_mem_addr_c", + "main_mem_addr_d", + "main_op_err", + "main_opcode_val", + "main_pc", + "main_r_in_tag", + "main_rwa", + "main_rwb", + "main_rwc", + "main_rwd", + "main_sel_alu", + "main_sel_bin", + "main_sel_calldata", + "main_sel_cd_cpy_gadget", + "main_sel_gas_accounting_active", + "main_sel_last", + "main_sel_mem_op_a", + "main_sel_mem_op_activate_gas", + "main_sel_mem_op_b", + "main_sel_mem_op_c", + "main_sel_mem_op_d", + "main_sel_mov_ia_to_ic", + "main_sel_mov_ib_to_ic", + "main_sel_op_add", + "main_sel_op_address", + "main_sel_op_and", + "main_sel_op_block_number", + "main_sel_op_calldata_copy", + "main_sel_op_cast", + "main_sel_op_chain_id", + "main_sel_op_cmov", + "main_sel_op_coinbase", + "main_sel_op_dagasleft", + "main_sel_op_div", + "main_sel_op_emit_l2_to_l1_msg", + "main_sel_op_emit_note_hash", + "main_sel_op_emit_nullifier", + "main_sel_op_emit_unencrypted_log", + "main_sel_op_eq", + "main_sel_op_external_call", + "main_sel_op_fdiv", + "main_sel_op_fee_per_da_gas", + "main_sel_op_fee_per_l2_gas", + "main_sel_op_function_selector", + "main_sel_op_get_contract_instance", + "main_sel_op_halt", + "main_sel_op_internal_call", + "main_sel_op_internal_return", + "main_sel_op_jump", + "main_sel_op_jumpi", + "main_sel_op_keccak", + "main_sel_op_l1_to_l2_msg_exists", + "main_sel_op_l2gasleft", + "main_sel_op_lt", + "main_sel_op_lte", + "main_sel_op_mov", + "main_sel_op_mul", + "main_sel_op_not", + "main_sel_op_note_hash_exists", + "main_sel_op_nullifier_exists", + "main_sel_op_or", + "main_sel_op_pedersen", + "main_sel_op_poseidon2", + "main_sel_op_radix_le", + "main_sel_op_sender", + "main_sel_op_sha256", + "main_sel_op_shl", + "main_sel_op_shr", + "main_sel_op_sload", + "main_sel_op_sstore", + "main_sel_op_storage_address", + "main_sel_op_sub", + "main_sel_op_timestamp", + "main_sel_op_transaction_fee", + "main_sel_op_version", + "main_sel_op_xor", + "main_sel_q_kernel_lookup", + "main_sel_q_kernel_output_lookup", + "main_sel_resolve_ind_addr_a", + "main_sel_resolve_ind_addr_b", + "main_sel_resolve_ind_addr_c", + "main_sel_resolve_ind_addr_d", + "main_sel_rng_16", + "main_sel_rng_8", + "main_space_id", + "main_tag_err", + "main_w_in_tag", + "mem_addr", + "mem_clk", + "mem_diff_hi", + "mem_diff_lo", + "mem_diff_mid", + "mem_glob_addr", + "mem_last", + "mem_lastAccess", + "mem_one_min_inv", + "mem_r_in_tag", + "mem_rw", + "mem_sel_mem", + "mem_sel_mov_ia_to_ic", + "mem_sel_mov_ib_to_ic", + "mem_sel_op_a", + "mem_sel_op_b", + "mem_sel_op_c", + "mem_sel_op_cd_cpy", + "mem_sel_op_cmov", + "mem_sel_op_d", + "mem_sel_resolve_ind_addr_a", + "mem_sel_resolve_ind_addr_b", + "mem_sel_resolve_ind_addr_c", + "mem_sel_resolve_ind_addr_d", + "mem_sel_rng_chk", + "mem_skip_check_tag", + "mem_space_id", + "mem_tag", + "mem_tag_err", + "mem_tsp", + "mem_val", + "mem_w_in_tag", + "pedersen_clk", + "pedersen_input", + "pedersen_output", + "pedersen_sel_pedersen", + "poseidon2_clk", + "poseidon2_input", + "poseidon2_output", + "poseidon2_sel_poseidon_perm", + "powers_power_of_2", + "sha256_clk", + "sha256_input", + "sha256_output", + "sha256_sel_sha256_compression", + "sha256_state", + "slice_addr", + "slice_cd_offset", + "slice_clk", + "slice_cnt", + "slice_one_min_inv", + "slice_sel_cd_cpy", + "slice_sel_start_cd_cpy", + "slice_space_id", + "slice_val", + "perm_cd_mem", + "perm_main_alu", + "perm_main_bin", + "perm_main_conv", + "perm_main_pos2_perm", + "perm_main_pedersen", + "perm_main_cd_copy", + "perm_main_mem_a", + "perm_main_mem_b", + "perm_main_mem_c", + "perm_main_mem_d", + "perm_main_mem_ind_addr_a", + "perm_main_mem_ind_addr_b", + "perm_main_mem_ind_addr_c", + "perm_main_mem_ind_addr_d", + "lookup_byte_lengths", + "lookup_byte_operations", + "lookup_cd_value", + "lookup_opcode_gas", + "range_check_l2_gas_hi", + "range_check_l2_gas_lo", + "range_check_da_gas_hi", + "range_check_da_gas_lo", + "kernel_output_lookup", + "lookup_into_kernel", + "incl_main_tag_err", + "incl_mem_tag_err", + "lookup_mem_rng_chk_lo", + "lookup_mem_rng_chk_mid", + "lookup_mem_rng_chk_hi", + "lookup_pow_2_0", + "lookup_pow_2_1", + "lookup_u8_0", + "lookup_u8_1", + "lookup_u16_0", + "lookup_u16_1", + "lookup_u16_2", + "lookup_u16_3", + "lookup_u16_4", + "lookup_u16_5", + "lookup_u16_6", + "lookup_u16_7", + "lookup_u16_8", + "lookup_u16_9", + "lookup_u16_10", + "lookup_u16_11", + "lookup_u16_12", + "lookup_u16_13", + "lookup_u16_14", + "lookup_div_u16_0", + "lookup_div_u16_1", + "lookup_div_u16_2", + "lookup_div_u16_3", + "lookup_div_u16_4", + "lookup_div_u16_5", + "lookup_div_u16_6", + "lookup_div_u16_7", + "lookup_byte_lengths_counts", + "lookup_byte_operations_counts", + "lookup_cd_value_counts", + "lookup_opcode_gas_counts", + "range_check_l2_gas_hi_counts", + "range_check_l2_gas_lo_counts", + "range_check_da_gas_hi_counts", + "range_check_da_gas_lo_counts", + "kernel_output_lookup_counts", + "lookup_into_kernel_counts", + "incl_main_tag_err_counts", + "incl_mem_tag_err_counts", + "lookup_mem_rng_chk_lo_counts", + "lookup_mem_rng_chk_mid_counts", + "lookup_mem_rng_chk_hi_counts", + "lookup_pow_2_0_counts", + "lookup_pow_2_1_counts", + "lookup_u8_0_counts", + "lookup_u8_1_counts", + "lookup_u16_0_counts", + "lookup_u16_1_counts", + "lookup_u16_2_counts", + "lookup_u16_3_counts", + "lookup_u16_4_counts", + "lookup_u16_5_counts", + "lookup_u16_6_counts", + "lookup_u16_7_counts", + "lookup_u16_8_counts", + "lookup_u16_9_counts", + "lookup_u16_10_counts", + "lookup_u16_11_counts", + "lookup_u16_12_counts", + "lookup_u16_13_counts", + "lookup_u16_14_counts", + "lookup_div_u16_0_counts", + "lookup_div_u16_1_counts", + "lookup_div_u16_2_counts", + "lookup_div_u16_3_counts", + "lookup_div_u16_4_counts", + "lookup_div_u16_5_counts", + "lookup_div_u16_6_counts", + "lookup_div_u16_7_counts" }; +} + +template std::ostream& operator<<(std::ostream& os, AvmFullRow const& row) +{ + return os << field_to_string(row.main_clk) // + << "," << field_to_string(row.main_sel_first) // + << "," << field_to_string(row.kernel_kernel_inputs) // + << "," << field_to_string(row.kernel_kernel_value_out) // + << "," << field_to_string(row.kernel_kernel_side_effect_out) // + << "," << field_to_string(row.kernel_kernel_metadata_out) // + << "," << field_to_string(row.main_calldata) // + << "," << field_to_string(row.alu_a_hi) // + << "," << field_to_string(row.alu_a_lo) // + << "," << field_to_string(row.alu_b_hi) // + << "," << field_to_string(row.alu_b_lo) // + << "," << field_to_string(row.alu_borrow) // + << "," << field_to_string(row.alu_cf) // + << "," << field_to_string(row.alu_clk) // + << "," << field_to_string(row.alu_cmp_rng_ctr) // + << "," << field_to_string(row.alu_div_u16_r0) // + << "," << field_to_string(row.alu_div_u16_r1) // + << "," << field_to_string(row.alu_div_u16_r2) // + << "," << field_to_string(row.alu_div_u16_r3) // + << "," << field_to_string(row.alu_div_u16_r4) // + << "," << field_to_string(row.alu_div_u16_r5) // + << "," << field_to_string(row.alu_div_u16_r6) // + << "," << field_to_string(row.alu_div_u16_r7) // + << "," << field_to_string(row.alu_divisor_hi) // + << "," << field_to_string(row.alu_divisor_lo) // + << "," << field_to_string(row.alu_ff_tag) // + << "," << field_to_string(row.alu_ia) // + << "," << field_to_string(row.alu_ib) // + << "," << field_to_string(row.alu_ic) // + << "," << field_to_string(row.alu_in_tag) // + << "," << field_to_string(row.alu_op_add) // + << "," << field_to_string(row.alu_op_cast) // + << "," << field_to_string(row.alu_op_cast_prev) // + << "," << field_to_string(row.alu_op_div) // + << "," << field_to_string(row.alu_op_div_a_lt_b) // + << "," << field_to_string(row.alu_op_div_std) // + << "," << field_to_string(row.alu_op_eq) // + << "," << field_to_string(row.alu_op_eq_diff_inv) // + << "," << field_to_string(row.alu_op_lt) // + << "," << field_to_string(row.alu_op_lte) // + << "," << field_to_string(row.alu_op_mul) // + << "," << field_to_string(row.alu_op_not) // + << "," << field_to_string(row.alu_op_shl) // + << "," << field_to_string(row.alu_op_shr) // + << "," << field_to_string(row.alu_op_sub) // + << "," << field_to_string(row.alu_p_a_borrow) // + << "," << field_to_string(row.alu_p_b_borrow) // + << "," << field_to_string(row.alu_p_sub_a_hi) // + << "," << field_to_string(row.alu_p_sub_a_lo) // + << "," << field_to_string(row.alu_p_sub_b_hi) // + << "," << field_to_string(row.alu_p_sub_b_lo) // + << "," << field_to_string(row.alu_partial_prod_hi) // + << "," << field_to_string(row.alu_partial_prod_lo) // + << "," << field_to_string(row.alu_quotient_hi) // + << "," << field_to_string(row.alu_quotient_lo) // + << "," << field_to_string(row.alu_remainder) // + << "," << field_to_string(row.alu_res_hi) // + << "," << field_to_string(row.alu_res_lo) // + << "," << field_to_string(row.alu_sel_alu) // + << "," << field_to_string(row.alu_sel_cmp) // + << "," << field_to_string(row.alu_sel_div_rng_chk) // + << "," << field_to_string(row.alu_sel_rng_chk) // + << "," << field_to_string(row.alu_sel_rng_chk_lookup) // + << "," << field_to_string(row.alu_sel_shift_which) // + << "," << field_to_string(row.alu_shift_lt_bit_len) // + << "," << field_to_string(row.alu_t_sub_s_bits) // + << "," << field_to_string(row.alu_two_pow_s) // + << "," << field_to_string(row.alu_two_pow_t_sub_s) // + << "," << field_to_string(row.alu_u128_tag) // + << "," << field_to_string(row.alu_u16_r0) // + << "," << field_to_string(row.alu_u16_r1) // + << "," << field_to_string(row.alu_u16_r10) // + << "," << field_to_string(row.alu_u16_r11) // + << "," << field_to_string(row.alu_u16_r12) // + << "," << field_to_string(row.alu_u16_r13) // + << "," << field_to_string(row.alu_u16_r14) // + << "," << field_to_string(row.alu_u16_r2) // + << "," << field_to_string(row.alu_u16_r3) // + << "," << field_to_string(row.alu_u16_r4) // + << "," << field_to_string(row.alu_u16_r5) // + << "," << field_to_string(row.alu_u16_r6) // + << "," << field_to_string(row.alu_u16_r7) // + << "," << field_to_string(row.alu_u16_r8) // + << "," << field_to_string(row.alu_u16_r9) // + << "," << field_to_string(row.alu_u16_tag) // + << "," << field_to_string(row.alu_u32_tag) // + << "," << field_to_string(row.alu_u64_tag) // + << "," << field_to_string(row.alu_u8_r0) // + << "," << field_to_string(row.alu_u8_r1) // + << "," << field_to_string(row.alu_u8_tag) // + << "," << field_to_string(row.binary_acc_ia) // + << "," << field_to_string(row.binary_acc_ib) // + << "," << field_to_string(row.binary_acc_ic) // + << "," << field_to_string(row.binary_clk) // + << "," << field_to_string(row.binary_ia_bytes) // + << "," << field_to_string(row.binary_ib_bytes) // + << "," << field_to_string(row.binary_ic_bytes) // + << "," << field_to_string(row.binary_in_tag) // + << "," << field_to_string(row.binary_mem_tag_ctr) // + << "," << field_to_string(row.binary_mem_tag_ctr_inv) // + << "," << field_to_string(row.binary_op_id) // + << "," << field_to_string(row.binary_sel_bin) // + << "," << field_to_string(row.binary_start) // + << "," << field_to_string(row.byte_lookup_sel_bin) // + << "," << field_to_string(row.byte_lookup_table_byte_lengths) // + << "," << field_to_string(row.byte_lookup_table_in_tags) // + << "," << field_to_string(row.byte_lookup_table_input_a) // + << "," << field_to_string(row.byte_lookup_table_input_b) // + << "," << field_to_string(row.byte_lookup_table_op_id) // + << "," << field_to_string(row.byte_lookup_table_output) // + << "," << field_to_string(row.conversion_clk) // + << "," << field_to_string(row.conversion_input) // + << "," << field_to_string(row.conversion_num_limbs) // + << "," << field_to_string(row.conversion_radix) // + << "," << field_to_string(row.conversion_sel_to_radix_le) // + << "," << field_to_string(row.gas_da_gas_fixed_table) // + << "," << field_to_string(row.gas_l2_gas_fixed_table) // + << "," << field_to_string(row.gas_sel_gas_cost) // + << "," << field_to_string(row.keccakf1600_clk) // + << "," << field_to_string(row.keccakf1600_input) // + << "," << field_to_string(row.keccakf1600_output) // + << "," << field_to_string(row.keccakf1600_sel_keccakf1600) // + << "," << field_to_string(row.kernel_emit_l2_to_l1_msg_write_offset) // + << "," << field_to_string(row.kernel_emit_note_hash_write_offset) // + << "," << field_to_string(row.kernel_emit_nullifier_write_offset) // + << "," << field_to_string(row.kernel_emit_unencrypted_log_write_offset) // + << "," << field_to_string(row.kernel_kernel_in_offset) // + << "," << field_to_string(row.kernel_kernel_out_offset) // + << "," << field_to_string(row.kernel_l1_to_l2_msg_exists_write_offset) // + << "," << field_to_string(row.kernel_note_hash_exist_write_offset) // + << "," << field_to_string(row.kernel_nullifier_exists_write_offset) // + << "," << field_to_string(row.kernel_nullifier_non_exists_write_offset) // + << "," << field_to_string(row.kernel_q_public_input_kernel_add_to_table) // + << "," << field_to_string(row.kernel_q_public_input_kernel_out_add_to_table) // + << "," << field_to_string(row.kernel_side_effect_counter) // + << "," << field_to_string(row.kernel_sload_write_offset) // + << "," << field_to_string(row.kernel_sstore_write_offset) // + << "," << field_to_string(row.main_abs_da_rem_gas_hi) // + << "," << field_to_string(row.main_abs_da_rem_gas_lo) // + << "," << field_to_string(row.main_abs_l2_rem_gas_hi) // + << "," << field_to_string(row.main_abs_l2_rem_gas_lo) // + << "," << field_to_string(row.main_alu_in_tag) // + << "," << field_to_string(row.main_bin_op_id) // + << "," << field_to_string(row.main_call_ptr) // + << "," << field_to_string(row.main_da_gas_op_cost) // + << "," << field_to_string(row.main_da_gas_remaining) // + << "," << field_to_string(row.main_da_out_of_gas) // + << "," << field_to_string(row.main_ia) // + << "," << field_to_string(row.main_ib) // + << "," << field_to_string(row.main_ic) // + << "," << field_to_string(row.main_id) // + << "," << field_to_string(row.main_id_zero) // + << "," << field_to_string(row.main_ind_addr_a) // + << "," << field_to_string(row.main_ind_addr_b) // + << "," << field_to_string(row.main_ind_addr_c) // + << "," << field_to_string(row.main_ind_addr_d) // + << "," << field_to_string(row.main_internal_return_ptr) // + << "," << field_to_string(row.main_inv) // + << "," << field_to_string(row.main_l2_gas_op_cost) // + << "," << field_to_string(row.main_l2_gas_remaining) // + << "," << field_to_string(row.main_l2_out_of_gas) // + << "," << field_to_string(row.main_mem_addr_a) // + << "," << field_to_string(row.main_mem_addr_b) // + << "," << field_to_string(row.main_mem_addr_c) // + << "," << field_to_string(row.main_mem_addr_d) // + << "," << field_to_string(row.main_op_err) // + << "," << field_to_string(row.main_opcode_val) // + << "," << field_to_string(row.main_pc) // + << "," << field_to_string(row.main_r_in_tag) // + << "," << field_to_string(row.main_rwa) // + << "," << field_to_string(row.main_rwb) // + << "," << field_to_string(row.main_rwc) // + << "," << field_to_string(row.main_rwd) // + << "," << field_to_string(row.main_sel_alu) // + << "," << field_to_string(row.main_sel_bin) // + << "," << field_to_string(row.main_sel_calldata) // + << "," << field_to_string(row.main_sel_cd_cpy_gadget) // + << "," << field_to_string(row.main_sel_gas_accounting_active) // + << "," << field_to_string(row.main_sel_last) // + << "," << field_to_string(row.main_sel_mem_op_a) // + << "," << field_to_string(row.main_sel_mem_op_activate_gas) // + << "," << field_to_string(row.main_sel_mem_op_b) // + << "," << field_to_string(row.main_sel_mem_op_c) // + << "," << field_to_string(row.main_sel_mem_op_d) // + << "," << field_to_string(row.main_sel_mov_ia_to_ic) // + << "," << field_to_string(row.main_sel_mov_ib_to_ic) // + << "," << field_to_string(row.main_sel_op_add) // + << "," << field_to_string(row.main_sel_op_address) // + << "," << field_to_string(row.main_sel_op_and) // + << "," << field_to_string(row.main_sel_op_block_number) // + << "," << field_to_string(row.main_sel_op_calldata_copy) // + << "," << field_to_string(row.main_sel_op_cast) // + << "," << field_to_string(row.main_sel_op_chain_id) // + << "," << field_to_string(row.main_sel_op_cmov) // + << "," << field_to_string(row.main_sel_op_coinbase) // + << "," << field_to_string(row.main_sel_op_dagasleft) // + << "," << field_to_string(row.main_sel_op_div) // + << "," << field_to_string(row.main_sel_op_emit_l2_to_l1_msg) // + << "," << field_to_string(row.main_sel_op_emit_note_hash) // + << "," << field_to_string(row.main_sel_op_emit_nullifier) // + << "," << field_to_string(row.main_sel_op_emit_unencrypted_log) // + << "," << field_to_string(row.main_sel_op_eq) // + << "," << field_to_string(row.main_sel_op_external_call) // + << "," << field_to_string(row.main_sel_op_fdiv) // + << "," << field_to_string(row.main_sel_op_fee_per_da_gas) // + << "," << field_to_string(row.main_sel_op_fee_per_l2_gas) // + << "," << field_to_string(row.main_sel_op_function_selector) // + << "," << field_to_string(row.main_sel_op_get_contract_instance) // + << "," << field_to_string(row.main_sel_op_halt) // + << "," << field_to_string(row.main_sel_op_internal_call) // + << "," << field_to_string(row.main_sel_op_internal_return) // + << "," << field_to_string(row.main_sel_op_jump) // + << "," << field_to_string(row.main_sel_op_jumpi) // + << "," << field_to_string(row.main_sel_op_keccak) // + << "," << field_to_string(row.main_sel_op_l1_to_l2_msg_exists) // + << "," << field_to_string(row.main_sel_op_l2gasleft) // + << "," << field_to_string(row.main_sel_op_lt) // + << "," << field_to_string(row.main_sel_op_lte) // + << "," << field_to_string(row.main_sel_op_mov) // + << "," << field_to_string(row.main_sel_op_mul) // + << "," << field_to_string(row.main_sel_op_not) // + << "," << field_to_string(row.main_sel_op_note_hash_exists) // + << "," << field_to_string(row.main_sel_op_nullifier_exists) // + << "," << field_to_string(row.main_sel_op_or) // + << "," << field_to_string(row.main_sel_op_pedersen) // + << "," << field_to_string(row.main_sel_op_poseidon2) // + << "," << field_to_string(row.main_sel_op_radix_le) // + << "," << field_to_string(row.main_sel_op_sender) // + << "," << field_to_string(row.main_sel_op_sha256) // + << "," << field_to_string(row.main_sel_op_shl) // + << "," << field_to_string(row.main_sel_op_shr) // + << "," << field_to_string(row.main_sel_op_sload) // + << "," << field_to_string(row.main_sel_op_sstore) // + << "," << field_to_string(row.main_sel_op_storage_address) // + << "," << field_to_string(row.main_sel_op_sub) // + << "," << field_to_string(row.main_sel_op_timestamp) // + << "," << field_to_string(row.main_sel_op_transaction_fee) // + << "," << field_to_string(row.main_sel_op_version) // + << "," << field_to_string(row.main_sel_op_xor) // + << "," << field_to_string(row.main_sel_q_kernel_lookup) // + << "," << field_to_string(row.main_sel_q_kernel_output_lookup) // + << "," << field_to_string(row.main_sel_resolve_ind_addr_a) // + << "," << field_to_string(row.main_sel_resolve_ind_addr_b) // + << "," << field_to_string(row.main_sel_resolve_ind_addr_c) // + << "," << field_to_string(row.main_sel_resolve_ind_addr_d) // + << "," << field_to_string(row.main_sel_rng_16) // + << "," << field_to_string(row.main_sel_rng_8) // + << "," << field_to_string(row.main_space_id) // + << "," << field_to_string(row.main_tag_err) // + << "," << field_to_string(row.main_w_in_tag) // + << "," << field_to_string(row.mem_addr) // + << "," << field_to_string(row.mem_clk) // + << "," << field_to_string(row.mem_diff_hi) // + << "," << field_to_string(row.mem_diff_lo) // + << "," << field_to_string(row.mem_diff_mid) // + << "," << field_to_string(row.mem_glob_addr) // + << "," << field_to_string(row.mem_last) // + << "," << field_to_string(row.mem_lastAccess) // + << "," << field_to_string(row.mem_one_min_inv) // + << "," << field_to_string(row.mem_r_in_tag) // + << "," << field_to_string(row.mem_rw) // + << "," << field_to_string(row.mem_sel_mem) // + << "," << field_to_string(row.mem_sel_mov_ia_to_ic) // + << "," << field_to_string(row.mem_sel_mov_ib_to_ic) // + << "," << field_to_string(row.mem_sel_op_a) // + << "," << field_to_string(row.mem_sel_op_b) // + << "," << field_to_string(row.mem_sel_op_c) // + << "," << field_to_string(row.mem_sel_op_cd_cpy) // + << "," << field_to_string(row.mem_sel_op_cmov) // + << "," << field_to_string(row.mem_sel_op_d) // + << "," << field_to_string(row.mem_sel_resolve_ind_addr_a) // + << "," << field_to_string(row.mem_sel_resolve_ind_addr_b) // + << "," << field_to_string(row.mem_sel_resolve_ind_addr_c) // + << "," << field_to_string(row.mem_sel_resolve_ind_addr_d) // + << "," << field_to_string(row.mem_sel_rng_chk) // + << "," << field_to_string(row.mem_skip_check_tag) // + << "," << field_to_string(row.mem_space_id) // + << "," << field_to_string(row.mem_tag) // + << "," << field_to_string(row.mem_tag_err) // + << "," << field_to_string(row.mem_tsp) // + << "," << field_to_string(row.mem_val) // + << "," << field_to_string(row.mem_w_in_tag) // + << "," << field_to_string(row.pedersen_clk) // + << "," << field_to_string(row.pedersen_input) // + << "," << field_to_string(row.pedersen_output) // + << "," << field_to_string(row.pedersen_sel_pedersen) // + << "," << field_to_string(row.poseidon2_clk) // + << "," << field_to_string(row.poseidon2_input) // + << "," << field_to_string(row.poseidon2_output) // + << "," << field_to_string(row.poseidon2_sel_poseidon_perm) // + << "," << field_to_string(row.powers_power_of_2) // + << "," << field_to_string(row.sha256_clk) // + << "," << field_to_string(row.sha256_input) // + << "," << field_to_string(row.sha256_output) // + << "," << field_to_string(row.sha256_sel_sha256_compression) // + << "," << field_to_string(row.sha256_state) // + << "," << field_to_string(row.slice_addr) // + << "," << field_to_string(row.slice_cd_offset) // + << "," << field_to_string(row.slice_clk) // + << "," << field_to_string(row.slice_cnt) // + << "," << field_to_string(row.slice_one_min_inv) // + << "," << field_to_string(row.slice_sel_cd_cpy) // + << "," << field_to_string(row.slice_sel_start_cd_cpy) // + << "," << field_to_string(row.slice_space_id) // + << "," << field_to_string(row.slice_val) // + << "," << field_to_string(row.perm_cd_mem) // + << "," << field_to_string(row.perm_main_alu) // + << "," << field_to_string(row.perm_main_bin) // + << "," << field_to_string(row.perm_main_conv) // + << "," << field_to_string(row.perm_main_pos2_perm) // + << "," << field_to_string(row.perm_main_pedersen) // + << "," << field_to_string(row.perm_main_cd_copy) // + << "," << field_to_string(row.perm_main_mem_a) // + << "," << field_to_string(row.perm_main_mem_b) // + << "," << field_to_string(row.perm_main_mem_c) // + << "," << field_to_string(row.perm_main_mem_d) // + << "," << field_to_string(row.perm_main_mem_ind_addr_a) // + << "," << field_to_string(row.perm_main_mem_ind_addr_b) // + << "," << field_to_string(row.perm_main_mem_ind_addr_c) // + << "," << field_to_string(row.perm_main_mem_ind_addr_d) // + << "," << field_to_string(row.lookup_byte_lengths) // + << "," << field_to_string(row.lookup_byte_operations) // + << "," << field_to_string(row.lookup_cd_value) // + << "," << field_to_string(row.lookup_opcode_gas) // + << "," << field_to_string(row.range_check_l2_gas_hi) // + << "," << field_to_string(row.range_check_l2_gas_lo) // + << "," << field_to_string(row.range_check_da_gas_hi) // + << "," << field_to_string(row.range_check_da_gas_lo) // + << "," << field_to_string(row.kernel_output_lookup) // + << "," << field_to_string(row.lookup_into_kernel) // + << "," << field_to_string(row.incl_main_tag_err) // + << "," << field_to_string(row.incl_mem_tag_err) // + << "," << field_to_string(row.lookup_mem_rng_chk_lo) // + << "," << field_to_string(row.lookup_mem_rng_chk_mid) // + << "," << field_to_string(row.lookup_mem_rng_chk_hi) // + << "," << field_to_string(row.lookup_pow_2_0) // + << "," << field_to_string(row.lookup_pow_2_1) // + << "," << field_to_string(row.lookup_u8_0) // + << "," << field_to_string(row.lookup_u8_1) // + << "," << field_to_string(row.lookup_u16_0) // + << "," << field_to_string(row.lookup_u16_1) // + << "," << field_to_string(row.lookup_u16_2) // + << "," << field_to_string(row.lookup_u16_3) // + << "," << field_to_string(row.lookup_u16_4) // + << "," << field_to_string(row.lookup_u16_5) // + << "," << field_to_string(row.lookup_u16_6) // + << "," << field_to_string(row.lookup_u16_7) // + << "," << field_to_string(row.lookup_u16_8) // + << "," << field_to_string(row.lookup_u16_9) // + << "," << field_to_string(row.lookup_u16_10) // + << "," << field_to_string(row.lookup_u16_11) // + << "," << field_to_string(row.lookup_u16_12) // + << "," << field_to_string(row.lookup_u16_13) // + << "," << field_to_string(row.lookup_u16_14) // + << "," << field_to_string(row.lookup_div_u16_0) // + << "," << field_to_string(row.lookup_div_u16_1) // + << "," << field_to_string(row.lookup_div_u16_2) // + << "," << field_to_string(row.lookup_div_u16_3) // + << "," << field_to_string(row.lookup_div_u16_4) // + << "," << field_to_string(row.lookup_div_u16_5) // + << "," << field_to_string(row.lookup_div_u16_6) // + << "," << field_to_string(row.lookup_div_u16_7) // + << "," << field_to_string(row.lookup_byte_lengths_counts) // + << "," << field_to_string(row.lookup_byte_operations_counts) // + << "," << field_to_string(row.lookup_cd_value_counts) // + << "," << field_to_string(row.lookup_opcode_gas_counts) // + << "," << field_to_string(row.range_check_l2_gas_hi_counts) // + << "," << field_to_string(row.range_check_l2_gas_lo_counts) // + << "," << field_to_string(row.range_check_da_gas_hi_counts) // + << "," << field_to_string(row.range_check_da_gas_lo_counts) // + << "," << field_to_string(row.kernel_output_lookup_counts) // + << "," << field_to_string(row.lookup_into_kernel_counts) // + << "," << field_to_string(row.incl_main_tag_err_counts) // + << "," << field_to_string(row.incl_mem_tag_err_counts) // + << "," << field_to_string(row.lookup_mem_rng_chk_lo_counts) // + << "," << field_to_string(row.lookup_mem_rng_chk_mid_counts) // + << "," << field_to_string(row.lookup_mem_rng_chk_hi_counts) // + << "," << field_to_string(row.lookup_pow_2_0_counts) // + << "," << field_to_string(row.lookup_pow_2_1_counts) // + << "," << field_to_string(row.lookup_u8_0_counts) // + << "," << field_to_string(row.lookup_u8_1_counts) // + << "," << field_to_string(row.lookup_u16_0_counts) // + << "," << field_to_string(row.lookup_u16_1_counts) // + << "," << field_to_string(row.lookup_u16_2_counts) // + << "," << field_to_string(row.lookup_u16_3_counts) // + << "," << field_to_string(row.lookup_u16_4_counts) // + << "," << field_to_string(row.lookup_u16_5_counts) // + << "," << field_to_string(row.lookup_u16_6_counts) // + << "," << field_to_string(row.lookup_u16_7_counts) // + << "," << field_to_string(row.lookup_u16_8_counts) // + << "," << field_to_string(row.lookup_u16_9_counts) // + << "," << field_to_string(row.lookup_u16_10_counts) // + << "," << field_to_string(row.lookup_u16_11_counts) // + << "," << field_to_string(row.lookup_u16_12_counts) // + << "," << field_to_string(row.lookup_u16_13_counts) // + << "," << field_to_string(row.lookup_u16_14_counts) // + << "," << field_to_string(row.lookup_div_u16_0_counts) // + << "," << field_to_string(row.lookup_div_u16_1_counts) // + << "," << field_to_string(row.lookup_div_u16_2_counts) // + << "," << field_to_string(row.lookup_div_u16_3_counts) // + << "," << field_to_string(row.lookup_div_u16_4_counts) // + << "," << field_to_string(row.lookup_div_u16_5_counts) // + << "," << field_to_string(row.lookup_div_u16_6_counts) // + << "," << field_to_string(row.lookup_div_u16_7_counts) // + ; +} + +// Explicit template instantiation. +template std::ostream& operator<<(std::ostream& os, AvmFullRow const& row); +template std::vector AvmFullRow::names(); + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 2bfabec72734..b30ff7909703 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -29,8 +29,8 @@ class AvmCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 387; - static constexpr size_t num_polys = 387 + 65; + static constexpr size_t num_fixed_columns = 404; + static constexpr size_t num_polys = 404 + 68; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -222,6 +222,8 @@ class AvmCircuitBuilder { polys.main_rwd[i] = rows[i].main_rwd; polys.main_sel_alu[i] = rows[i].main_sel_alu; polys.main_sel_bin[i] = rows[i].main_sel_bin; + polys.main_sel_calldata[i] = rows[i].main_sel_calldata; + polys.main_sel_cd_cpy_gadget[i] = rows[i].main_sel_cd_cpy_gadget; polys.main_sel_gas_accounting_active[i] = rows[i].main_sel_gas_accounting_active; polys.main_sel_last[i] = rows[i].main_sel_last; polys.main_sel_mem_op_a[i] = rows[i].main_sel_mem_op_a; @@ -235,6 +237,7 @@ class AvmCircuitBuilder { polys.main_sel_op_address[i] = rows[i].main_sel_op_address; polys.main_sel_op_and[i] = rows[i].main_sel_op_and; polys.main_sel_op_block_number[i] = rows[i].main_sel_op_block_number; + polys.main_sel_op_calldata_copy[i] = rows[i].main_sel_op_calldata_copy; polys.main_sel_op_cast[i] = rows[i].main_sel_op_cast; polys.main_sel_op_chain_id[i] = rows[i].main_sel_op_chain_id; polys.main_sel_op_cmov[i] = rows[i].main_sel_op_cmov; @@ -311,6 +314,7 @@ class AvmCircuitBuilder { polys.mem_sel_op_a[i] = rows[i].mem_sel_op_a; polys.mem_sel_op_b[i] = rows[i].mem_sel_op_b; polys.mem_sel_op_c[i] = rows[i].mem_sel_op_c; + polys.mem_sel_op_cd_cpy[i] = rows[i].mem_sel_op_cd_cpy; polys.mem_sel_op_cmov[i] = rows[i].mem_sel_op_cmov; polys.mem_sel_op_d[i] = rows[i].mem_sel_op_d; polys.mem_sel_resolve_ind_addr_a[i] = rows[i].mem_sel_resolve_ind_addr_a; @@ -339,8 +343,18 @@ class AvmCircuitBuilder { polys.sha256_output[i] = rows[i].sha256_output; polys.sha256_sel_sha256_compression[i] = rows[i].sha256_sel_sha256_compression; polys.sha256_state[i] = rows[i].sha256_state; + polys.slice_addr[i] = rows[i].slice_addr; + polys.slice_cd_offset[i] = rows[i].slice_cd_offset; + polys.slice_clk[i] = rows[i].slice_clk; + polys.slice_cnt[i] = rows[i].slice_cnt; + polys.slice_one_min_inv[i] = rows[i].slice_one_min_inv; + polys.slice_sel_cd_cpy[i] = rows[i].slice_sel_cd_cpy; + polys.slice_sel_start_cd_cpy[i] = rows[i].slice_sel_start_cd_cpy; + polys.slice_space_id[i] = rows[i].slice_space_id; + polys.slice_val[i] = rows[i].slice_val; polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; + polys.lookup_cd_value_counts[i] = rows[i].lookup_cd_value_counts; polys.lookup_opcode_gas_counts[i] = rows[i].lookup_opcode_gas_counts; polys.range_check_l2_gas_hi_counts[i] = rows[i].range_check_l2_gas_hi_counts; polys.range_check_l2_gas_lo_counts[i] = rows[i].range_check_l2_gas_lo_counts; @@ -453,6 +467,9 @@ class AvmCircuitBuilder { polys.mem_tag_shift = Polynomial(polys.mem_tag.shifted()); polys.mem_tsp_shift = Polynomial(polys.mem_tsp.shifted()); polys.mem_val_shift = Polynomial(polys.mem_val.shifted()); + polys.slice_addr_shift = Polynomial(polys.slice_addr.shifted()); + polys.slice_cd_offset_shift = Polynomial(polys.slice_cd_offset.shifted()); + polys.slice_cnt_shift = Polynomial(polys.slice_cnt.shifted()); return polys; } @@ -552,6 +569,10 @@ class AvmCircuitBuilder { auto mem = [=]() { return evaluate_relation.template operator()>("mem", Avm_vm::get_relation_label_mem); }; + auto mem_slice = [=]() { + return evaluate_relation.template operator()>("mem_slice", + Avm_vm::get_relation_label_mem_slice); + }; auto pedersen = [=]() { return evaluate_relation.template operator()>("pedersen", Avm_vm::get_relation_label_pedersen); @@ -570,6 +591,9 @@ class AvmCircuitBuilder { }; // Check lookups + auto perm_cd_mem = [=]() { + return evaluate_logderivative.template operator()>("PERM_CD_MEM"); + }; auto perm_main_alu = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_ALU"); }; @@ -585,6 +609,9 @@ class AvmCircuitBuilder { auto perm_main_pedersen = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_PEDERSEN"); }; + auto perm_main_cd_copy = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_CD_COPY"); + }; auto perm_main_mem_a = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_A"); }; @@ -620,6 +647,9 @@ class AvmCircuitBuilder { return evaluate_logderivative.template operator()>( "LOOKUP_BYTE_OPERATIONS"); }; + auto lookup_cd_value = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_CD_VALUE"); + }; auto lookup_opcode_gas = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_OPCODE_GAS"); }; @@ -757,15 +787,18 @@ class AvmCircuitBuilder { relation_futures.emplace_back(std::async(std::launch::async, kernel)); relation_futures.emplace_back(std::async(std::launch::async, main)); relation_futures.emplace_back(std::async(std::launch::async, mem)); + relation_futures.emplace_back(std::async(std::launch::async, mem_slice)); relation_futures.emplace_back(std::async(std::launch::async, pedersen)); relation_futures.emplace_back(std::async(std::launch::async, poseidon2)); relation_futures.emplace_back(std::async(std::launch::async, powers)); relation_futures.emplace_back(std::async(std::launch::async, sha256)); + relation_futures.emplace_back(std::async(std::launch::async, perm_cd_mem)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_alu)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_bin)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_conv)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_pos2_perm)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_pedersen)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_cd_copy)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_a)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_b)); relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_c)); @@ -776,6 +809,7 @@ class AvmCircuitBuilder { relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_addr_d)); relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_lengths)); relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_operations)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_cd_value)); relation_futures.emplace_back(std::async(std::launch::async, lookup_opcode_gas)); relation_futures.emplace_back(std::async(std::launch::async, range_check_l2_gas_hi)); relation_futures.emplace_back(std::async(std::launch::async, range_check_l2_gas_lo)); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index a2a58cd49a40..bff44bf37339 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -23,6 +23,7 @@ #include "barretenberg/relations/generated/avm/kernel.hpp" #include "barretenberg/relations/generated/avm/main.hpp" #include "barretenberg/relations/generated/avm/mem.hpp" +#include "barretenberg/relations/generated/avm/mem_slice.hpp" #include "barretenberg/relations/generated/avm/pedersen.hpp" #include "barretenberg/relations/generated/avm/poseidon2.hpp" #include "barretenberg/relations/generated/avm/powers.hpp" @@ -34,6 +35,7 @@ #include "barretenberg/relations/generated/avm/kernel_output_lookup.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_lengths.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_operations.hpp" +#include "barretenberg/relations/generated/avm/lookup_cd_value.hpp" #include "barretenberg/relations/generated/avm/lookup_div_u16_0.hpp" #include "barretenberg/relations/generated/avm/lookup_div_u16_1.hpp" #include "barretenberg/relations/generated/avm/lookup_div_u16_2.hpp" @@ -66,8 +68,10 @@ #include "barretenberg/relations/generated/avm/lookup_u16_9.hpp" #include "barretenberg/relations/generated/avm/lookup_u8_0.hpp" #include "barretenberg/relations/generated/avm/lookup_u8_1.hpp" +#include "barretenberg/relations/generated/avm/perm_cd_mem.hpp" #include "barretenberg/relations/generated/avm/perm_main_alu.hpp" #include "barretenberg/relations/generated/avm/perm_main_bin.hpp" +#include "barretenberg/relations/generated/avm/perm_main_cd_copy.hpp" #include "barretenberg/relations/generated/avm/perm_main_conv.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_a.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_b.hpp" @@ -107,11 +111,11 @@ class AvmFlavor { using RelationSeparator = AvmFlavorSettings::RelationSeparator; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 385; + static constexpr size_t NUM_WITNESS_ENTITIES = 402; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for // the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 452; + static constexpr size_t NUM_ALL_ENTITIES = 472; using MainRelations = std::tuple< // Relations @@ -123,6 +127,7 @@ class AvmFlavor { Avm_vm::kernel, Avm_vm::main, Avm_vm::mem, + Avm_vm::mem_slice, Avm_vm::pedersen, Avm_vm::poseidon2, Avm_vm::powers, @@ -130,11 +135,13 @@ class AvmFlavor { using LookupRelations = std::tuple< // Lookups + perm_cd_mem_relation, perm_main_alu_relation, perm_main_bin_relation, perm_main_conv_relation, perm_main_pos2_perm_relation, perm_main_pedersen_relation, + perm_main_cd_copy_relation, perm_main_mem_a_relation, perm_main_mem_b_relation, perm_main_mem_c_relation, @@ -145,6 +152,7 @@ class AvmFlavor { perm_main_mem_ind_addr_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, + lookup_cd_value_relation, lookup_opcode_gas_relation, range_check_l2_gas_hi_relation, range_check_l2_gas_lo_relation, @@ -392,6 +400,8 @@ class AvmFlavor { main_rwd, main_sel_alu, main_sel_bin, + main_sel_calldata, + main_sel_cd_cpy_gadget, main_sel_gas_accounting_active, main_sel_last, main_sel_mem_op_a, @@ -405,6 +415,7 @@ class AvmFlavor { main_sel_op_address, main_sel_op_and, main_sel_op_block_number, + main_sel_op_calldata_copy, main_sel_op_cast, main_sel_op_chain_id, main_sel_op_cmov, @@ -481,6 +492,7 @@ class AvmFlavor { mem_sel_op_a, mem_sel_op_b, mem_sel_op_c, + mem_sel_op_cd_cpy, mem_sel_op_cmov, mem_sel_op_d, mem_sel_resolve_ind_addr_a, @@ -509,8 +521,18 @@ class AvmFlavor { sha256_output, sha256_sel_sha256_compression, sha256_state, + slice_addr, + slice_cd_offset, + slice_clk, + slice_cnt, + slice_one_min_inv, + slice_sel_cd_cpy, + slice_sel_start_cd_cpy, + slice_space_id, + slice_val, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_cd_value_counts, lookup_opcode_gas_counts, range_check_l2_gas_hi_counts, range_check_l2_gas_lo_counts, @@ -555,11 +577,13 @@ class AvmFlavor { template class DerivedWitnessEntities { public: DEFINE_FLAVOR_MEMBERS(DataType, + perm_cd_mem, perm_main_alu, perm_main_bin, perm_main_conv, perm_main_pos2_perm, perm_main_pedersen, + perm_main_cd_copy, perm_main_mem_a, perm_main_mem_b, perm_main_mem_c, @@ -570,6 +594,7 @@ class AvmFlavor { perm_main_mem_ind_addr_d, lookup_byte_lengths, lookup_byte_operations, + lookup_cd_value, lookup_opcode_gas, range_check_l2_gas_hi, range_check_l2_gas_lo, @@ -678,7 +703,10 @@ class AvmFlavor { mem_sel_mem_shift, mem_tag_shift, mem_tsp_shift, - mem_val_shift) + mem_val_shift, + slice_addr_shift, + slice_cd_offset_shift, + slice_cnt_shift) }; template @@ -748,7 +776,10 @@ class AvmFlavor { entities.mem_sel_mem, entities.mem_tag, entities.mem_tsp, - entities.mem_val }; + entities.mem_val, + entities.slice_addr, + entities.slice_cd_offset, + entities.slice_cnt }; } template @@ -855,7 +886,10 @@ class AvmFlavor { mem_sel_mem, mem_tag, mem_tsp, - mem_val }; + mem_val, + slice_addr, + slice_cd_offset, + slice_cnt }; } }; @@ -1126,6 +1160,8 @@ class AvmFlavor { Base::main_rwd = "MAIN_RWD"; Base::main_sel_alu = "MAIN_SEL_ALU"; Base::main_sel_bin = "MAIN_SEL_BIN"; + Base::main_sel_calldata = "MAIN_SEL_CALLDATA"; + Base::main_sel_cd_cpy_gadget = "MAIN_SEL_CD_CPY_GADGET"; Base::main_sel_gas_accounting_active = "MAIN_SEL_GAS_ACCOUNTING_ACTIVE"; Base::main_sel_last = "MAIN_SEL_LAST"; Base::main_sel_mem_op_a = "MAIN_SEL_MEM_OP_A"; @@ -1139,6 +1175,7 @@ class AvmFlavor { Base::main_sel_op_address = "MAIN_SEL_OP_ADDRESS"; Base::main_sel_op_and = "MAIN_SEL_OP_AND"; Base::main_sel_op_block_number = "MAIN_SEL_OP_BLOCK_NUMBER"; + Base::main_sel_op_calldata_copy = "MAIN_SEL_OP_CALLDATA_COPY"; Base::main_sel_op_cast = "MAIN_SEL_OP_CAST"; Base::main_sel_op_chain_id = "MAIN_SEL_OP_CHAIN_ID"; Base::main_sel_op_cmov = "MAIN_SEL_OP_CMOV"; @@ -1215,6 +1252,7 @@ class AvmFlavor { Base::mem_sel_op_a = "MEM_SEL_OP_A"; Base::mem_sel_op_b = "MEM_SEL_OP_B"; Base::mem_sel_op_c = "MEM_SEL_OP_C"; + Base::mem_sel_op_cd_cpy = "MEM_SEL_OP_CD_CPY"; Base::mem_sel_op_cmov = "MEM_SEL_OP_CMOV"; Base::mem_sel_op_d = "MEM_SEL_OP_D"; Base::mem_sel_resolve_ind_addr_a = "MEM_SEL_RESOLVE_IND_ADDR_A"; @@ -1243,11 +1281,22 @@ class AvmFlavor { Base::sha256_output = "SHA256_OUTPUT"; Base::sha256_sel_sha256_compression = "SHA256_SEL_SHA256_COMPRESSION"; Base::sha256_state = "SHA256_STATE"; + Base::slice_addr = "SLICE_ADDR"; + Base::slice_cd_offset = "SLICE_CD_OFFSET"; + Base::slice_clk = "SLICE_CLK"; + Base::slice_cnt = "SLICE_CNT"; + Base::slice_one_min_inv = "SLICE_ONE_MIN_INV"; + Base::slice_sel_cd_cpy = "SLICE_SEL_CD_CPY"; + Base::slice_sel_start_cd_cpy = "SLICE_SEL_START_CD_CPY"; + Base::slice_space_id = "SLICE_SPACE_ID"; + Base::slice_val = "SLICE_VAL"; + Base::perm_cd_mem = "PERM_CD_MEM"; Base::perm_main_alu = "PERM_MAIN_ALU"; Base::perm_main_bin = "PERM_MAIN_BIN"; Base::perm_main_conv = "PERM_MAIN_CONV"; Base::perm_main_pos2_perm = "PERM_MAIN_POS2_PERM"; Base::perm_main_pedersen = "PERM_MAIN_PEDERSEN"; + Base::perm_main_cd_copy = "PERM_MAIN_CD_COPY"; Base::perm_main_mem_a = "PERM_MAIN_MEM_A"; Base::perm_main_mem_b = "PERM_MAIN_MEM_B"; Base::perm_main_mem_c = "PERM_MAIN_MEM_C"; @@ -1258,6 +1307,7 @@ class AvmFlavor { Base::perm_main_mem_ind_addr_d = "PERM_MAIN_MEM_IND_ADDR_D"; Base::lookup_byte_lengths = "LOOKUP_BYTE_LENGTHS"; Base::lookup_byte_operations = "LOOKUP_BYTE_OPERATIONS"; + Base::lookup_cd_value = "LOOKUP_CD_VALUE"; Base::lookup_opcode_gas = "LOOKUP_OPCODE_GAS"; Base::range_check_l2_gas_hi = "RANGE_CHECK_L2_GAS_HI"; Base::range_check_l2_gas_lo = "RANGE_CHECK_L2_GAS_LO"; @@ -1299,6 +1349,7 @@ class AvmFlavor { Base::lookup_div_u16_7 = "LOOKUP_DIV_U16_7"; Base::lookup_byte_lengths_counts = "LOOKUP_BYTE_LENGTHS_COUNTS"; Base::lookup_byte_operations_counts = "LOOKUP_BYTE_OPERATIONS_COUNTS"; + Base::lookup_cd_value_counts = "LOOKUP_CD_VALUE_COUNTS"; Base::lookup_opcode_gas_counts = "LOOKUP_OPCODE_GAS_COUNTS"; Base::range_check_l2_gas_hi_counts = "RANGE_CHECK_L2_GAS_HI_COUNTS"; Base::range_check_l2_gas_lo_counts = "RANGE_CHECK_L2_GAS_LO_COUNTS"; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.cpp index 3cda79780a3e..d49e9277b0e7 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.cpp @@ -193,6 +193,8 @@ template std::vector AvmFullRow::names() "main_rwd", "main_sel_alu", "main_sel_bin", + "main_sel_calldata", + "main_sel_cd_cpy_gadget", "main_sel_gas_accounting_active", "main_sel_last", "main_sel_mem_op_a", @@ -206,6 +208,7 @@ template std::vector AvmFullRow::names() "main_sel_op_address", "main_sel_op_and", "main_sel_op_block_number", + "main_sel_op_calldata_copy", "main_sel_op_cast", "main_sel_op_chain_id", "main_sel_op_cmov", @@ -282,6 +285,7 @@ template std::vector AvmFullRow::names() "mem_sel_op_a", "mem_sel_op_b", "mem_sel_op_c", + "mem_sel_op_cd_cpy", "mem_sel_op_cmov", "mem_sel_op_d", "mem_sel_resolve_ind_addr_a", @@ -310,11 +314,22 @@ template std::vector AvmFullRow::names() "sha256_output", "sha256_sel_sha256_compression", "sha256_state", + "slice_addr", + "slice_cd_offset", + "slice_clk", + "slice_cnt", + "slice_one_min_inv", + "slice_sel_cd_cpy", + "slice_sel_start_cd_cpy", + "slice_space_id", + "slice_val", + "perm_cd_mem", "perm_main_alu", "perm_main_bin", "perm_main_conv", "perm_main_pos2_perm", "perm_main_pedersen", + "perm_main_cd_copy", "perm_main_mem_a", "perm_main_mem_b", "perm_main_mem_c", @@ -325,6 +340,7 @@ template std::vector AvmFullRow::names() "perm_main_mem_ind_addr_d", "lookup_byte_lengths", "lookup_byte_operations", + "lookup_cd_value", "lookup_opcode_gas", "range_check_l2_gas_hi", "range_check_l2_gas_lo", @@ -366,6 +382,7 @@ template std::vector AvmFullRow::names() "lookup_div_u16_7", "lookup_byte_lengths_counts", "lookup_byte_operations_counts", + "lookup_cd_value_counts", "lookup_opcode_gas_counts", "range_check_l2_gas_hi_counts", "range_check_l2_gas_lo_counts", @@ -584,6 +601,8 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << field_to_string(row.main_rwd) // << "," << field_to_string(row.main_sel_alu) // << "," << field_to_string(row.main_sel_bin) // + << "," << field_to_string(row.main_sel_calldata) // + << "," << field_to_string(row.main_sel_cd_cpy_gadget) // << "," << field_to_string(row.main_sel_gas_accounting_active) // << "," << field_to_string(row.main_sel_last) // << "," << field_to_string(row.main_sel_mem_op_a) // @@ -597,6 +616,7 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << field_to_string(row.main_sel_op_address) // << "," << field_to_string(row.main_sel_op_and) // << "," << field_to_string(row.main_sel_op_block_number) // + << "," << field_to_string(row.main_sel_op_calldata_copy) // << "," << field_to_string(row.main_sel_op_cast) // << "," << field_to_string(row.main_sel_op_chain_id) // << "," << field_to_string(row.main_sel_op_cmov) // @@ -673,6 +693,7 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << field_to_string(row.mem_sel_op_a) // << "," << field_to_string(row.mem_sel_op_b) // << "," << field_to_string(row.mem_sel_op_c) // + << "," << field_to_string(row.mem_sel_op_cd_cpy) // << "," << field_to_string(row.mem_sel_op_cmov) // << "," << field_to_string(row.mem_sel_op_d) // << "," << field_to_string(row.mem_sel_resolve_ind_addr_a) // @@ -701,11 +722,22 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << field_to_string(row.sha256_output) // << "," << field_to_string(row.sha256_sel_sha256_compression) // << "," << field_to_string(row.sha256_state) // + << "," << field_to_string(row.slice_addr) // + << "," << field_to_string(row.slice_cd_offset) // + << "," << field_to_string(row.slice_clk) // + << "," << field_to_string(row.slice_cnt) // + << "," << field_to_string(row.slice_one_min_inv) // + << "," << field_to_string(row.slice_sel_cd_cpy) // + << "," << field_to_string(row.slice_sel_start_cd_cpy) // + << "," << field_to_string(row.slice_space_id) // + << "," << field_to_string(row.slice_val) // + << "," << field_to_string(row.perm_cd_mem) // << "," << field_to_string(row.perm_main_alu) // << "," << field_to_string(row.perm_main_bin) // << "," << field_to_string(row.perm_main_conv) // << "," << field_to_string(row.perm_main_pos2_perm) // << "," << field_to_string(row.perm_main_pedersen) // + << "," << field_to_string(row.perm_main_cd_copy) // << "," << field_to_string(row.perm_main_mem_a) // << "," << field_to_string(row.perm_main_mem_b) // << "," << field_to_string(row.perm_main_mem_c) // @@ -716,6 +748,7 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << field_to_string(row.perm_main_mem_ind_addr_d) // << "," << field_to_string(row.lookup_byte_lengths) // << "," << field_to_string(row.lookup_byte_operations) // + << "," << field_to_string(row.lookup_cd_value) // << "," << field_to_string(row.lookup_opcode_gas) // << "," << field_to_string(row.range_check_l2_gas_hi) // << "," << field_to_string(row.range_check_l2_gas_lo) // @@ -757,6 +790,7 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << field_to_string(row.lookup_div_u16_7) // << "," << field_to_string(row.lookup_byte_lengths_counts) // << "," << field_to_string(row.lookup_byte_operations_counts) // + << "," << field_to_string(row.lookup_cd_value_counts) // << "," << field_to_string(row.lookup_opcode_gas_counts) // << "," << field_to_string(row.range_check_l2_gas_hi_counts) // << "," << field_to_string(row.range_check_l2_gas_lo_counts) // diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.hpp index 6499381c1814..f6a06beafa8f 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.hpp @@ -182,6 +182,8 @@ template struct AvmFullRow { FF main_rwd{}; FF main_sel_alu{}; FF main_sel_bin{}; + FF main_sel_calldata{}; + FF main_sel_cd_cpy_gadget{}; FF main_sel_gas_accounting_active{}; FF main_sel_last{}; FF main_sel_mem_op_a{}; @@ -195,6 +197,7 @@ template struct AvmFullRow { FF main_sel_op_address{}; FF main_sel_op_and{}; FF main_sel_op_block_number{}; + FF main_sel_op_calldata_copy{}; FF main_sel_op_cast{}; FF main_sel_op_chain_id{}; FF main_sel_op_cmov{}; @@ -271,6 +274,7 @@ template struct AvmFullRow { FF mem_sel_op_a{}; FF mem_sel_op_b{}; FF mem_sel_op_c{}; + FF mem_sel_op_cd_cpy{}; FF mem_sel_op_cmov{}; FF mem_sel_op_d{}; FF mem_sel_resolve_ind_addr_a{}; @@ -299,11 +303,22 @@ template struct AvmFullRow { FF sha256_output{}; FF sha256_sel_sha256_compression{}; FF sha256_state{}; + FF slice_addr{}; + FF slice_cd_offset{}; + FF slice_clk{}; + FF slice_cnt{}; + FF slice_one_min_inv{}; + FF slice_sel_cd_cpy{}; + FF slice_sel_start_cd_cpy{}; + FF slice_space_id{}; + FF slice_val{}; + FF perm_cd_mem{}; FF perm_main_alu{}; FF perm_main_bin{}; FF perm_main_conv{}; FF perm_main_pos2_perm{}; FF perm_main_pedersen{}; + FF perm_main_cd_copy{}; FF perm_main_mem_a{}; FF perm_main_mem_b{}; FF perm_main_mem_c{}; @@ -314,6 +329,7 @@ template struct AvmFullRow { FF perm_main_mem_ind_addr_d{}; FF lookup_byte_lengths{}; FF lookup_byte_operations{}; + FF lookup_cd_value{}; FF lookup_opcode_gas{}; FF range_check_l2_gas_hi{}; FF range_check_l2_gas_lo{}; @@ -355,6 +371,7 @@ template struct AvmFullRow { FF lookup_div_u16_7{}; FF lookup_byte_lengths_counts{}; FF lookup_byte_operations_counts{}; + FF lookup_cd_value_counts{}; FF lookup_opcode_gas_counts{}; FF range_check_l2_gas_hi_counts{}; FF range_check_l2_gas_lo_counts{}; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index b1046c8400a7..1e9486fe7348 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -79,6 +79,7 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.perm_cd_mem); commitments.perm_main_alu = transcript->template receive_from_prover(commitment_labels.perm_main_alu); commitments.perm_main_bin = transcript->template receive_from_prover(commitment_labels.perm_main_bin); commitments.perm_main_conv = transcript->template receive_from_prover(commitment_labels.perm_main_conv); @@ -86,6 +87,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.perm_main_pos2_perm); commitments.perm_main_pedersen = transcript->template receive_from_prover(commitment_labels.perm_main_pedersen); + commitments.perm_main_cd_copy = + transcript->template receive_from_prover(commitment_labels.perm_main_cd_copy); commitments.perm_main_mem_a = transcript->template receive_from_prover(commitment_labels.perm_main_mem_a); commitments.perm_main_mem_b = @@ -106,6 +109,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.lookup_byte_lengths); commitments.lookup_byte_operations = transcript->template receive_from_prover(commitment_labels.lookup_byte_operations); + commitments.lookup_cd_value = + transcript->template receive_from_prover(commitment_labels.lookup_cd_value); commitments.lookup_opcode_gas = transcript->template receive_from_prover(commitment_labels.lookup_opcode_gas); commitments.range_check_l2_gas_hi = diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_cast.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_cast.test.cpp index 11d9768300df..de12256404ac 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_cast.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_cast.test.cpp @@ -26,9 +26,9 @@ class AvmCastTests : public ::testing::Test { std::vector calldata; std::vector trace; - size_t main_addr; - size_t alu_addr; - size_t mem_addr_c; + size_t main_row_idx; + size_t alu_row_idx; + size_t mem_c_row_idx; void gen_trace( uint128_t const& a, uint32_t src_address, uint32_t dst_address, AvmMemoryTag src_tag, AvmMemoryTag dst_tag) @@ -44,20 +44,20 @@ class AvmCastTests : public ::testing::Test { { auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_cast == FF(1); }); ASSERT_TRUE(row != trace.end()); - main_addr = static_cast(row - trace.begin()); + main_row_idx = static_cast(row - trace.begin()); // Find the corresponding Alu trace row auto clk = row->main_clk; auto alu_row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { return r.alu_clk == clk; }); ASSERT_TRUE(alu_row != trace.end()); - alu_addr = static_cast(alu_row - trace.begin()); + alu_row_idx = static_cast(alu_row - trace.begin()); // Mem entry output ic write operation auto mem_row_c = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { return r.mem_tsp == FF(AvmMemTraceBuilder::NUM_SUB_CLK) * clk + AvmMemTraceBuilder::SUB_CLK_STORE_C; }); ASSERT_TRUE(mem_row_c != trace.end()); - mem_addr_c = static_cast(mem_row_c - trace.begin()); + mem_c_row_idx = static_cast(mem_row_c - trace.begin()); } void validate_cast_trace(FF const& a, @@ -70,7 +70,7 @@ class AvmCastTests : public ::testing::Test { ) { - auto const& row = trace.at(main_addr); + auto const& row = trace.at(main_row_idx); EXPECT_THAT(row, AllOf(MAIN_ROW_FIELD_EQ(sel_op_cast, 1), MAIN_ROW_FIELD_EQ(ia, a), @@ -90,7 +90,7 @@ class AvmCastTests : public ::testing::Test { MAIN_ROW_FIELD_EQ(sel_rng_8, 1), MAIN_ROW_FIELD_EQ(sel_rng_16, 1))); - auto const& alu_row = trace.at(alu_addr); + auto const& alu_row = trace.at(alu_row_idx); EXPECT_THAT(alu_row, AllOf(ALU_ROW_FIELD_EQ(op_cast, 1), ALU_ROW_FIELD_EQ(ia, a), @@ -108,7 +108,7 @@ class AvmCastTests : public ::testing::Test { ALU_ROW_FIELD_EQ(sel_alu, 1))); // Check that there is a second ALU row - auto alu_row_next = trace.at(alu_addr + 1); + auto alu_row_next = trace.at(alu_row_idx + 1); EXPECT_THAT(alu_row_next, AllOf(ALU_ROW_FIELD_EQ(op_cast, 0), ALU_ROW_FIELD_EQ(op_cast_prev, 1))); // We still want the ability to enable proving through the environment variable and therefore we do not pass @@ -256,13 +256,13 @@ TEST_F(AvmCastTests, indirectAddrWrongResolutionU64ToU8) TEST_F(AvmCastNegativeTests, nonTruncatedOutputMainIc) { gen_trace(300, 0, 1, AvmMemoryTag::U16, AvmMemoryTag::U8); - ASSERT_EQ(trace.at(main_addr).main_ic, 44); + ASSERT_EQ(trace.at(main_row_idx).main_ic, 44); // Replace the output in main trace with the non-truncated value - trace.at(main_addr).main_ic = 300; + trace.at(main_row_idx).main_ic = 300; // Adapt the memory trace entry - trace.at(mem_addr_c).mem_val = 300; + trace.at(mem_c_row_idx).mem_val = 300; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -270,13 +270,13 @@ TEST_F(AvmCastNegativeTests, nonTruncatedOutputMainIc) TEST_F(AvmCastNegativeTests, wrongOutputMainIc) { gen_trace(151515, 0, 1, AvmMemoryTag::U32, AvmMemoryTag::FF); - ASSERT_EQ(trace.at(main_addr).main_ic, 151515); + ASSERT_EQ(trace.at(main_row_idx).main_ic, 151515); // Replace the output in main trace with a wrong value - trace.at(main_addr).main_ic = 151516; + trace.at(main_row_idx).main_ic = 151516; // Adapt the memory trace entry - trace.at(mem_addr_c).mem_val = 151516; + trace.at(mem_c_row_idx).mem_val = 151516; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -284,12 +284,12 @@ TEST_F(AvmCastNegativeTests, wrongOutputMainIc) TEST_F(AvmCastNegativeTests, wrongOutputAluIc) { gen_trace(6582736, 0, 1, AvmMemoryTag::U128, AvmMemoryTag::U16); - ASSERT_EQ(trace.at(alu_addr).alu_ic, 29136); + ASSERT_EQ(trace.at(alu_row_idx).alu_ic, 29136); // Replace output in ALU, MAIN, and MEM trace - trace.at(alu_addr).alu_ic = 33; - trace.at(main_addr).main_ic = 33; - trace.at(mem_addr_c).mem_val = 33; + trace.at(alu_row_idx).alu_ic = 33; + trace.at(main_row_idx).main_ic = 33; + trace.at(mem_c_row_idx).mem_val = 33; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_CAST"); } @@ -304,7 +304,7 @@ TEST_F(AvmCastNegativeTests, wrongLimbDecompositionInput) trace = trace_builder.finalize(); gen_indices(); - trace.at(alu_addr).alu_a_lo -= 23; + trace.at(alu_row_idx).alu_a_lo -= 23; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INPUT_DECOMP_1"); } @@ -312,9 +312,9 @@ TEST_F(AvmCastNegativeTests, wrongLimbDecompositionInput) TEST_F(AvmCastNegativeTests, wrongPSubALo) { gen_trace(12345, 0, 1, AvmMemoryTag::U32, AvmMemoryTag::U16); - ASSERT_EQ(trace.at(alu_addr).alu_ic, 12345); + ASSERT_EQ(trace.at(alu_row_idx).alu_ic, 12345); - trace.at(alu_addr).alu_p_sub_a_lo += 3; + trace.at(alu_row_idx).alu_p_sub_a_lo += 3; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUB_LO_1"); } @@ -329,7 +329,7 @@ TEST_F(AvmCastNegativeTests, wrongPSubAHi) trace = trace_builder.finalize(); gen_indices(); - trace.at(alu_addr).alu_p_sub_a_hi += 3; + trace.at(alu_row_idx).alu_p_sub_a_hi += 3; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUB_HI_1"); } @@ -338,7 +338,7 @@ TEST_F(AvmCastNegativeTests, disableRangecheck) { gen_trace(123, 23, 43, AvmMemoryTag::U8, AvmMemoryTag::U8); - trace.at(alu_addr).alu_sel_rng_chk_lookup = 0; + trace.at(alu_row_idx).alu_sel_rng_chk_lookup = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "RNG_CHK_LOOKUP_SELECTOR"); } @@ -346,16 +346,16 @@ TEST_F(AvmCastNegativeTests, disableRangecheckSub) { gen_trace(123, 23, 43, AvmMemoryTag::U8, AvmMemoryTag::U8); - trace.at(alu_addr + 1).alu_sel_rng_chk_lookup = 0; + trace.at(alu_row_idx + 1).alu_sel_rng_chk_lookup = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "RNG_CHK_LOOKUP_SELECTOR"); } TEST_F(AvmCastNegativeTests, wrongRangeCheckDecompositionLo) { gen_trace(987344323, 23, 43, AvmMemoryTag::FF, AvmMemoryTag::U128); - ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_row_idx).alu_ic, 987344323); - trace.at(alu_addr).alu_u16_r0 = 5555; + trace.at(alu_row_idx).alu_u16_r0 = 5555; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOWER_CMP_RNG_CHK"); } @@ -369,17 +369,17 @@ TEST_F(AvmCastNegativeTests, wrongRangeCheckDecompositionHi) trace = trace_builder.finalize(); gen_indices(); - trace.at(alu_addr).alu_u16_r9 = 5555; + trace.at(alu_row_idx).alu_u16_r9 = 5555; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "UPPER_CMP_RNG_CHK"); } TEST_F(AvmCastNegativeTests, outOfRangeU8Registers) { gen_trace(987344323, 23, 43, AvmMemoryTag::FF, AvmMemoryTag::U128); - ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_row_idx).alu_ic, 987344323); - trace.at(alu_addr).alu_u8_r0 += 256; - trace.at(alu_addr).alu_u8_r1 -= 1; // Adjust so that the decomposition is correct. + trace.at(alu_row_idx).alu_u8_r0 += 256; + trace.at(alu_row_idx).alu_u8_r1 -= 1; // Adjust so that the decomposition is correct. EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "Lookup LOOKUP_U8_0"); } @@ -387,10 +387,10 @@ TEST_F(AvmCastNegativeTests, outOfRangeU8Registers) TEST_F(AvmCastNegativeTests, outOfRangeU16Registers) { gen_trace(987344323, 23, 43, AvmMemoryTag::FF, AvmMemoryTag::U128); - ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_row_idx).alu_ic, 987344323); - trace.at(alu_addr).alu_u16_r0 += 65536; - trace.at(alu_addr).alu_u16_r1 -= 1; // Adjust so that the decomposition is correct. + trace.at(alu_row_idx).alu_u16_r0 += 65536; + trace.at(alu_row_idx).alu_u16_r1 -= 1; // Adjust so that the decomposition is correct. EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "Lookup LOOKUP_U16_0"); } @@ -398,10 +398,10 @@ TEST_F(AvmCastNegativeTests, outOfRangeU16Registers) TEST_F(AvmCastNegativeTests, wrongCopySubLoForRangeCheck) { gen_trace(987344323, 23, 43, AvmMemoryTag::U64, AvmMemoryTag::U128); - ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_row_idx).alu_ic, 987344323); - ASSERT_EQ(trace.at(alu_addr + 1).alu_a_lo, trace.at(alu_addr).alu_p_sub_a_lo); - trace.at(alu_addr + 1).alu_a_lo -= 1; + ASSERT_EQ(trace.at(alu_row_idx + 1).alu_a_lo, trace.at(alu_row_idx).alu_p_sub_a_lo); + trace.at(alu_row_idx + 1).alu_a_lo -= 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OP_CAST_RNG_CHECK_P_SUB_A_LOW"); } @@ -415,33 +415,33 @@ TEST_F(AvmCastNegativeTests, wrongCopySubHiForRangeCheck) trace = trace_builder.finalize(); gen_indices(); - ASSERT_EQ(trace.at(alu_addr + 1).alu_a_hi, trace.at(alu_addr).alu_p_sub_a_hi); - trace.at(alu_addr + 1).alu_a_hi += 2; + ASSERT_EQ(trace.at(alu_row_idx + 1).alu_a_hi, trace.at(alu_row_idx).alu_p_sub_a_hi); + trace.at(alu_row_idx + 1).alu_a_hi += 2; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OP_CAST_RNG_CHECK_P_SUB_A_HIGH"); } TEST_F(AvmCastNegativeTests, secondRowNoOp) { gen_trace(6583, 0, 1, AvmMemoryTag::U64, AvmMemoryTag::U8); - ASSERT_EQ(trace.at(alu_addr).alu_ic, 183); + ASSERT_EQ(trace.at(alu_row_idx).alu_ic, 183); // We have to enable alu_sel otherwise another relation will fail. - trace.at(alu_addr + 1).alu_sel_alu = 1; + trace.at(alu_row_idx + 1).alu_sel_alu = 1; // Add an LT selector in the next row (second part of the cast operation) auto trace_lt = trace; - trace_lt.at(alu_addr + 1).alu_op_lt = 1; + trace_lt.at(alu_row_idx + 1).alu_op_lt = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace_lt)), "TWO_LINE_OP_NO_OVERLAP"); // Try with EQ selector auto trace_eq = trace; - trace_eq.at(alu_addr + 1).alu_op_eq = 1; + trace_eq.at(alu_row_idx + 1).alu_op_eq = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace_eq)), "TWO_LINE_OP_NO_OVERLAP"); // Try with a second cast selector - trace.at(alu_addr + 1).alu_op_cast = 1; + trace.at(alu_row_idx + 1).alu_op_cast = 1; // Adjust to not violate #[RNG_CHK_LOOKUP_SELECTOR] - trace.at(alu_addr + 1).alu_sel_rng_chk_lookup = 2; + trace.at(alu_row_idx + 1).alu_sel_rng_chk_lookup = 2; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "TWO_LINE_OP_NO_OVERLAP"); } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp index 400d0a480b4c..79855ca1de60 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp @@ -44,9 +44,9 @@ class AvmInterTableTests : public ::testing::Test { class AvmPermMainAluNegativeTests : public AvmInterTableTests { protected: std::vector trace; - size_t main_addr; - size_t mem_addr; - size_t alu_addr; + size_t main_row_idx; + size_t mem_row_idx; + size_t alu_row_idx; void SetUp() override { @@ -78,9 +78,9 @@ class AvmPermMainAluNegativeTests : public AvmInterTableTests { }); ASSERT_TRUE(mem_row != trace.end()); - main_addr = static_cast(row - trace.begin()); - alu_addr = static_cast(alu_row - trace.begin()); - mem_addr = static_cast(mem_row - trace.begin()); + main_row_idx = static_cast(row - trace.begin()); + alu_row_idx = static_cast(alu_row - trace.begin()); + mem_row_idx = static_cast(mem_row - trace.begin()); } }; @@ -88,8 +88,8 @@ TEST_F(AvmPermMainAluNegativeTests, wrongAluOutputCopyInMain) { // Mutate the multiplication output. Note that the output alu counterpart is still valid // and pass the multiplication relation. - trace.at(main_addr).main_ic = 1008; - trace.at(mem_addr).mem_val = 1008; + trace.at(main_row_idx).main_ic = 1008; + trace.at(mem_row_idx).mem_val = 1008; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -97,10 +97,10 @@ TEST_F(AvmPermMainAluNegativeTests, wrongAluOutputCopyInMain) TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) { // Mutate the input of alu_ia and adapt the output ic accordingly. - trace.at(alu_addr).alu_ia = 20; - trace.at(alu_addr).alu_ic = 1060; // 20 * 53; required to pass the alu mul relation - trace.at(alu_addr).alu_u8_r0 = 36; // 1060 % 256 = 36 - trace.at(alu_addr).alu_u8_r1 = 4; // 4 * 256 = 1024 + trace.at(alu_row_idx).alu_ia = 20; + trace.at(alu_row_idx).alu_ic = 1060; // 20 * 53; required to pass the alu mul relation + trace.at(alu_row_idx).alu_u8_r0 = 36; // 1060 % 256 = 36 + trace.at(alu_row_idx).alu_u8_r1 = 4; // 4 * 256 = 1024 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -108,30 +108,30 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIbInput) { // Mutate the input of alu_ia and adapt the output ic accordingly. - trace.at(alu_addr).alu_ib = 10; - trace.at(alu_addr).alu_ic = 190; // 19 * 10; required to pass the alu mul relation - trace.at(alu_addr).alu_u8_r0 = 190; - trace.at(alu_addr).alu_u8_r1 = 0; + trace.at(alu_row_idx).alu_ib = 10; + trace.at(alu_row_idx).alu_ic = 190; // 19 * 10; required to pass the alu mul relation + trace.at(alu_row_idx).alu_u8_r0 = 190; + trace.at(alu_row_idx).alu_u8_r1 = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluOpSelector) { - trace.at(alu_addr).alu_op_mul = 0; - trace.at(alu_addr).alu_op_add = 1; - trace.at(alu_addr).alu_ic = 72; // 19 + 53 - trace.at(alu_addr).alu_u8_r0 = 72; - trace.at(alu_addr).alu_u8_r1 = 0; + trace.at(alu_row_idx).alu_op_mul = 0; + trace.at(alu_row_idx).alu_op_add = 1; + trace.at(alu_row_idx).alu_ic = 72; // 19 + 53 + trace.at(alu_row_idx).alu_u8_r0 = 72; + trace.at(alu_row_idx).alu_u8_r1 = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) { - trace.at(alu_addr).alu_sel_alu = 0; - trace.at(alu_addr).alu_op_mul = 0; - trace.at(alu_addr).alu_sel_rng_chk_lookup = 0; + trace.at(alu_row_idx).alu_sel_alu = 0; + trace.at(alu_row_idx).alu_op_mul = 0; + trace.at(alu_row_idx).alu_sel_rng_chk_lookup = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -142,9 +142,9 @@ TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) class AvmRangeCheckNegativeTests : public AvmInterTableTests { protected: std::vector trace; - size_t main_addr; - size_t mem_addr; - size_t alu_addr; + size_t main_row_idx; + size_t mem_row_idx; + size_t alu_row_idx; void genTraceAdd( uint128_t const& a, uint128_t const& b, uint128_t const& c, AvmMemoryTag tag, uint32_t min_trace_size = 0) @@ -174,9 +174,9 @@ class AvmRangeCheckNegativeTests : public AvmInterTableTests { }); ASSERT_TRUE(mem_row != trace.end()); - main_addr = static_cast(row - trace.begin()); - alu_addr = static_cast(alu_row - trace.begin()); - mem_addr = static_cast(mem_row - trace.begin()); + main_row_idx = static_cast(row - trace.begin()); + alu_row_idx = static_cast(alu_row - trace.begin()); + mem_row_idx = static_cast(mem_row - trace.begin()); }; }; @@ -191,9 +191,9 @@ TEST_F(AvmRangeCheckNegativeTests, additionU8Reg0) // All constraints except range checks on u8_r0, u8_r1 are satisfied. FF const fake_c = FF(15).add(-FF(2).pow(254)); - auto& row = trace.at(main_addr); - auto& mem_row = trace.at(mem_addr); - auto& alu_row = trace.at(alu_addr); + auto& row = trace.at(main_row_idx); + auto& mem_row = trace.at(mem_row_idx); + auto& alu_row = trace.at(alu_row_idx); row.main_ic = fake_c; mem_row.mem_val = fake_c; @@ -221,9 +221,9 @@ TEST_F(AvmRangeCheckNegativeTests, additionU8Reg0) TEST_F(AvmRangeCheckNegativeTests, additionU8Reg1) { genTraceAdd(19, 20, 39, AvmMemoryTag::U8); - auto& row = trace.at(main_addr); - auto& mem_row = trace.at(mem_addr); - auto& alu_row = trace.at(alu_addr); + auto& row = trace.at(main_row_idx); + auto& mem_row = trace.at(mem_row_idx); + auto& alu_row = trace.at(alu_row_idx); // a + b = u8_r0 + 2^8 * u8_r1 (mod p) // We recall that p-1 is a multiple of a large power of two. @@ -259,9 +259,9 @@ TEST_F(AvmRangeCheckNegativeTests, additionU8Reg1) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg0) { genTraceAdd(1200, 2000, 3200, AvmMemoryTag::U16, 130); - auto& row = trace.at(main_addr); - auto& mem_row = trace.at(mem_addr); - auto& alu_row = trace.at(alu_addr); + auto& row = trace.at(main_row_idx); + auto& mem_row = trace.at(mem_row_idx); + auto& alu_row = trace.at(alu_row_idx); // a + b = u8_r0 + 2^8 * u8_r1 + 2^16 * u16_r0 (mod p) // We recall that p-1 is a multiple of a large power of two. @@ -306,7 +306,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg7) genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); auto trace_original = trace; - auto& alu_row = trace.at(alu_addr); + auto& alu_row = trace.at(alu_row_idx); alu_row.alu_u16_r7 = FF(235655); auto trace_same_cnt = trace; @@ -323,7 +323,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg7) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg8) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_addr).alu_u16_r8 = FF(235655); + trace.at(alu_row_idx).alu_u16_r8 = FF(235655); trace.at(1).lookup_u16_8_counts -= FF(1); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_U16_8"); } @@ -332,7 +332,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg8) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg9) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_addr).alu_u16_r9 = FF(235655); + trace.at(alu_row_idx).alu_u16_r9 = FF(235655); trace.at(1).lookup_u16_9_counts -= FF(1); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_U16_9"); } @@ -341,7 +341,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg9) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg10) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_addr).alu_u16_r10 = FF(235655); + trace.at(alu_row_idx).alu_u16_r10 = FF(235655); trace.at(1).lookup_u16_10_counts -= FF(1); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_U16_10"); } @@ -350,7 +350,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg10) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg11) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_addr).alu_u16_r11 = FF(235655); + trace.at(alu_row_idx).alu_u16_r11 = FF(235655); trace.at(1).lookup_u16_11_counts -= FF(1); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_U16_11"); } @@ -359,7 +359,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg11) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg12) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_addr).alu_u16_r12 = FF(235655); + trace.at(alu_row_idx).alu_u16_r12 = FF(235655); trace.at(1).lookup_u16_12_counts -= FF(1); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_U16_12"); } @@ -368,7 +368,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg12) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg13) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_addr).alu_u16_r13 = FF(235655); + trace.at(alu_row_idx).alu_u16_r13 = FF(235655); trace.at(1).lookup_u16_13_counts -= FF(1); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_U16_13"); } @@ -377,7 +377,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg13) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg14) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_addr).alu_u16_r14 = FF(235655); + trace.at(alu_row_idx).alu_u16_r14 = FF(235655); trace.at(1).lookup_u16_14_counts -= FF(1); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_U16_14"); } @@ -388,11 +388,11 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg14) class AvmPermMainMemNegativeTests : public AvmInterTableTests { protected: std::vector trace; - size_t main_addr; - size_t mem_addr_a; - size_t mem_addr_b; - size_t mem_addr_c; - size_t alu_addr; + size_t main_row_idx; + size_t mem_a_row_idx; + size_t mem_b_row_idx; + size_t mem_c_row_idx; + size_t alu_row_idx; // Helper function to generate a trace with a subtraction // for c = a - b at arbitray chosen addresses 52 (a), 11 (b), 55 (c). @@ -433,11 +433,11 @@ class AvmPermMainMemNegativeTests : public AvmInterTableTests { }); ASSERT_TRUE(mem_row_b != trace.end()); - main_addr = static_cast(row - trace.begin()); - alu_addr = static_cast(alu_row - trace.begin()); - mem_addr_a = static_cast(mem_row_a - trace.begin()); - mem_addr_b = static_cast(mem_row_b - trace.begin()); - mem_addr_c = static_cast(mem_row_c - trace.begin()); + main_row_idx = static_cast(row - trace.begin()); + alu_row_idx = static_cast(alu_row - trace.begin()); + mem_a_row_idx = static_cast(mem_row_a - trace.begin()); + mem_b_row_idx = static_cast(mem_row_b - trace.begin()); + mem_c_row_idx = static_cast(mem_row_c - trace.begin()); } }; // Error tag propagation from memory trace back to the main trace. @@ -483,8 +483,8 @@ TEST_F(AvmPermMainMemNegativeTests, tagErrNotCopiedInMain) TEST_F(AvmPermMainMemNegativeTests, wrongValueIaInMem) { executeSub(21, 3); - trace.at(mem_addr_a).mem_val = 26; // Correct value: 21 - trace.at(mem_addr_a - 1).mem_val = 26; // We need to adjust the write operation beforehand (set opcode). + trace.at(mem_a_row_idx).mem_val = 26; // Correct value: 21 + trace.at(mem_a_row_idx - 1).mem_val = 26; // We need to adjust the write operation beforehand (set opcode). EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -492,8 +492,8 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIaInMem) TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) { executeSub(21, 3); - trace.at(mem_addr_b).mem_val = 7; // Correct value: 3 - trace.at(mem_addr_b - 1).mem_val = 7; // We need to adjust the write operation beforehand (set opcode). + trace.at(mem_b_row_idx).mem_val = 7; // Correct value: 3 + trace.at(mem_b_row_idx - 1).mem_val = 7; // We need to adjust the write operation beforehand (set opcode). EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -501,7 +501,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) { executeSub(21, 3); - trace.at(mem_addr_c).mem_val = 17; // Correct value: 18 = 21 - 3 + trace.at(mem_c_row_idx).mem_val = 17; // Correct value: 18 = 21 - 3 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -509,7 +509,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) { executeSub(21, 3); - trace.at(main_addr).main_mem_addr_a = 28; // Correct address: 52 + trace.at(main_row_idx).main_mem_addr_a = 28; // Correct address: 52 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -517,7 +517,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) { executeSub(21, 3); - trace.at(main_addr).main_mem_addr_b = 2; // Correct address: 11 + trace.at(main_row_idx).main_mem_addr_b = 2; // Correct address: 11 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -525,7 +525,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) TEST_F(AvmPermMainMemNegativeTests, wrongAddressIcInMain) { executeSub(21, 3); - trace.at(main_addr).main_mem_addr_c = 75; // Correct address: 55 + trace.at(main_row_idx).main_mem_addr_c = 75; // Correct address: 55 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -534,13 +534,13 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIaInMem) { executeSub(21, 3); auto wrong_in_tag = static_cast(AvmMemoryTag::U32); - trace.at(mem_addr_a).mem_r_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 - trace.at(mem_addr_a).mem_tag = wrong_in_tag; + trace.at(mem_a_row_idx).mem_r_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 + trace.at(mem_a_row_idx).mem_tag = wrong_in_tag; // We need to adjust the write operation beforehand (set opcode). - trace.at(mem_addr_a - 1).mem_r_in_tag = wrong_in_tag; - trace.at(mem_addr_a - 1).mem_w_in_tag = wrong_in_tag; - trace.at(mem_addr_a - 1).mem_tag = wrong_in_tag; + trace.at(mem_a_row_idx - 1).mem_r_in_tag = wrong_in_tag; + trace.at(mem_a_row_idx - 1).mem_w_in_tag = wrong_in_tag; + trace.at(mem_a_row_idx - 1).mem_tag = wrong_in_tag; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -549,13 +549,13 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIbInMem) { executeSub(21, 3); auto wrong_in_tag = static_cast(AvmMemoryTag::U16); - trace.at(mem_addr_b).mem_r_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 - trace.at(mem_addr_b).mem_tag = wrong_in_tag; + trace.at(mem_b_row_idx).mem_r_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 + trace.at(mem_b_row_idx).mem_tag = wrong_in_tag; // We need to adjust the write operation beforehand (set opcode). - trace.at(mem_addr_b - 1).mem_r_in_tag = wrong_in_tag; - trace.at(mem_addr_b - 1).mem_w_in_tag = wrong_in_tag; - trace.at(mem_addr_b - 1).mem_tag = wrong_in_tag; + trace.at(mem_b_row_idx - 1).mem_r_in_tag = wrong_in_tag; + trace.at(mem_b_row_idx - 1).mem_w_in_tag = wrong_in_tag; + trace.at(mem_b_row_idx - 1).mem_tag = wrong_in_tag; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -564,8 +564,8 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) { executeSub(21, 3); auto wrong_in_tag = static_cast(AvmMemoryTag::U128); - trace.at(mem_addr_c).mem_w_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 - trace.at(mem_addr_c).mem_tag = wrong_in_tag; + trace.at(mem_c_row_idx).mem_w_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 + trace.at(mem_c_row_idx).mem_tag = wrong_in_tag; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -573,15 +573,15 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) { executeSub(21, 3); - trace.at(mem_addr_a).mem_rw = 1; // Write instead of read. + trace.at(mem_a_row_idx).mem_rw = 1; // Write instead of read. // Adjust timestamp value - trace.at(mem_addr_a).mem_tsp += FF(AvmMemTraceBuilder::SUB_CLK_STORE_A - AvmMemTraceBuilder::SUB_CLK_LOAD_A); + trace.at(mem_a_row_idx).mem_tsp += FF(AvmMemTraceBuilder::SUB_CLK_STORE_A - AvmMemTraceBuilder::SUB_CLK_LOAD_A); // Adjust diff value of previous row as well - FF diff = trace.at(mem_addr_a - 1).mem_diff_lo + trace.at(mem_addr_a - 1).mem_diff_mid * FF(1 << 16) + + FF diff = trace.at(mem_a_row_idx - 1).mem_diff_lo + trace.at(mem_a_row_idx - 1).mem_diff_mid * FF(1 << 16) + FF(AvmMemTraceBuilder::SUB_CLK_STORE_A - AvmMemTraceBuilder::SUB_CLK_LOAD_A); - trace.at(mem_addr_a - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_addr_a - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + trace.at(mem_a_row_idx - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); + trace.at(mem_a_row_idx - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -589,15 +589,15 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) TEST_F(AvmPermMainMemNegativeTests, wrongRwIbInMem) { executeSub(21, 3); - trace.at(mem_addr_b).mem_rw = 1; // Write instead of read. + trace.at(mem_b_row_idx).mem_rw = 1; // Write instead of read. // Adjust timestamp value - trace.at(mem_addr_b).mem_tsp += FF(AvmMemTraceBuilder::SUB_CLK_STORE_B - AvmMemTraceBuilder::SUB_CLK_LOAD_B); + trace.at(mem_b_row_idx).mem_tsp += FF(AvmMemTraceBuilder::SUB_CLK_STORE_B - AvmMemTraceBuilder::SUB_CLK_LOAD_B); // Adjust diff value of previous row as well - FF diff = trace.at(mem_addr_b - 1).mem_diff_lo + trace.at(mem_addr_b - 1).mem_diff_mid * FF(1 << 16) + + FF diff = trace.at(mem_b_row_idx - 1).mem_diff_lo + trace.at(mem_b_row_idx - 1).mem_diff_mid * FF(1 << 16) + FF(AvmMemTraceBuilder::SUB_CLK_STORE_B - AvmMemTraceBuilder::SUB_CLK_LOAD_B); - trace.at(mem_addr_b - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_addr_b - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + trace.at(mem_b_row_idx - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); + trace.at(mem_b_row_idx - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -608,10 +608,10 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIcInMem) // a write for a read of Ic below leads to a violation that the memory // is initialized with zero values. executeSub(11, 11); - trace.at(mem_addr_c).mem_rw = 0; // Read instead of write. + trace.at(mem_c_row_idx).mem_rw = 0; // Read instead of write. // Adjust timestamp value. - trace.at(mem_addr_c).mem_tsp -= FF(AvmMemTraceBuilder::SUB_CLK_STORE_C - AvmMemTraceBuilder::SUB_CLK_LOAD_C); + trace.at(mem_c_row_idx).mem_tsp -= FF(AvmMemTraceBuilder::SUB_CLK_STORE_C - AvmMemTraceBuilder::SUB_CLK_LOAD_C); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -619,13 +619,13 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIcInMem) TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) { executeSub(87, 23); - trace.at(mem_addr_a).mem_clk += 3; - trace.at(mem_addr_a).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 3; + trace.at(mem_a_row_idx).mem_clk += 3; + trace.at(mem_a_row_idx).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 3; // Adjust diff value of previous row as well - FF diff = trace.at(mem_addr_a - 1).mem_diff_lo + trace.at(mem_addr_a - 1).mem_diff_mid * FF(1 << 16) + + FF diff = trace.at(mem_a_row_idx - 1).mem_diff_lo + trace.at(mem_a_row_idx - 1).mem_diff_mid * FF(1 << 16) + FF(AvmMemTraceBuilder::NUM_SUB_CLK * 3); - trace.at(mem_addr_a - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_addr_a - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + trace.at(mem_a_row_idx - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); + trace.at(mem_a_row_idx - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -633,12 +633,12 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) { executeSub(87, 23); - trace.at(mem_addr_b).mem_clk += 5; - trace.at(mem_addr_b).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 5; - FF diff = trace.at(mem_addr_b - 1).mem_diff_lo + trace.at(mem_addr_b - 1).mem_diff_mid * FF(1 << 16) + + trace.at(mem_b_row_idx).mem_clk += 5; + trace.at(mem_b_row_idx).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 5; + FF diff = trace.at(mem_b_row_idx - 1).mem_diff_lo + trace.at(mem_b_row_idx - 1).mem_diff_mid * FF(1 << 16) + FF(AvmMemTraceBuilder::NUM_SUB_CLK * 5); - trace.at(mem_addr_b - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_addr_b - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + trace.at(mem_b_row_idx - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); + trace.at(mem_b_row_idx - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -646,8 +646,8 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) TEST_F(AvmPermMainMemNegativeTests, wrongClkIcInMem) { executeSub(87, 23); - trace.at(mem_addr_c).mem_clk += 7; - trace.at(mem_addr_c).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 7; + trace.at(mem_c_row_idx).mem_clk += 7; + trace.at(mem_c_row_idx).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 7; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp index 94157443a75f..c7c8a21c794b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp @@ -7,8 +7,6 @@ #include #include -#define MEM_ROW_FIELD_EQ(field_name, expression) Field(#field_name, &Row::mem_##field_name, expression) - namespace tests_avm { using namespace bb; @@ -29,15 +27,15 @@ class AvmMemOpcodeTests : public ::testing::Test { protected: std::vector trace; - size_t main_addr; - size_t mem_a_addr; - size_t mem_b_addr; - size_t mem_c_addr; - size_t mem_d_addr; - size_t mem_ind_a_addr; - size_t mem_ind_b_addr; - size_t mem_ind_c_addr; - size_t mem_ind_d_addr; + size_t main_row_idx; + size_t mem_a_row_idx; + size_t mem_b_row_idx; + size_t mem_c_row_idx; + size_t mem_d_row_idx; + size_t mem_ind_a_row_idx; + size_t mem_ind_b_row_idx; + size_t mem_ind_c_row_idx; + size_t mem_ind_d_row_idx; void build_mov_trace(bool indirect, uint128_t const& val, @@ -84,14 +82,14 @@ class AvmMemOpcodeTests : public ::testing::Test { auto row = std::ranges::find_if(trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_LOAD_A)); ASSERT_TRUE(row != trace.end()); - mem_a_addr = static_cast(row - trace.begin()); + mem_a_row_idx = static_cast(row - trace.begin()); // Find the memory trace position of the indirect load for register ia. if (indirect) { row = std::ranges::find_if( trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_IND_LOAD_A)); ASSERT_TRUE(row != trace.end()); - mem_ind_a_addr = static_cast(row - trace.begin()); + mem_ind_a_row_idx = static_cast(row - trace.begin()); } } @@ -101,14 +99,14 @@ class AvmMemOpcodeTests : public ::testing::Test { auto row = std::ranges::find_if(trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_STORE_C)); ASSERT_TRUE(row != trace.end()); - mem_c_addr = static_cast(row - trace.begin()); + mem_c_row_idx = static_cast(row - trace.begin()); // Find the memory trace position of the indirect load for register ic. if (indirect) { row = std::ranges::find_if( trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_IND_LOAD_C)); ASSERT_TRUE(row != trace.end()); - mem_ind_c_addr = static_cast(row - trace.begin()); + mem_ind_c_row_idx = static_cast(row - trace.begin()); } } @@ -117,7 +115,7 @@ class AvmMemOpcodeTests : public ::testing::Test { // Find the first row enabling the MOV selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_mov == FF(1); }); ASSERT_TRUE(row != trace.end()); - main_addr = static_cast(row - trace.begin()); + main_row_idx = static_cast(row - trace.begin()); auto clk = row->main_clk; @@ -130,7 +128,7 @@ class AvmMemOpcodeTests : public ::testing::Test { // Find the first row enabling the CMOV selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_cmov == FF(1); }); ASSERT_TRUE(row != trace.end()); - main_addr = static_cast(row - trace.begin()); + main_row_idx = static_cast(row - trace.begin()); auto clk = row->main_clk; compute_index_a(clk, is_operand_indirect(indirect, 0)); @@ -139,27 +137,27 @@ class AvmMemOpcodeTests : public ::testing::Test { // Find the memory trace position corresponding to the load sub-operation of register ib. row = std::ranges::find_if(trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_LOAD_B)); ASSERT_TRUE(row != trace.end()); - mem_b_addr = static_cast(row - trace.begin()); + mem_b_row_idx = static_cast(row - trace.begin()); // Find the memory trace position of the indirect load for register ib. if (is_operand_indirect(indirect, 1)) { row = std::ranges::find_if( trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_IND_LOAD_B)); ASSERT_TRUE(row != trace.end()); - mem_ind_b_addr = static_cast(row - trace.begin()); + mem_ind_b_row_idx = static_cast(row - trace.begin()); } // Find the memory trace position corresponding to the load sub-operation of register id. row = std::ranges::find_if(trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_LOAD_D)); ASSERT_TRUE(row != trace.end()); - mem_d_addr = static_cast(row - trace.begin()); + mem_d_row_idx = static_cast(row - trace.begin()); // Find the memory trace position of the indirect load for register id. if (is_operand_indirect(indirect, 3)) { row = std::ranges::find_if( trace.begin(), trace.end(), gen_matcher(clk, AvmMemTraceBuilder::SUB_CLK_IND_LOAD_D)); ASSERT_TRUE(row != trace.end()); - mem_ind_d_addr = static_cast(row - trace.begin()); + mem_ind_d_row_idx = static_cast(row - trace.begin()); } } @@ -174,7 +172,7 @@ class AvmMemOpcodeTests : public ::testing::Test { { compute_mov_indices(indirect); FF const val_ff = uint256_t::from_uint128(val); - auto const& main_row = trace.at(main_addr); + auto const& main_row = trace.at(main_row_idx); if (indirect) { EXPECT_THAT( @@ -190,7 +188,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MAIN_ROW_FIELD_EQ(r_in_tag, static_cast(tag)), MAIN_ROW_FIELD_EQ(w_in_tag, static_cast(tag)))); - auto const& mem_a_row = trace.at(mem_a_addr); + auto const& mem_a_row = trace.at(mem_a_row_idx); EXPECT_THAT(mem_a_row, AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), @@ -202,7 +200,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MEM_ROW_FIELD_EQ(rw, 0), MEM_ROW_FIELD_EQ(sel_op_a, 1))); - auto const& mem_c_row = trace.at(mem_c_addr); + auto const& mem_c_row = trace.at(mem_c_row_idx); EXPECT_THAT(mem_c_row, AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), @@ -213,7 +211,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MEM_ROW_FIELD_EQ(sel_op_c, 1))); if (indirect) { - auto const& mem_ind_a_row = trace.at(mem_ind_a_addr); + auto const& mem_ind_a_row = trace.at(mem_ind_a_row_idx); EXPECT_THAT(mem_ind_a_row, AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U32)), @@ -224,7 +222,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MEM_ROW_FIELD_EQ(val, dir_src_offset), MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_a, 1))); - auto const& mem_ind_c_row = trace.at(mem_ind_c_addr); + auto const& mem_ind_c_row = trace.at(mem_ind_c_row_idx); EXPECT_THAT(mem_ind_c_row, AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U32)), @@ -254,7 +252,7 @@ class AvmMemOpcodeTests : public ::testing::Test { FF const& mov_val = mov_a ? a : b; FF const inv = mov_a ? d.invert() : 1; - EXPECT_THAT(trace.at(main_addr), + EXPECT_THAT(trace.at(main_row_idx), AllOf(MAIN_ROW_FIELD_EQ(ia, a), MAIN_ROW_FIELD_EQ(ib, b), MAIN_ROW_FIELD_EQ(ic, mov_val), @@ -282,7 +280,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MAIN_ROW_FIELD_EQ(w_in_tag, static_cast(mov_tag)), MAIN_ROW_FIELD_EQ(inv, inv))); - EXPECT_THAT(trace.at(mem_a_addr), + EXPECT_THAT(trace.at(mem_a_row_idx), AllOf(MEM_ROW_FIELD_EQ(r_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(w_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(tag, static_cast(tag_a)), @@ -294,7 +292,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MEM_ROW_FIELD_EQ(sel_op_a, 1), MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_a, 0))); - EXPECT_THAT(trace.at(mem_b_addr), + EXPECT_THAT(trace.at(mem_b_row_idx), AllOf(MEM_ROW_FIELD_EQ(r_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(w_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(tag, static_cast(tag_b)), @@ -307,7 +305,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MEM_ROW_FIELD_EQ(sel_op_b, 1), MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_b, 0))); - EXPECT_THAT(trace.at(mem_c_addr), + EXPECT_THAT(trace.at(mem_c_row_idx), AllOf(MEM_ROW_FIELD_EQ(r_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(w_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(tag, static_cast(mov_tag)), @@ -319,7 +317,7 @@ class AvmMemOpcodeTests : public ::testing::Test { MEM_ROW_FIELD_EQ(sel_op_c, 1), MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 0))); - EXPECT_THAT(trace.at(mem_d_addr), + EXPECT_THAT(trace.at(mem_d_row_idx), AllOf(MEM_ROW_FIELD_EQ(r_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(w_in_tag, static_cast(mov_tag)), MEM_ROW_FIELD_EQ(tag, static_cast(tag_d)), @@ -395,8 +393,8 @@ TEST_F(AvmMemOpcodeTests, indirectMovInvalidAddressTag) compute_mov_indices(true); - EXPECT_EQ(trace.at(main_addr).main_tag_err, 1); - EXPECT_THAT(trace.at(mem_ind_c_addr), + EXPECT_EQ(trace.at(main_row_idx).main_tag_err, 1); + EXPECT_THAT(trace.at(mem_ind_c_row_idx), AllOf(MEM_ROW_FIELD_EQ(tag_err, 1), MEM_ROW_FIELD_EQ(tag, static_cast(AvmMemoryTag::U128)), MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U32)), @@ -535,7 +533,7 @@ TEST_F(AvmMemOpcodeTests, directSet) MAIN_ROW_FIELD_EQ(rwc, 1), MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 0))); - EXPECT_THAT(trace.at(mem_c_addr), + EXPECT_THAT(trace.at(mem_c_row_idx), AllOf(MEM_ROW_FIELD_EQ(val, 5683), MEM_ROW_FIELD_EQ(addr, 99), MEM_ROW_FIELD_EQ(sel_op_c, 1), @@ -564,7 +562,7 @@ TEST_F(AvmMemOpcodeTests, indirectSet) MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1), MAIN_ROW_FIELD_EQ(ind_addr_c, 10))); - EXPECT_THAT(trace.at(mem_c_addr), + EXPECT_THAT(trace.at(mem_c_row_idx), AllOf(MEM_ROW_FIELD_EQ(val, 1979), MEM_ROW_FIELD_EQ(addr, 100), MEM_ROW_FIELD_EQ(sel_op_c, 1), @@ -573,7 +571,7 @@ TEST_F(AvmMemOpcodeTests, indirectSet) MEM_ROW_FIELD_EQ(w_in_tag, static_cast(AvmMemoryTag::U64)), MEM_ROW_FIELD_EQ(tag, static_cast(AvmMemoryTag::U64)))); - EXPECT_THAT(trace.at(mem_ind_c_addr), + EXPECT_THAT(trace.at(mem_ind_c_row_idx), AllOf(MEM_ROW_FIELD_EQ(val, 100), MEM_ROW_FIELD_EQ(addr, 10), MEM_ROW_FIELD_EQ(sel_op_c, 0), @@ -602,7 +600,7 @@ TEST_F(AvmMemOpcodeTests, indirectSetWrongTag) MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1), MAIN_ROW_FIELD_EQ(ind_addr_c, 10))); - EXPECT_THAT(trace.at(mem_ind_c_addr), + EXPECT_THAT(trace.at(mem_ind_c_row_idx), AllOf(MEM_ROW_FIELD_EQ(val, 100), MEM_ROW_FIELD_EQ(addr, 10), MEM_ROW_FIELD_EQ(sel_op_c, 0), @@ -629,7 +627,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputErrorTag) { build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(main_addr).main_tag_err = 1; + trace.at(main_row_idx).main_tag_err = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INCL_MEM_TAG_ERR"); } @@ -638,7 +636,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) { build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(main_addr).main_ic = 233; + trace.at(main_row_idx).main_ic = 233; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); } @@ -647,7 +645,7 @@ TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) { build_mov_trace(true, 8732, 23, 24, AvmMemoryTag::U16, 432, 876); compute_mov_indices(true); - trace.at(main_addr).main_ic = 8733; + trace.at(main_row_idx).main_ic = 8733; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); } @@ -667,14 +665,14 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagLoadIa) auto trace_tmp = trace; - trace.at(mem_a_addr).mem_r_in_tag = tag_u64; - trace.at(mem_a_addr).mem_tag_err = 1; - trace.at(mem_a_addr).mem_one_min_inv = one_min_inverse_diff; - trace.at(mem_c_addr).mem_tag = tag_u64; - trace.at(mem_c_addr).mem_w_in_tag = tag_u64; - trace.at(main_addr).main_r_in_tag = tag_u64; - trace.at(main_addr).main_w_in_tag = tag_u64; - trace.at(main_addr).main_tag_err = 1; + trace.at(mem_a_row_idx).mem_r_in_tag = tag_u64; + trace.at(mem_a_row_idx).mem_tag_err = 1; + trace.at(mem_a_row_idx).mem_one_min_inv = one_min_inverse_diff; + trace.at(mem_c_row_idx).mem_tag = tag_u64; + trace.at(mem_c_row_idx).mem_w_in_tag = tag_u64; + trace.at(main_row_idx).main_r_in_tag = tag_u64; + trace.at(main_row_idx).main_w_in_tag = tag_u64; + trace.at(main_row_idx).main_tag_err = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_TAG"); } @@ -690,17 +688,17 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagDisabledSelector) build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(mem_a_addr).mem_r_in_tag = tag_u64; - trace.at(mem_a_addr).mem_w_in_tag = tag_u64; - trace.at(mem_a_addr).mem_tag_err = 1; - trace.at(mem_a_addr).mem_one_min_inv = one_min_inverse_diff; - trace.at(mem_a_addr).mem_sel_mov_ia_to_ic = 0; - trace.at(mem_c_addr).mem_tag = tag_u64; - trace.at(mem_c_addr).mem_r_in_tag = tag_u64; - trace.at(mem_c_addr).mem_w_in_tag = tag_u64; - trace.at(main_addr).main_r_in_tag = tag_u64; - trace.at(main_addr).main_w_in_tag = tag_u64; - trace.at(main_addr).main_tag_err = 1; + trace.at(mem_a_row_idx).mem_r_in_tag = tag_u64; + trace.at(mem_a_row_idx).mem_w_in_tag = tag_u64; + trace.at(mem_a_row_idx).mem_tag_err = 1; + trace.at(mem_a_row_idx).mem_one_min_inv = one_min_inverse_diff; + trace.at(mem_a_row_idx).mem_sel_mov_ia_to_ic = 0; + trace.at(mem_c_row_idx).mem_tag = tag_u64; + trace.at(mem_c_row_idx).mem_r_in_tag = tag_u64; + trace.at(mem_c_row_idx).mem_w_in_tag = tag_u64; + trace.at(main_row_idx).main_r_in_tag = tag_u64; + trace.at(main_row_idx).main_w_in_tag = tag_u64; + trace.at(main_row_idx).main_tag_err = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -714,10 +712,10 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagInMainTrace) build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(mem_c_addr).mem_tag = tag_u64; - trace.at(mem_c_addr).mem_w_in_tag = tag_u64; - trace.at(main_addr).main_w_in_tag = tag_u64; - trace.at(main_addr).main_tag_err = 1; + trace.at(mem_c_row_idx).mem_tag = tag_u64; + trace.at(mem_c_row_idx).mem_w_in_tag = tag_u64; + trace.at(main_row_idx).main_w_in_tag = tag_u64; + trace.at(main_row_idx).main_tag_err = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_MAIN_SAME_TAG"); } @@ -730,8 +728,8 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagMainTraceRead) build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(mem_c_addr).mem_tag = tag_u64; - trace.at(mem_c_addr).mem_w_in_tag = tag_u64; + trace.at(mem_c_row_idx).mem_tag = tag_u64; + trace.at(mem_c_row_idx).mem_w_in_tag = tag_u64; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -743,7 +741,7 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovBInsteadA) { build_cmov_trace_neg_test(true); - trace.at(main_addr).main_ic = 1980; + trace.at(main_row_idx).main_ic = 1980; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); } @@ -751,7 +749,7 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovAInsteadB) { build_cmov_trace_neg_test(false); - trace.at(main_addr).main_ic = 1979; + trace.at(main_row_idx).main_ic = 1979; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_B"); } @@ -759,9 +757,9 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovAChangeTag) { build_cmov_trace_neg_test(true); - trace.at(mem_c_addr).mem_tag = static_cast(AvmMemoryTag::U32); - trace.at(mem_c_addr).mem_w_in_tag = static_cast(AvmMemoryTag::U32); - trace.at(main_addr).main_w_in_tag = static_cast(AvmMemoryTag::U32); + trace.at(mem_c_row_idx).mem_tag = static_cast(AvmMemoryTag::U32); + trace.at(mem_c_row_idx).mem_w_in_tag = static_cast(AvmMemoryTag::U32); + trace.at(main_row_idx).main_w_in_tag = static_cast(AvmMemoryTag::U32); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_MAIN_SAME_TAG"); } @@ -770,7 +768,7 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovASkipCheckAbuse) { build_cmov_trace_neg_test(true); - trace.at(mem_a_addr).mem_skip_check_tag = 1; + trace.at(mem_a_row_idx).mem_skip_check_tag = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SKIP_CHECK_TAG"); } @@ -779,8 +777,8 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovASkipCheckAbuseDisableSelMovA) { build_cmov_trace_neg_test(true); - trace.at(mem_a_addr).mem_skip_check_tag = 1; - trace.at(mem_a_addr).mem_sel_mov_ia_to_ic = 0; + trace.at(mem_a_row_idx).mem_skip_check_tag = 1; + trace.at(mem_a_row_idx).mem_sel_mov_ia_to_ic = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -789,8 +787,8 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovBSkipCheckAbuseDisableSelMovB) { build_cmov_trace_neg_test(false); - trace.at(mem_b_addr).mem_skip_check_tag = 1; - trace.at(mem_b_addr).mem_sel_mov_ib_to_ic = 0; + trace.at(mem_b_row_idx).mem_skip_check_tag = 1; + trace.at(mem_b_row_idx).mem_sel_mov_ib_to_ic = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_slice.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_slice.test.cpp new file mode 100644 index 000000000000..ed8c9a95d84c --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_slice.test.cpp @@ -0,0 +1,336 @@ +#include "avm_common.test.hpp" +#include "barretenberg/vm/avm_trace/avm_common.hpp" +#include "barretenberg/vm/tests/helpers.test.hpp" +#include +#include + +#include + +#define SLICE_ROW_FIELD_EQ(field_name, expression) Field(#field_name, &Row::slice_##field_name, expression) + +namespace tests_avm { + +using namespace bb; +using namespace bb::avm_trace; +using namespace testing; + +class AvmSliceTests : public ::testing::Test { + public: + AvmSliceTests() + : public_inputs(generate_base_public_inputs()) + , trace_builder(AvmTraceBuilder(public_inputs)) + { + srs::init_crs_factory("../srs_db/ignition"); + } + + void gen_trace_builder(std::vector const& calldata) + { + trace_builder = AvmTraceBuilder(public_inputs, {}, 0, calldata); + this->calldata = calldata; + } + + void gen_single_calldata_copy( + bool indirect, uint32_t cd_size, uint32_t cd_offset, uint32_t copy_size, uint32_t dst_offset) + { + ASSERT_LE(cd_offset + copy_size, cd_size); + std::vector calldata; + for (size_t i = 0; i < cd_size; i++) { + calldata.emplace_back(i * i); + } + + gen_trace_builder(calldata); + trace_builder.op_calldata_copy(static_cast(indirect), cd_offset, copy_size, dst_offset); + trace_builder.op_return(0, 0, 0); + trace = trace_builder.finalize(); + } + + void validate_single_calldata_copy_trace(uint32_t cd_offset, + uint32_t copy_size, + uint32_t dst_offset, + bool proof_verif = false) + { + // Find the first row enabling the calldata_copy selector + auto row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_calldata_copy == FF(1); }); + + ASSERT_TRUE(row != trace.end()); + + // Memory trace view pertaining to the calldata_copy operation. + auto clk = row->main_clk; + auto mem_view = std::views::filter(trace, [clk](Row r) { + return r.mem_clk == clk && r.mem_rw == 1 && r.mem_sel_op_cd_cpy == 1 && + r.mem_tag == static_cast(AvmMemoryTag::FF); + }); + + // Check that the memory operations are as expected. + size_t count = 0; + for (auto const& mem_row : mem_view) { + EXPECT_THAT(mem_row, + AllOf(MEM_ROW_FIELD_EQ(val, (cd_offset + count) * (cd_offset + count)), + MEM_ROW_FIELD_EQ(addr, dst_offset + count), + MEM_ROW_FIELD_EQ(tag, static_cast(AvmMemoryTag::FF)), + MEM_ROW_FIELD_EQ(w_in_tag, static_cast(AvmMemoryTag::FF)), + MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U0)), + MEM_ROW_FIELD_EQ(tag_err, 0))); + count++; + } + + EXPECT_EQ(count, copy_size); + + // Slice trace view pertaining to the calldata_copy operation. + auto slice_view = + std::views::filter(trace, [clk](Row r) { return r.slice_clk == clk && r.slice_sel_cd_cpy == 1; }); + + FF last_clk = 0; + + // Check that the slice trace is as expected. + count = 0; + for (auto const& slice_row : slice_view) { + EXPECT_THAT(slice_row, + AllOf(SLICE_ROW_FIELD_EQ(val, (cd_offset + count) * (cd_offset + count)), + SLICE_ROW_FIELD_EQ(addr, dst_offset + count), + SLICE_ROW_FIELD_EQ(cd_offset, cd_offset + count), + SLICE_ROW_FIELD_EQ(cnt, copy_size - count), + SLICE_ROW_FIELD_EQ(sel_start_cd_cpy, static_cast(count == 0)))); + count++; + + if (count == copy_size) { + last_clk = slice_row.main_clk; + } + } + + // Check that the extra final row is well-formed. + EXPECT_THAT(trace.at(static_cast(last_clk + 1)), + AllOf(SLICE_ROW_FIELD_EQ(addr, FF(dst_offset) + FF(copy_size)), + SLICE_ROW_FIELD_EQ(cd_offset, cd_offset + copy_size), + SLICE_ROW_FIELD_EQ(cnt, 0), + SLICE_ROW_FIELD_EQ(clk, 0), + SLICE_ROW_FIELD_EQ(sel_cd_cpy, 0), + SLICE_ROW_FIELD_EQ(sel_start_cd_cpy, 0))); + + if (proof_verif) { + validate_trace(std::move(trace), public_inputs, calldata, true); + } else { + validate_trace(std::move(trace), public_inputs, calldata); + } + } + + VmPublicInputs public_inputs; + AvmTraceBuilder trace_builder; + std::vector calldata; + + std::vector trace; + size_t main_row_idx; + size_t alu_row_idx; + size_t mem_row_idx; +}; + +TEST_F(AvmSliceTests, simpleCopyAllCDValues) +{ + gen_single_calldata_copy(false, 12, 0, 12, 25); + validate_single_calldata_copy_trace(0, 12, 25, true); +} + +TEST_F(AvmSliceTests, singleCopyCDElement) +{ + gen_single_calldata_copy(false, 12, 5, 1, 25); + validate_single_calldata_copy_trace(5, 1, 25); +} + +TEST_F(AvmSliceTests, longCopyAllCDValues) +{ + gen_single_calldata_copy(false, 2000, 0, 2000, 873); + validate_single_calldata_copy_trace(0, 2000, 873); +} + +TEST_F(AvmSliceTests, copyFirstHalfCDValues) +{ + gen_single_calldata_copy(false, 12, 0, 6, 98127); + validate_single_calldata_copy_trace(0, 6, 98127); +} + +TEST_F(AvmSliceTests, copySecondHalfCDValues) +{ + gen_single_calldata_copy(false, 12, 6, 6, 0); + validate_single_calldata_copy_trace(6, 6, 0); +} + +TEST_F(AvmSliceTests, copyToHighestMemOffset) +{ + gen_single_calldata_copy(false, 8, 2, 6, UINT32_MAX - 5); + validate_single_calldata_copy_trace(2, 6, UINT32_MAX - 5); +} + +TEST_F(AvmSliceTests, twoCallsNoOverlap) +{ + calldata = { 2, 3, 4, 5, 6 }; + + gen_trace_builder(calldata); + trace_builder.op_calldata_copy(0, 0, 2, 34); + trace_builder.op_calldata_copy(0, 3, 2, 2123); + trace_builder.op_return(0, 0, 0); + trace = trace_builder.finalize(); + + // Main trace views of rows enabling the calldata_copy selector + auto main_view = std::views::filter(trace, [](Row r) { return r.main_sel_op_calldata_copy == FF(1); }); + + std::vector main_rows; + for (auto const& row : main_view) { + main_rows.push_back(row); + } + + EXPECT_EQ(main_rows.size(), 2); + + EXPECT_THAT(main_rows.at(0), + AllOf(MAIN_ROW_FIELD_EQ(ia, 0), + MAIN_ROW_FIELD_EQ(ib, 2), + MAIN_ROW_FIELD_EQ(mem_addr_c, 34), + MAIN_ROW_FIELD_EQ(clk, 1))); + EXPECT_THAT(main_rows.at(1), + AllOf(MAIN_ROW_FIELD_EQ(ia, 3), + MAIN_ROW_FIELD_EQ(ib, 2), + MAIN_ROW_FIELD_EQ(mem_addr_c, 2123), + MAIN_ROW_FIELD_EQ(clk, 2))); + + validate_trace(std::move(trace), public_inputs, calldata); +} + +TEST_F(AvmSliceTests, indirectTwoCallsOverlap) +{ + calldata = { 2, 3, 4, 5, 6 }; + + gen_trace_builder(calldata); + trace_builder.op_set(0, 34, 100, AvmMemoryTag::U32); // indirect address 100 resolves to 34 + trace_builder.op_set(0, 2123, 101, AvmMemoryTag::U32); // indirect address 101 resolves to 2123 + trace_builder.op_calldata_copy(1, 1, 3, 100); + trace_builder.op_calldata_copy(1, 2, 3, 101); + trace_builder.op_return(0, 0, 0); + trace = trace_builder.finalize(); + + // Main trace views of rows enabling the calldata_copy selector + auto main_view = std::views::filter(trace, [](Row r) { return r.main_sel_op_calldata_copy == FF(1); }); + + std::vector main_rows; + for (auto const& row : main_view) { + main_rows.push_back(row); + } + + EXPECT_EQ(main_rows.size(), 2); + + EXPECT_THAT(main_rows.at(0), + AllOf(MAIN_ROW_FIELD_EQ(ia, 1), + MAIN_ROW_FIELD_EQ(ib, 3), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1), + MAIN_ROW_FIELD_EQ(ind_addr_c, 100), + MAIN_ROW_FIELD_EQ(mem_addr_c, 34), + MAIN_ROW_FIELD_EQ(clk, 3))); + EXPECT_THAT(main_rows.at(1), + AllOf(MAIN_ROW_FIELD_EQ(ia, 2), + MAIN_ROW_FIELD_EQ(ib, 3), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1), + MAIN_ROW_FIELD_EQ(ind_addr_c, 101), + MAIN_ROW_FIELD_EQ(mem_addr_c, 2123), + MAIN_ROW_FIELD_EQ(clk, 4))); + + validate_trace(std::move(trace), public_inputs, calldata); +} + +TEST_F(AvmSliceTests, indirectFailedResolution) +{ + calldata = { 2, 3, 4, 5, 6 }; + + gen_trace_builder(calldata); + trace_builder.op_set(0, 34, 100, AvmMemoryTag::U16); // indirect address 100 resolves to 34 + trace_builder.op_calldata_copy(1, 1, 3, 100); + trace_builder.halt(); + trace = trace_builder.finalize(); + + // Check that slice trace is empty + auto slice_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.slice_sel_cd_cpy == 1; }); + EXPECT_EQ(slice_row, trace.end()); + + auto count = std::ranges::count_if(trace.begin(), trace.end(), [](Row r) { return r.mem_sel_op_cd_cpy == 1; }); + // Check that MEM trace does not contain any entry related to calldata_copy write. + EXPECT_EQ(count, 0); + + // Find the first row enabling the calldata_copy selector + auto row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_calldata_copy == FF(1); }); + + ASSERT_TRUE(row != trace.end()); + auto clk = row->main_clk; + auto mem_row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { return r.mem_clk == clk; }); + + EXPECT_EQ(mem_row->mem_rw, 0); + EXPECT_EQ(mem_row->mem_sel_resolve_ind_addr_c, 1); + + validate_trace(std::move(trace), public_inputs, calldata); +} + +class AvmSliceNegativeTests : public AvmSliceTests {}; + +TEST_F(AvmSliceNegativeTests, wrongCDValueInSlice) +{ + gen_single_calldata_copy(false, 10, 0, 10, 0); + + trace.at(3).slice_val = 98; + + // Adapt corresponding MEM trace entry in a consistent way. + auto clk = trace.at(3).slice_clk; + auto addr = trace.at(3).slice_addr; + auto mem_row = std::ranges::find_if( + trace.begin(), trace.end(), [clk, addr](Row r) { return r.mem_clk == clk && r.mem_addr == addr; }); + mem_row->mem_val = 98; + + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_CD_VALUE"); +} + +TEST_F(AvmSliceNegativeTests, wrongCDValueInMemory) +{ + gen_single_calldata_copy(false, 10, 0, 10, 0); + + auto clk = trace.at(5).slice_clk; + auto addr = trace.at(5).slice_addr; + auto mem_row = std::ranges::find_if( + trace.begin(), trace.end(), [clk, addr](Row r) { return r.mem_clk == clk && r.mem_addr == addr; }); + mem_row->mem_val = 98; + + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_CD_MEM"); +} + +TEST_F(AvmSliceNegativeTests, wrongCDValueInCalldataColumn) +{ + gen_single_calldata_copy(false, 10, 0, 10, 0); + + trace.at(2).main_calldata = 12; + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOOKUP_CD_VALUE"); +} + +TEST_F(AvmSliceNegativeTests, wrongCDValueInCalldataVerifier) +{ + calldata = { 2, 3, 4, 5, 6 }; + + gen_trace_builder(calldata); + trace_builder.op_calldata_copy(0, 1, 3, 100); + trace_builder.op_return(0, 0, 0); + trace = trace_builder.finalize(); + + validate_trace(std::move(trace), public_inputs, { 2, 3, 4, 5, 7 }, true, true); +} + +TEST_F(AvmSliceNegativeTests, disableMemWriteEntry) +{ + gen_single_calldata_copy(false, 10, 0, 10, 0); + + // Multiple adjustements to get valid MEM trace. + trace.at(10).mem_sel_op_cd_cpy = 0; + trace.at(10).mem_sel_mem = 0; + trace.at(9).mem_last = 1; + trace.at(10).mem_last = 0; + trace.at(10).mem_tsp = 12; + trace.at(9).mem_sel_rng_chk = 0; + + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_CD_MEM"); +} + +} // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index d84f11226dec..5ffab2c65e2e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -37,7 +37,8 @@ void validate_trace_check_circuit(std::vector&& trace) void validate_trace(std::vector&& trace, VmPublicInputs const& public_inputs, std::vector const& calldata, - bool with_proof) + bool with_proof, + bool expect_proof_failure) { auto circuit_builder = AvmCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); @@ -55,7 +56,11 @@ void validate_trace(std::vector&& trace, bool verified = verifier.verify_proof(proof, { public_inputs_as_vec }); - EXPECT_TRUE(verified); + if (expect_proof_failure) { + EXPECT_FALSE(verified); + } else { + EXPECT_TRUE(verified); + } } }; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index e2c80155ada9..dc7982fe6ae2 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -15,6 +15,7 @@ } #define MAIN_ROW_FIELD_EQ(field_name, expression) Field(#field_name, &Row::main_##field_name, expression) +#define MEM_ROW_FIELD_EQ(field_name, expression) Field(#field_name, &Row::mem_##field_name, expression) namespace tests_avm { @@ -31,7 +32,8 @@ void validate_trace_check_circuit(std::vector&& trace); void validate_trace(std::vector&& trace, VmPublicInputs const& public_inputs = {}, std::vector const& calldata = {}, - bool with_proof = bb::avm_trace::ENABLE_PROVING); + bool with_proof = bb::avm_trace::ENABLE_PROVING, + bool expect_proof_failure = false); void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, FF const& newValue,