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..2fa6f61afe68 --- /dev/null +++ b/barretenberg/cpp/pil/avm/gadgets/mem_slice.pil @@ -0,0 +1,77 @@ +include "../main.pil"; + +namespace slice(256); + + pol commit clk; + + pol commit sel_start; // Selector to indicate the start of calldatacopy/return. Used in permutation with the main trace. + pol commit sel_cd_cpy; // Selector for any row involved in a callatacopy operation. + pol commit sel_return; // Selector for any row involved in a return operation. + pol commit sel_mem_active; // Selector for any row involved in a memory 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 col_offset; // Offset of the public column element. It is used to get the correct value from calldata/returndata. + pol commit one_min_inv; // Helper column to assert zero/non-zero equality of cnt; + + // We use a counter corresponding to the number of memory operations. The counter + // is initialized by copying the size argument from the main trace. The counter column + // is shared for CALLDATACOPY and RETURN opcodes. The counter is decreased until + // it reaches the value zero. Each row with a non-zero counter corresponds to + // a memory operation. The following relations ensure that exactly one operation + // selector sel_cd_cpy/sel_return is activated per row with a non-zero counter and + // that within a given operation the pertaining selector is enabled. (One prevents + // to activate sel_return during a callatacopy operation and vice-versa.) + + sel_mem_active = sel_cd_cpy + sel_return; + + // Instruction decomposition guarantees that sel_cd_cpy and sel_return are mutually exclusive on + // the first row of the calldatcopy/return operation. + + // Show that cnt != 0 <==> sel_mem_active == 1 + // one_min_inv == 1 - cnt^(-1) if cnt != 0 else == 0 + #[SLICE_CNT_ZERO_TEST1] + cnt * (1 - one_min_inv) - sel_mem_active = 0; + #[SLICE_CNT_ZERO_TEST2] + (1 - sel_mem_active) * one_min_inv = 0; + + #[SLICE_CNT_DECREMENT] + sel_mem_active * (cnt - 1 - cnt') = 0; + #[ADDR_INCREMENT] + sel_mem_active * (addr + 1 - addr') = 0; + #[COL_OFFSET_INCREMENT] + sel_mem_active * (col_offset + 1 - col_offset') = 0; + #[SAME_CLK] + sel_mem_active * (clk - clk') = 0; + #[SAME_SPACE_ID] + sel_mem_active * (space_id - space_id') = 0; + #[SAME_SEL_RETURN] + sel_mem_active * sel_mem_active' * (sel_return - sel_return') = 0; + #[SAME_SEL_CD_CPY] + sel_mem_active * sel_mem_active' * (sel_cd_cpy - sel_cd_cpy') = 0; + + #[SEL_MEM_INACTIVE] + (1 - sel_mem_active) * sel_mem_active' * (1 - sel_start') = 0; + + // The above relation is crucial to prevent a malicious prover of adding extra active rows + // after the row with cnt == 0 unless another operation starts (sel_start == 1). This relation + // implies that whenever sel_mem_active == 0 and sel_start' != 1, sel_mem_active' == 0. + // Note that the malicious prover can fill other columns such as clk or even sel_cd_cpy + // but as long sel_mem_active == 0, it does not lead to any memory operations. The latter + // is guarded by sel_mem_active in #[PERM_SLICE_MEM] below. + + #[LOOKUP_CD_VALUE] + sel_cd_cpy {col_offset, val} in main.sel_calldata {main.clk, main.calldata}; + + #[PERM_SLICE_MEM] + sel_mem_active {clk, space_id, addr, val, sel_cd_cpy} + is + mem.sel_op_slice {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw}; + + // Caution: sel_op_slice disables the tag check during a read. This is required for the RETURN opcode + // but could have bad consequences if one adds additional "read" operations as part of this gadget. + // In such a case, we have to disable tag check specifically for RETURN opcode. + + #[LOOKUP_RET_VALUE] + sel_return {col_offset, val} in main.sel_returndata {main.clk, main.returndata}; \ No newline at end of file diff --git a/barretenberg/cpp/pil/avm/main.pil b/barretenberg/cpp/pil/avm/main.pil index 7858269448b4..c498e242b814 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,9 @@ 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. + pol public returndata; + pol commit sel_returndata; // Selector used for lookup in returndata. TODO: Might be removed or made constant. //===== KERNEL INPUTS ========================================================= // Kernel lookup selector opcodes @@ -139,6 +143,10 @@ namespace main(256); pol commit sel_op_keccak; pol commit sel_op_pedersen; + //===== Memory Slice Gadget Selectors ========================================= + pol commit sel_op_calldata_copy; + pol commit sel_op_external_return; + //===== 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 +329,9 @@ 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; + sel_op_external_return * (1 - sel_op_external_return) = 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 +484,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 + sel_op_external_return; 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 +668,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_slice_gadget; // Selector to activate a slice gadget operation in the gadget (#[PERM_MAIN_SLICE]). + + // Activate only if tag_err is disabled + sel_slice_gadget = (sel_op_calldata_copy + sel_op_external_return) * (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 +742,11 @@ namespace main(256); is pedersen.sel_pedersen {pedersen.clk, pedersen.input}; + #[PERM_MAIN_SLICE] + sel_slice_gadget {clk, space_id, ia, ib, mem_addr_c, sel_op_calldata_copy, sel_op_external_return} + is + slice.sel_start {slice.clk, slice.space_id, slice.col_offset, slice.cnt, slice.addr, slice.sel_cd_cpy, slice.sel_return}; + #[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..781d2891add9 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/return memory operations triggered from memory slice gadget. + pol commit sel_op_slice; + // 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_slice * (1 - sel_op_slice) = 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_slice; // Maximum one memory operation enabled per row sel_mem * (sel_mem - 1) = 0; // TODO: might be infered by the main trace @@ -99,6 +104,12 @@ 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. Similarly return memory slice operations + // will have a sub_clk value of 4. + #[TIMESTAMP] tsp = NUM_SUB_CLK * clk + SUB_CLK; @@ -154,9 +165,10 @@ namespace mem(256); #[MEM_ZERO_INIT] lastAccess * (1 - rw') * val' = 0; - // Skip check tag + // TODO: Verfiy that skip_check_tag cannot be enabled maliciously by the prover. + // Skip check tag enabled for some MOV/CMOV opcodes and RETURN opcode (sel_op_slice) #[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)); + 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)) + sel_op_slice; // Memory tag consistency check for load operations, i.e., rw == 0. // We want to prove that r_in_tag == tag <==> tag_err == 0 @@ -207,6 +219,10 @@ namespace mem(256); sel_resolve_ind_addr_c * rw = 0; sel_resolve_ind_addr_d * rw = 0; + //====== CALLDATACOPY/RETURN specific constraints ================================== + sel_op_slice * (w_in_tag - 6) = 0; // Only write elements of type FF + sel_op_slice * (r_in_tag - 6) = 0; // Only read 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..60916f5b0433 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -10,6 +10,7 @@ [[maybe_unused]] auto kernel_kernel_side_effect_out = View(new_term.kernel_kernel_side_effect_out); \ [[maybe_unused]] auto kernel_kernel_metadata_out = View(new_term.kernel_kernel_metadata_out); \ [[maybe_unused]] auto main_calldata = View(new_term.main_calldata); \ + [[maybe_unused]] auto main_returndata = View(new_term.main_returndata); \ [[maybe_unused]] auto alu_a_hi = View(new_term.alu_a_hi); \ [[maybe_unused]] auto alu_a_lo = View(new_term.alu_a_lo); \ [[maybe_unused]] auto alu_b_hi = View(new_term.alu_b_hi); \ @@ -184,6 +185,7 @@ [[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_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); \ @@ -209,6 +212,7 @@ [[maybe_unused]] auto main_sel_op_emit_unencrypted_log = View(new_term.main_sel_op_emit_unencrypted_log); \ [[maybe_unused]] auto main_sel_op_eq = View(new_term.main_sel_op_eq); \ [[maybe_unused]] auto main_sel_op_external_call = View(new_term.main_sel_op_external_call); \ + [[maybe_unused]] auto main_sel_op_external_return = View(new_term.main_sel_op_external_return); \ [[maybe_unused]] auto main_sel_op_fdiv = View(new_term.main_sel_op_fdiv); \ [[maybe_unused]] auto main_sel_op_fee_per_da_gas = View(new_term.main_sel_op_fee_per_da_gas); \ [[maybe_unused]] auto main_sel_op_fee_per_l2_gas = View(new_term.main_sel_op_fee_per_l2_gas); \ @@ -251,8 +255,10 @@ [[maybe_unused]] auto main_sel_resolve_ind_addr_b = View(new_term.main_sel_resolve_ind_addr_b); \ [[maybe_unused]] auto main_sel_resolve_ind_addr_c = View(new_term.main_sel_resolve_ind_addr_c); \ [[maybe_unused]] auto main_sel_resolve_ind_addr_d = View(new_term.main_sel_resolve_ind_addr_d); \ + [[maybe_unused]] auto main_sel_returndata = View(new_term.main_sel_returndata); \ [[maybe_unused]] auto main_sel_rng_16 = View(new_term.main_sel_rng_16); \ [[maybe_unused]] auto main_sel_rng_8 = View(new_term.main_sel_rng_8); \ + [[maybe_unused]] auto main_sel_slice_gadget = View(new_term.main_sel_slice_gadget); \ [[maybe_unused]] auto main_space_id = View(new_term.main_space_id); \ [[maybe_unused]] auto main_tag_err = View(new_term.main_tag_err); \ [[maybe_unused]] auto main_w_in_tag = View(new_term.main_w_in_tag); \ @@ -275,6 +281,7 @@ [[maybe_unused]] auto mem_sel_op_c = View(new_term.mem_sel_op_c); \ [[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_op_slice = View(new_term.mem_sel_op_slice); \ [[maybe_unused]] auto mem_sel_resolve_ind_addr_a = View(new_term.mem_sel_resolve_ind_addr_a); \ [[maybe_unused]] auto mem_sel_resolve_ind_addr_b = View(new_term.mem_sel_resolve_ind_addr_b); \ [[maybe_unused]] auto mem_sel_resolve_ind_addr_c = View(new_term.mem_sel_resolve_ind_addr_c); \ @@ -301,11 +308,24 @@ [[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_clk = View(new_term.slice_clk); \ + [[maybe_unused]] auto slice_cnt = View(new_term.slice_cnt); \ + [[maybe_unused]] auto slice_col_offset = View(new_term.slice_col_offset); \ + [[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_mem_active = View(new_term.slice_sel_mem_active); \ + [[maybe_unused]] auto slice_sel_return = View(new_term.slice_sel_return); \ + [[maybe_unused]] auto slice_sel_start = View(new_term.slice_sel_start); \ + [[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_slice_mem = View(new_term.perm_slice_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_slice = View(new_term.perm_main_slice); \ [[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 +336,8 @@ [[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_ret_value = View(new_term.lookup_ret_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 +379,8 @@ [[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_ret_value_counts = View(new_term.lookup_ret_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 +492,13 @@ [[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_clk_shift = View(new_term.slice_clk_shift); \ + [[maybe_unused]] auto slice_cnt_shift = View(new_term.slice_cnt_shift); \ + [[maybe_unused]] auto slice_col_offset_shift = View(new_term.slice_col_offset_shift); \ + [[maybe_unused]] auto slice_sel_cd_cpy_shift = View(new_term.slice_sel_cd_cpy_shift); \ + [[maybe_unused]] auto slice_sel_mem_active_shift = View(new_term.slice_sel_mem_active_shift); \ + [[maybe_unused]] auto slice_sel_return_shift = View(new_term.slice_sel_return_shift); \ + [[maybe_unused]] auto slice_sel_start_shift = View(new_term.slice_sel_start_shift); \ + [[maybe_unused]] auto slice_space_id_shift = View(new_term.slice_space_id_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..86247444cf0c --- /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_col_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_col_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/lookup_ret_value.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_ret_value.hpp new file mode 100644 index 000000000000..7e341860cb99 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_ret_value.hpp @@ -0,0 +1,67 @@ +#pragma once + +#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" + +#include +#include + +namespace bb { + +class lookup_ret_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_return == 1 || in.main_sel_returndata == 1); + } + + template + static inline auto compute_inverse_exists(const AllEntities& in) + { + using View = typename Accumulator::View; + const auto is_operation = View(in.slice_sel_return); + const auto is_table_entry = View(in.main_sel_returndata); + 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_ret_value, + in.lookup_ret_value_counts, + in.slice_sel_return, + in.main_sel_returndata, + in.slice_col_offset, + in.slice_val, + in.main_clk, + in.main_returndata); + } + + template static inline auto get_nonconst_entities(AllEntities& in) + { + return std::forward_as_tuple(in.lookup_ret_value, + in.lookup_ret_value_counts, + in.slice_sel_return, + in.main_sel_returndata, + in.slice_col_offset, + in.slice_val, + in.main_clk, + in.main_returndata); + } +}; + +template +class lookup_ret_value_relation : public GenericLookupRelation { + public: + static constexpr const char* NAME = "lookup_ret_value"; +}; +template using lookup_ret_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..65065fe1f2dd 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp @@ -69,6 +69,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{}; @@ -81,6 +82,7 @@ template struct MainRow { FF main_sel_op_emit_unencrypted_log{}; FF main_sel_op_eq{}; FF main_sel_op_external_call{}; + FF main_sel_op_external_return{}; FF main_sel_op_fdiv{}; FF main_sel_op_fee_per_da_gas{}; FF main_sel_op_fee_per_l2_gas{}; @@ -123,6 +125,7 @@ template struct MainRow { FF main_sel_resolve_ind_addr_b{}; FF main_sel_resolve_ind_addr_c{}; FF main_sel_resolve_ind_addr_d{}; + FF main_sel_slice_gadget{}; FF main_space_id{}; FF main_tag_err{}; FF main_w_in_tag{}; @@ -139,99 +142,99 @@ inline std::string get_relation_label_main(int index) return "L2_GAS_INACTIVE"; case 5: return "DA_GAS_INACTIVE"; - case 75: + case 77: return "OUTPUT_U8"; - case 76: + case 78: return "SUBOP_FDIV"; - case 77: + case 79: return "SUBOP_FDIV_ZERO_ERR1"; - case 78: + case 80: return "SUBOP_FDIV_ZERO_ERR2"; - case 79: + case 81: return "SUBOP_FDIV_R_IN_TAG_FF"; - case 80: + case 82: return "SUBOP_FDIV_W_IN_TAG_FF"; - case 81: + case 83: return "SUBOP_ERROR_RELEVANT_OP"; - case 82: + case 84: return "KERNEL_INPUT_ACTIVE_CHECK"; - case 83: + case 85: return "KERNEL_OUTPUT_ACTIVE_CHECK"; - case 84: + case 86: return "PC_JUMP"; - case 85: + case 87: return "PC_JUMPI"; - case 86: + case 88: return "RETURN_POINTER_INCREMENT"; - case 92: + case 94: return "RETURN_POINTER_DECREMENT"; - case 98: + case 100: return "PC_INCREMENT"; - case 99: + case 101: return "INTERNAL_RETURN_POINTER_CONSISTENCY"; - case 100: + case 102: return "SPACE_ID_INTERNAL"; - case 101: + case 103: return "SPACE_ID_STANDARD_OPCODES"; - case 102: + case 104: return "CMOV_CONDITION_RES_1"; - case 103: + case 105: return "CMOV_CONDITION_RES_2"; - case 106: + case 108: return "MOV_SAME_VALUE_A"; - case 107: + case 109: return "MOV_SAME_VALUE_B"; - case 108: + case 110: return "MOV_MAIN_SAME_TAG"; - case 112: + case 114: return "L2GASLEFT"; - case 113: + case 115: return "DAGASLEFT"; - case 114: + case 116: return "ADDRESS_KERNEL"; - case 115: + case 117: return "STORAGE_ADDRESS_KERNEL"; - case 116: + case 118: return "SENDER_KERNEL"; - case 117: + case 119: return "FUNCTION_SELECTOR_KERNEL"; - case 118: + case 120: return "FEE_TRANSACTION_FEE_KERNEL"; - case 119: + case 121: return "CHAIN_ID_KERNEL"; - case 120: + case 122: return "VERSION_KERNEL"; - case 121: + case 123: return "BLOCK_NUMBER_KERNEL"; - case 122: + case 124: return "TIMESTAMP_KERNEL"; - case 123: + case 125: return "COINBASE_KERNEL"; - case 124: + case 126: return "FEE_DA_GAS_KERNEL"; - case 125: + case 127: return "FEE_L2_GAS_KERNEL"; - case 126: - return "NOTE_HASH_KERNEL_OUTPUT"; case 128: - return "EMIT_NOTE_HASH_KERNEL_OUTPUT"; + return "NOTE_HASH_KERNEL_OUTPUT"; case 130: + return "EMIT_NOTE_HASH_KERNEL_OUTPUT"; + case 132: return "NULLIFIER_EXISTS_KERNEL_OUTPUT"; - case 133: - return "EMIT_NULLIFIER_KERNEL_OUTPUT"; case 135: - return "L1_TO_L2_MSG_EXISTS_KERNEL_OUTPUT"; + return "EMIT_NULLIFIER_KERNEL_OUTPUT"; case 137: - return "EMIT_UNENCRYPTED_LOG_KERNEL_OUTPUT"; + return "L1_TO_L2_MSG_EXISTS_KERNEL_OUTPUT"; case 139: - return "EMIT_L2_TO_L1_MSGS_KERNEL_OUTPUT"; + return "EMIT_UNENCRYPTED_LOG_KERNEL_OUTPUT"; case 141: - return "SLOAD_KERNEL_OUTPUT"; + return "EMIT_L2_TO_L1_MSGS_KERNEL_OUTPUT"; case 143: + return "SLOAD_KERNEL_OUTPUT"; + case 145: return "SSTORE_KERNEL_OUTPUT"; - case 146: + case 149: return "BIN_SEL_1"; - case 147: + case 150: return "BIN_SEL_2"; } return std::to_string(index); @@ -241,11 +244,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, 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 +675,188 @@ 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_external_return * (-main_sel_op_external_return + 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_mov * (-main_sel_op_mov + 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_sel_op_cmov * (-main_sel_op_cmov + 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_op_err * (-main_op_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_tag_err * (-main_tag_err + 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_id_zero * (-main_id_zero + 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_a * (-main_sel_mem_op_a + 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_b * (-main_sel_mem_op_b + 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_c * (-main_sel_mem_op_c + 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_sel_mem_op_d * (-main_sel_mem_op_d + 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_rwa * (-main_rwa + 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_rwb * (-main_rwb + 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_rwc * (-main_rwc + 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_rwd * (-main_rwd + 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_a * (-main_sel_resolve_ind_addr_a + 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_b * (-main_sel_resolve_ind_addr_b + 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_c * (-main_sel_resolve_ind_addr_c + 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_resolve_ind_addr_d * (-main_sel_resolve_ind_addr_d + 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_eq + main_sel_op_lte) + main_sel_op_lt) * (main_w_in_tag - FF(1))); 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_op_err + FF(1))) * ((main_ic * main_ib) - main_ia)); 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_ib * main_inv) - FF(1)) + main_op_err)); 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_sel_op_div) * main_op_err) * (-main_inv + FF(1))); 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_r_in_tag - FF(6))); tmp *= scaling_factor; std::get<81>(evals) += tmp; } // Contribution 82 { Avm_DECLARE_VIEWS(82); + auto tmp = (main_sel_op_fdiv * (main_w_in_tag - FF(6))); + tmp *= scaling_factor; + std::get<82>(evals) += tmp; + } + // Contribution 83 + { + Avm_DECLARE_VIEWS(83); + auto tmp = (main_op_err * ((main_sel_op_fdiv + main_sel_op_div) - FF(1))); + tmp *= scaling_factor; + std::get<83>(evals) += tmp; + } + // Contribution 84 + { + Avm_DECLARE_VIEWS(84); 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 +869,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<84>(evals) += tmp; } - // Contribution 83 + // Contribution 85 { - Avm_DECLARE_VIEWS(83); + Avm_DECLARE_VIEWS(85); 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,197 +882,182 @@ 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))))); - 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_jump * (main_pc_shift - main_ia)); 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_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<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_shift - (main_internal_return_ptr + FF(1)))); 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_internal_return_ptr - main_mem_addr_b)); 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_shift - main_ia)); 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_pc + FF(1)) - main_ib)); 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_rwb - 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_call * (main_sel_mem_op_b - 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_shift - (main_internal_return_ptr - FF(1)))); 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_internal_return_ptr - FF(1)) - main_mem_addr_a)); 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_pc_shift - main_ia)); 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_rwa); tmp *= scaling_factor; std::get<97>(evals) += tmp; } // Contribution 98 { Avm_DECLARE_VIEWS(98); - auto tmp = - ((((-main_sel_first + FF(1)) * (-main_sel_op_halt + FF(1))) * - (((((((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_pc_shift - (main_pc + FF(1)))); + auto tmp = (main_sel_op_internal_return * (main_sel_mem_op_a - 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)); + 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_external_return))) - + (((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<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))); + auto tmp = + ((((-main_sel_first + FF(1)) * (-main_sel_op_halt + FF(1))) * + ((((((((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_external_return))) * + (main_pc_shift - (main_pc + FF(1)))); tmp *= scaling_factor; std::get<100>(evals) += tmp; } @@ -1062,91 +1065,109 @@ template class mainImpl { { 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_call_ptr - main_space_id)); + ((-(((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<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)); + auto tmp = ((main_sel_op_internal_call + main_sel_op_internal_return) * (main_space_id - FF(255))); 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_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_external_return)) * + (main_call_ptr - main_space_id)); 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 * main_inv) - FF(1)) + main_id_zero)); 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_op_cmov + main_sel_op_jumpi) * main_id_zero) * (-main_inv + 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_ia_to_ic - (main_sel_op_mov + (main_sel_op_cmov * (-main_id_zero + FF(1))))); 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_ib_to_ic - (main_sel_op_cmov * main_id_zero)); 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_ia_to_ic * (main_ia - main_ic)); tmp *= scaling_factor; std::get<108>(evals) += tmp; } // Contribution 109 { Avm_DECLARE_VIEWS(109); + auto tmp = (main_sel_mov_ib_to_ic * (main_ib - main_ic)); + tmp *= scaling_factor; + std::get<109>(evals) += tmp; + } + // Contribution 110 + { + Avm_DECLARE_VIEWS(110); + auto tmp = ((main_sel_op_mov + main_sel_op_cmov) * (main_r_in_tag - main_w_in_tag)); + tmp *= scaling_factor; + std::get<110>(evals) += tmp; + } + // Contribution 111 + { + Avm_DECLARE_VIEWS(111); 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 +1180,11 @@ template class mainImpl { (-main_tag_err + FF(1))) * (-main_op_err + FF(1)))); tmp *= scaling_factor; - std::get<109>(evals) += tmp; + std::get<111>(evals) += tmp; } - // Contribution 110 + // Contribution 112 { - Avm_DECLARE_VIEWS(110); + Avm_DECLARE_VIEWS(112); 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 +1194,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)); - 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_cast * (main_alu_in_tag - main_w_in_tag)); 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_l2gasleft * (main_ia - main_l2_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_dagasleft * (main_ia - main_da_gas_remaining_shift)); 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_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_storage_address * (kernel_kernel_in_offset - FF(1))); 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_sender * kernel_kernel_in_offset); 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_function_selector * (kernel_kernel_in_offset - FF(2))); 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_transaction_fee * (kernel_kernel_in_offset - FF(39))); 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_chain_id * (kernel_kernel_in_offset - FF(28))); 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_version * (kernel_kernel_in_offset - FF(29))); 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_block_number * (kernel_kernel_in_offset - FF(30))); 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_timestamp * (kernel_kernel_in_offset - FF(31))); 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_coinbase * (kernel_kernel_in_offset - FF(32))); 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_da_gas * (kernel_kernel_in_offset - FF(34))); 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_fee_per_l2_gas * (kernel_kernel_in_offset - FF(35))); 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_op_note_hash_exists * + (kernel_kernel_out_offset - (kernel_note_hash_exist_write_offset + FF(0)))); 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_first * kernel_note_hash_exist_write_offset); 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_op_emit_note_hash * + (kernel_kernel_out_offset - (kernel_emit_note_hash_write_offset + FF(128)))); 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_first * kernel_emit_note_hash_write_offset); 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_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<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_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_first * kernel_nullifier_non_exists_write_offset); 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_op_emit_nullifier * + (kernel_kernel_out_offset - (kernel_emit_nullifier_write_offset + FF(144)))); 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_first * kernel_emit_nullifier_write_offset); 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_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<137>(evals) += tmp; } // Contribution 138 { Avm_DECLARE_VIEWS(138); - auto tmp = (main_sel_first * kernel_emit_unencrypted_log_write_offset); + auto tmp = (main_sel_first * kernel_l1_to_l2_msg_exists_write_offset); 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_op_emit_unencrypted_log * + (kernel_kernel_out_offset - (kernel_emit_unencrypted_log_write_offset + FF(162)))); 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_first * kernel_emit_unencrypted_log_write_offset); 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_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<141>(evals) += tmp; } // Contribution 142 { Avm_DECLARE_VIEWS(142); - auto tmp = (main_sel_first * kernel_sload_write_offset); + auto tmp = (main_sel_first * kernel_emit_l2_to_l1_msg_write_offset); 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_op_sload * (kernel_kernel_out_offset - (kernel_sload_write_offset + FF(96)))); 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_first * kernel_sload_write_offset); tmp *= scaling_factor; std::get<144>(evals) += tmp; } // Contribution 145 { Avm_DECLARE_VIEWS(145); + auto tmp = (main_sel_op_sstore * (kernel_kernel_out_offset - (kernel_sstore_write_offset + FF(64)))); + tmp *= scaling_factor; + std::get<145>(evals) += tmp; + } + // Contribution 146 + { + Avm_DECLARE_VIEWS(146); + auto tmp = (main_sel_first * kernel_sstore_write_offset); + tmp *= scaling_factor; + std::get<146>(evals) += tmp; + } + // Contribution 147 + { + Avm_DECLARE_VIEWS(147); 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 +1454,29 @@ 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<147>(evals) += tmp; } - // Contribution 146 + // Contribution 148 { - Avm_DECLARE_VIEWS(146); + Avm_DECLARE_VIEWS(148); + auto tmp = (main_sel_slice_gadget - + ((main_sel_op_calldata_copy + main_sel_op_external_return) * (-main_tag_err + FF(1)))); + tmp *= scaling_factor; + std::get<148>(evals) += tmp; + } + // Contribution 149 + { + Avm_DECLARE_VIEWS(149); 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<149>(evals) += tmp; } - // Contribution 147 + // Contribution 150 { - Avm_DECLARE_VIEWS(147); + Avm_DECLARE_VIEWS(150); 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<150>(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..31eba07d6ae9 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp @@ -30,6 +30,7 @@ template struct MemRow { FF mem_sel_op_c{}; FF mem_sel_op_cmov{}; FF mem_sel_op_d{}; + FF mem_sel_op_slice{}; FF mem_sel_resolve_ind_addr_a{}; FF mem_sel_resolve_ind_addr_b{}; FF mem_sel_resolve_ind_addr_c{}; @@ -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_slice * (-mem_sel_op_slice + 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_slice)); 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,184 @@ 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))))) + + mem_sel_op_slice)); 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_slice * (mem_w_in_tag - FF(6))); + tmp *= scaling_factor; + std::get<41>(evals) += tmp; + } + // Contribution 42 + { + Avm_DECLARE_VIEWS(42); + auto tmp = (mem_sel_op_slice * (mem_r_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..5ad94a5d5fa6 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem_slice.hpp @@ -0,0 +1,154 @@ +#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_clk{}; + FF slice_clk_shift{}; + FF slice_cnt{}; + FF slice_cnt_shift{}; + FF slice_col_offset{}; + FF slice_col_offset_shift{}; + FF slice_one_min_inv{}; + FF slice_sel_cd_cpy{}; + FF slice_sel_cd_cpy_shift{}; + FF slice_sel_mem_active{}; + FF slice_sel_mem_active_shift{}; + FF slice_sel_return{}; + FF slice_sel_return_shift{}; + FF slice_sel_start_shift{}; + FF slice_space_id{}; + FF slice_space_id_shift{}; +}; + +inline std::string get_relation_label_mem_slice(int index) +{ + switch (index) { + case 1: + return "SLICE_CNT_ZERO_TEST1"; + case 2: + return "SLICE_CNT_ZERO_TEST2"; + case 3: + return "SLICE_CNT_DECREMENT"; + case 4: + return "ADDR_INCREMENT"; + case 5: + return "COL_OFFSET_INCREMENT"; + case 6: + return "SAME_CLK"; + case 7: + return "SAME_SPACE_ID"; + case 8: + return "SAME_SEL_RETURN"; + case 9: + return "SAME_SEL_CD_CPY"; + case 10: + return "SEL_MEM_INACTIVE"; + } + return std::to_string(index); +} + +template class mem_sliceImpl { + public: + using FF = FF_; + + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4 }; + + 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_mem_active - (slice_sel_cd_cpy + slice_sel_return)); + tmp *= scaling_factor; + std::get<0>(evals) += tmp; + } + // Contribution 1 + { + Avm_DECLARE_VIEWS(1); + auto tmp = ((slice_cnt * (-slice_one_min_inv + FF(1))) - slice_sel_mem_active); + tmp *= scaling_factor; + std::get<1>(evals) += tmp; + } + // Contribution 2 + { + Avm_DECLARE_VIEWS(2); + auto tmp = ((-slice_sel_mem_active + FF(1)) * slice_one_min_inv); + tmp *= scaling_factor; + std::get<2>(evals) += tmp; + } + // Contribution 3 + { + Avm_DECLARE_VIEWS(3); + auto tmp = (slice_sel_mem_active * ((slice_cnt - FF(1)) - slice_cnt_shift)); + tmp *= scaling_factor; + std::get<3>(evals) += tmp; + } + // Contribution 4 + { + Avm_DECLARE_VIEWS(4); + auto tmp = (slice_sel_mem_active * ((slice_addr + FF(1)) - slice_addr_shift)); + tmp *= scaling_factor; + std::get<4>(evals) += tmp; + } + // Contribution 5 + { + Avm_DECLARE_VIEWS(5); + auto tmp = (slice_sel_mem_active * ((slice_col_offset + FF(1)) - slice_col_offset_shift)); + tmp *= scaling_factor; + std::get<5>(evals) += tmp; + } + // Contribution 6 + { + Avm_DECLARE_VIEWS(6); + auto tmp = (slice_sel_mem_active * (slice_clk - slice_clk_shift)); + tmp *= scaling_factor; + std::get<6>(evals) += tmp; + } + // Contribution 7 + { + Avm_DECLARE_VIEWS(7); + auto tmp = (slice_sel_mem_active * (slice_space_id - slice_space_id_shift)); + tmp *= scaling_factor; + std::get<7>(evals) += tmp; + } + // Contribution 8 + { + Avm_DECLARE_VIEWS(8); + auto tmp = + ((slice_sel_mem_active * slice_sel_mem_active_shift) * (slice_sel_return - slice_sel_return_shift)); + tmp *= scaling_factor; + std::get<8>(evals) += tmp; + } + // Contribution 9 + { + Avm_DECLARE_VIEWS(9); + auto tmp = + ((slice_sel_mem_active * slice_sel_mem_active_shift) * (slice_sel_cd_cpy - slice_sel_cd_cpy_shift)); + tmp *= scaling_factor; + std::get<9>(evals) += tmp; + } + // Contribution 10 + { + Avm_DECLARE_VIEWS(10); + auto tmp = + (((-slice_sel_mem_active + FF(1)) * slice_sel_mem_active_shift) * (-slice_sel_start_shift + FF(1))); + tmp *= scaling_factor; + std::get<10>(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..fa58cde51ec4 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cd_copy.hpp @@ -0,0 +1,64 @@ +#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 = 5; + + 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_clk, + in.main_space_id, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.slice_clk, + in.slice_space_id, + in.slice_col_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_clk, + in.main_space_id, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.slice_clk, + in.slice_space_id, + in.slice_col_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/relations/generated/avm/perm_main_return.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_return.hpp new file mode 100644 index 000000000000..7a9ab3ad5d39 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_return.hpp @@ -0,0 +1,106 @@ + + +#pragma once + +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" + +#include +#include + +namespace bb { + +class perm_main_return_permutation_settings { + public: + // This constant defines how many columns are bundled together to form each set. + constexpr static size_t COLUMNS_PER_SET = 5; + + /** + * @brief If this method returns true on a row of values, then the inverse polynomial at this index. Otherwise the + * value needs to be set to zero. + * + * @details If this is true then permutation takes place in this row + */ + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.main_sel_return_gadget == 1 || in.slice_sel_start_return == 1); + } + + /** + * @brief Get all the entities for the permutation when we don't need to update them + * + * @details The entities are returned as a tuple of references in the following order: + * - The entity/polynomial used to store the product of the inverse values + * - The entity/polynomial that switches on the subrelation of the permutation relation that ensures correctness of + * the inverse polynomial + * - The entity/polynomial that enables adding a tuple-generated value from the first set to the logderivative sum + * subrelation + * - The entity/polynomial that enables adding a tuple-generated value from the second set to the logderivative sum + * subrelation + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the first set (N.B. ORDER IS IMPORTANT!) + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the second set (N.B. ORDER IS IMPORTANT!) + * + * @return All the entities needed for the permutation + */ + + template static inline auto get_const_entities(const AllEntities& in) + { + + return std::forward_as_tuple(in.perm_main_return, + in.main_sel_return_gadget, + in.main_sel_return_gadget, + in.slice_sel_start_return, + in.main_clk, + in.main_space_id, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.slice_clk, + in.slice_space_id, + in.slice_col_offset, + in.slice_cnt, + in.slice_addr); + } + + /** + * @brief Get all the entities for the permutation when need to update them + * + * @details The entities are returned as a tuple of references in the following order: + * - The entity/polynomial used to store the product of the inverse values + * - The entity/polynomial that switches on the subrelation of the permutation relation that ensures correctness of + * the inverse polynomial + * - The entity/polynomial that enables adding a tuple-generated value from the first set to the logderivative sum + * subrelation + * - The entity/polynomial that enables adding a tuple-generated value from the second set to the logderivative sum + * subrelation + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the first set (N.B. ORDER IS IMPORTANT!) + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the second set (N.B. ORDER IS IMPORTANT!) + * + * @return All the entities needed for the permutation + */ + + template static inline auto get_nonconst_entities(AllEntities& in) + { + + return std::forward_as_tuple(in.perm_main_return, + in.main_sel_return_gadget, + in.main_sel_return_gadget, + in.slice_sel_start_return, + in.main_clk, + in.main_space_id, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.slice_clk, + in.slice_space_id, + in.slice_col_offset, + in.slice_cnt, + in.slice_addr); + } +}; + +template +using perm_main_return_relation = GenericPermutationRelation; +template using perm_main_return = GenericPermutation; + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_slice.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_slice.hpp new file mode 100644 index 000000000000..6297b546d918 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_slice.hpp @@ -0,0 +1,72 @@ +#pragma once + +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" + +#include +#include + +namespace bb { + +class perm_main_slice_permutation_settings { + public: + // This constant defines how many columns are bundled together to form each set. + constexpr static size_t COLUMNS_PER_SET = 7; + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.main_sel_slice_gadget == 1 || in.slice_sel_start == 1); + } + + template static inline auto get_const_entities(const AllEntities& in) + { + return std::forward_as_tuple(in.perm_main_slice, + in.main_sel_slice_gadget, + in.main_sel_slice_gadget, + in.slice_sel_start, + in.main_clk, + in.main_space_id, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.main_sel_op_calldata_copy, + in.main_sel_op_external_return, + in.slice_clk, + in.slice_space_id, + in.slice_col_offset, + in.slice_cnt, + in.slice_addr, + in.slice_sel_cd_cpy, + in.slice_sel_return); + } + + template static inline auto get_nonconst_entities(AllEntities& in) + { + return std::forward_as_tuple(in.perm_main_slice, + in.main_sel_slice_gadget, + in.main_sel_slice_gadget, + in.slice_sel_start, + in.main_clk, + in.main_space_id, + in.main_ia, + in.main_ib, + in.main_mem_addr_c, + in.main_sel_op_calldata_copy, + in.main_sel_op_external_return, + in.slice_clk, + in.slice_space_id, + in.slice_col_offset, + in.slice_cnt, + in.slice_addr, + in.slice_sel_cd_cpy, + in.slice_sel_return); + } +}; + +template +class perm_main_slice_relation : public GenericPermutationRelation { + public: + static constexpr const char* NAME = "perm_main_slice"; +}; +template using perm_main_slice = GenericPermutation; + +} // namespace bb \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_return_mem.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_return_mem.hpp new file mode 100644 index 000000000000..8b9c5f5ec1e0 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_return_mem.hpp @@ -0,0 +1,102 @@ + + +#pragma once + +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" + +#include +#include + +namespace bb { + +class perm_return_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; + + /** + * @brief If this method returns true on a row of values, then the inverse polynomial at this index. Otherwise the + * value needs to be set to zero. + * + * @details If this is true then permutation takes place in this row + */ + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.slice_sel_return == 1 || in.mem_sel_op_return == 1); + } + + /** + * @brief Get all the entities for the permutation when we don't need to update them + * + * @details The entities are returned as a tuple of references in the following order: + * - The entity/polynomial used to store the product of the inverse values + * - The entity/polynomial that switches on the subrelation of the permutation relation that ensures correctness of + * the inverse polynomial + * - The entity/polynomial that enables adding a tuple-generated value from the first set to the logderivative sum + * subrelation + * - The entity/polynomial that enables adding a tuple-generated value from the second set to the logderivative sum + * subrelation + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the first set (N.B. ORDER IS IMPORTANT!) + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the second set (N.B. ORDER IS IMPORTANT!) + * + * @return All the entities needed for the permutation + */ + + template static inline auto get_const_entities(const AllEntities& in) + { + + return std::forward_as_tuple(in.perm_return_mem, + in.slice_sel_return, + in.slice_sel_return, + in.mem_sel_op_return, + 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); + } + + /** + * @brief Get all the entities for the permutation when need to update them + * + * @details The entities are returned as a tuple of references in the following order: + * - The entity/polynomial used to store the product of the inverse values + * - The entity/polynomial that switches on the subrelation of the permutation relation that ensures correctness of + * the inverse polynomial + * - The entity/polynomial that enables adding a tuple-generated value from the first set to the logderivative sum + * subrelation + * - The entity/polynomial that enables adding a tuple-generated value from the second set to the logderivative sum + * subrelation + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the first set (N.B. ORDER IS IMPORTANT!) + * - A sequence of COLUMNS_PER_SET entities/polynomials that represent the second set (N.B. ORDER IS IMPORTANT!) + * + * @return All the entities needed for the permutation + */ + + template static inline auto get_nonconst_entities(AllEntities& in) + { + + return std::forward_as_tuple(in.perm_return_mem, + in.slice_sel_return, + in.slice_sel_return, + in.mem_sel_op_return, + 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 +using perm_return_mem_relation = GenericPermutationRelation; +template using perm_return_mem = GenericPermutation; + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_slice_mem.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_slice_mem.hpp new file mode 100644 index 000000000000..e0b871a779bf --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_slice_mem.hpp @@ -0,0 +1,64 @@ +#pragma once + +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" + +#include +#include + +namespace bb { + +class perm_slice_mem_permutation_settings { + public: + // This constant defines how many columns are bundled together to form each set. + constexpr static size_t COLUMNS_PER_SET = 5; + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.slice_sel_mem_active == 1 || in.mem_sel_op_slice == 1); + } + + template static inline auto get_const_entities(const AllEntities& in) + { + return std::forward_as_tuple(in.perm_slice_mem, + in.slice_sel_mem_active, + in.slice_sel_mem_active, + in.mem_sel_op_slice, + in.slice_clk, + in.slice_space_id, + in.slice_addr, + in.slice_val, + in.slice_sel_cd_cpy, + in.mem_clk, + in.mem_space_id, + in.mem_addr, + in.mem_val, + in.mem_rw); + } + + template static inline auto get_nonconst_entities(AllEntities& in) + { + return std::forward_as_tuple(in.perm_slice_mem, + in.slice_sel_mem_active, + in.slice_sel_mem_active, + in.mem_sel_op_slice, + in.slice_clk, + in.slice_space_id, + in.slice_addr, + in.slice_val, + in.slice_sel_cd_cpy, + in.mem_clk, + in.mem_space_id, + in.mem_addr, + in.mem_val, + in.mem_rw); + } +}; + +template +class perm_slice_mem_relation : public GenericPermutationRelation { + public: + static constexpr const char* NAME = "perm_slice_mem"; +}; +template using perm_slice_mem = GenericPermutation; + +} // namespace bb \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp index 8ba8765aa5cc..21401f2fe0a8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp @@ -78,10 +78,12 @@ std::tuple Execution::prove(std::vector public_inputs_vec; std::vector calldata; + std::vector returndata; std::vector raw_proof; // This can be made nicer using BB's serialize::read, probably. const auto public_inputs_offset = proof.begin(); const auto calldata_size_offset = public_inputs_offset + PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH; const auto calldata_offset = calldata_size_offset + 1; - const auto raw_proof_offset = calldata_offset + static_cast(uint64_t(*calldata_size_offset)); + const auto returndata_size_offset = calldata_offset + static_cast(uint64_t(*calldata_size_offset)); + const auto returndata_offset = returndata_size_offset + 1; + const auto raw_proof_offset = returndata_offset + static_cast(uint64_t(*returndata_size_offset)); std::copy(public_inputs_offset, calldata_size_offset, std::back_inserter(public_inputs_vec)); - std::copy(calldata_offset, raw_proof_offset, std::back_inserter(calldata)); + std::copy(calldata_offset, returndata_size_offset, std::back_inserter(calldata)); + std::copy(returndata_offset, raw_proof_offset, std::back_inserter(returndata)); std::copy(raw_proof_offset, proof.end(), std::back_inserter(raw_proof)); VmPublicInputs public_inputs = convert_public_inputs(public_inputs_vec); - std::vector> public_inputs_columns = copy_public_inputs_columns(public_inputs, calldata); + std::vector> public_inputs_columns = + copy_public_inputs_columns(public_inputs, calldata, returndata); return verifier.verify_proof(raw_proof, public_inputs_columns); } @@ -647,11 +654,14 @@ std::vector Execution::gen_trace(std::vector const& instructio break; } - case OpCode::REVERT: - trace_builder.op_revert(std::get(inst.operands.at(0)), - std::get(inst.operands.at(1)), - std::get(inst.operands.at(2))); + case OpCode::REVERT: { + auto ret = trace_builder.op_revert(std::get(inst.operands.at(0)), + std::get(inst.operands.at(1)), + std::get(inst.operands.at(2))); + returndata.insert(returndata.end(), ret.begin(), ret.end()); + break; + } // Misc case OpCode::DEBUGLOG: 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..82b730ad0171 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 { @@ -19,7 +18,6 @@ void log_avm_trace([[maybe_unused]] std::vector const& trace, [[maybe_unused]] size_t end, [[maybe_unused]] bool enable_selectors) { - /* info("Built circuit with ", trace.size(), " rows"); for (size_t i = beg; i < end; i++) { @@ -42,7 +40,6 @@ void log_avm_trace([[maybe_unused]] std::vector const& trace, info("m_lastAccess: ", trace.at(i).mem_lastAccess); info("m_last: ", trace.at(i).mem_last); - info("m_val_shift: ", trace.at(i).mem_val_shift); info("=======CONTROL_FLOW==================================================================="); info("pc: ", trace.at(i).main_pc); @@ -68,29 +65,31 @@ void log_avm_trace([[maybe_unused]] std::vector const& trace, info("last: ", trace.at(i).main_sel_last); info("=======MEM_OP_A======================================================================"); - info("mem_op_a: ", trace.at(i).main_mem_op_a); - info("mem_idx_a: ", trace.at(i).main_mem_idx_a); + info("mem_op_a: ", trace.at(i).main_sel_mem_op_a); + info("mem_addr_a: ", trace.at(i).main_mem_addr_a); info("rwa: ", trace.at(i).main_rwa); info("=======MEM_OP_B======================================================================"); - info("mem_op_b: ", trace.at(i).main_mem_op_b); - info("mem_idx_b: ", trace.at(i).main_mem_idx_b); + info("mem_op_b: ", trace.at(i).main_sel_mem_op_b); + info("mem_addr_b: ", trace.at(i).main_mem_addr_b); info("rwb: ", trace.at(i).main_rwb); info("=======MEM_OP_C======================================================================"); - info("mem_op_c: ", trace.at(i).main_mem_op_c); - info("mem_idx_c: ", trace.at(i).main_mem_idx_c); + info("mem_op_c: ", trace.at(i).main_sel_mem_op_c); + info("mem_addr_c: ", trace.at(i).main_mem_addr_c); info("rwc: ", trace.at(i).main_rwc); + + info("=======MEM_DIFF======================================================================"); info("diff_hi: ", trace.at(i).mem_diff_hi); info("diff_mid: ", trace.at(i).mem_diff_mid); info("diff_lo: ", trace.at(i).mem_diff_lo); info("=======GAS ACCOUNTING================================================================"); - info("opcode active: ", trace.at(i).main_gas_cost_active); + info("opcode active: ", trace.at(i).main_sel_mem_op_activate_gas); info("l2_gas_remaining: ", trace.at(i).main_l2_gas_remaining); info("da_gas_remaining: ", trace.at(i).main_da_gas_remaining); - info("l2_gas_op: ", trace.at(i).main_l2_gas_op); - info("da_gas_op: ", trace.at(i).main_da_gas_op); + info("l2_gas_op_cost: ", trace.at(i).main_l2_gas_op_cost); + info("da_gas_op_cost: ", trace.at(i).main_da_gas_op_cost); info("l2_out_of_gas: ", trace.at(i).main_l2_out_of_gas); info("da_out_of_gas: ", trace.at(i).main_da_out_of_gas); info("abs_l2_hi_rem_gas: ", trace.at(i).main_abs_l2_rem_gas_hi); @@ -105,11 +104,10 @@ void log_avm_trace([[maybe_unused]] std::vector const& trace, info("sel_op_mul: ", trace.at(i).main_sel_op_mul); info("sel_op_eq: ", trace.at(i).main_sel_op_eq); info("sel_op_not: ", trace.at(i).main_sel_op_not); - info("sel_op_sel_alu: ", trace.at(i).main_alu_sel); + info("sel_sel_alu: ", trace.at(i).main_sel_alu); } info("\n"); } - */ } void dump_trace_as_csv(std::vector const& trace, std::filesystem::path const& filename) @@ -137,7 +135,8 @@ bool is_operand_indirect(uint8_t ind_value, uint8_t operand_idx) } std::vector> copy_public_inputs_columns(VmPublicInputs const& public_inputs, - std::vector const& calldata) + std::vector const& calldata, + std::vector const& returndata) { // We convert to a vector as the pil generated verifier is generic and unaware of the KERNEL_INPUTS_LENGTH // For each of the public input vectors @@ -156,11 +155,14 @@ std::vector> copy_public_inputs_columns(VmPublicInputs const& pu assert(public_inputs_kernel_side_effect_outputs.size() == KERNEL_OUTPUTS_LENGTH); assert(public_inputs_kernel_metadata_outputs.size() == KERNEL_OUTPUTS_LENGTH); - return { std::move(public_inputs_kernel_inputs), - std::move(public_inputs_kernel_value_outputs), - std::move(public_inputs_kernel_side_effect_outputs), - std::move(public_inputs_kernel_metadata_outputs), - calldata }; + return { + std::move(public_inputs_kernel_inputs), + std::move(public_inputs_kernel_value_outputs), + std::move(public_inputs_kernel_side_effect_outputs), + std::move(public_inputs_kernel_metadata_outputs), + calldata, + returndata, + }; } } // namespace bb::avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.hpp index d982ee258a97..aadc0dba1174 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.hpp @@ -13,10 +13,12 @@ void dump_trace_as_csv(const std::vector& trace, const std::filesystem::pat bool is_operand_indirect(uint8_t ind_value, uint8_t operand_idx); // Copy Public Input Columns -// There are 4 public input columns, one for inputs, and 3 for the kernel outputs {value, side effect counter, metadata} -// The verifier is generic, and so accepts vectors of these values rather than the fixed length arrays that are used -// during circuit building. This method copies each array into a vector to be used by the verifier. +// There are 5 public input columns, one for inputs, one for returndata and 3 for the kernel outputs +// {value, side effect counter, metadata}. The verifier is generic, and so accepts vectors of these values +// rather than the fixed length arrays that are used during circuit building. This method copies each array +// into a vector to be used by the verifier. std::vector> copy_public_inputs_columns(VmPublicInputs const& public_inputs, - std::vector const& calldata); + std::vector const& calldata, + std::vector const& returndata); } // namespace bb::avm_trace \ No newline at end of file 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..e75aa34d2fde 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_slice) { - 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_slice = m_sel_op_slice }); } // Memory operations need to be performed before the addition of the corresponding row in @@ -472,17 +473,63 @@ 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::FF, + AvmMemoryTag::FF, + true, + true); + } +} + +std::vector AvmMemTraceBuilder::read_return_opcode(uint32_t clk, + uint8_t space_id, + uint32_t direct_ret_offset, + uint32_t ret_size) +{ + std::vector returndata; + for (uint32_t i = 0; i < ret_size; i++) { + auto addr = direct_ret_offset + i; + auto& mem_space = memory.at(space_id); + FF val = mem_space.contains(addr) ? mem_space.at(addr).val : 0; + AvmMemoryTag tag = mem_space.contains(addr) ? mem_space.at(addr).tag : AvmMemoryTag::U0; + + // No tag checking is performed for RETURN opcode. + insert_in_mem_trace(space_id, + clk, + SUB_CLK_LOAD_A, // Specific re-use of this value for return read slice. + addr, + val, + tag, + AvmMemoryTag::FF, + AvmMemoryTag::FF, + false, + true); + + returndata.push_back(val); + } + return returndata; +} + bool AvmMemTraceBuilder::MemoryTraceEntry::operator<(const AvmMemTraceBuilder::MemoryTraceEntry& other) const { if (m_space_id < other.m_space_id) { @@ -514,4 +561,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..6f8af5a60e28 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_slice = false; /** * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. We sort first by @@ -88,6 +89,13 @@ 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); + std::vector read_return_opcode(uint32_t clk, uint8_t space_id, uint32_t direct_ret_offset, uint32_t ret_size); private: std::vector mem_trace; // Entries will be sorted by m_clk, m_sub_clk after finalize(). @@ -103,7 +111,8 @@ class AvmMemTraceBuilder { AvmMemoryTag m_tag, AvmMemoryTag r_in_tag, AvmMemoryTag w_in_tag, - bool m_rw); + bool m_rw, + bool m_sel_op_slice = false); void load_mismatch_tag_in_mem_trace(uint8_t space_id, uint32_t m_clk, @@ -128,5 +137,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..eee16a419a10 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,50 @@ 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 - - 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; + auto clk = static_cast(main_trace.size()) + 1; - // Storing from Ib - mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IB, mem_addr_b, ib, AvmMemoryTag::U0, AvmMemoryTag::FF); - } + uint32_t direct_dst_offset = dst_offset; // Will be overwritten in indirect mode. - 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; + bool indirect_flag = false; + bool tag_match = true; - // Storing from Ic - mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IC, mem_addr_c, ic, AvmMemoryTag::U0, AvmMemoryTag::FF); - } + // 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. - // Constrain gas cost on the first row - if (pos == 0) { - gas_trace_builder.constrain_gas_lookup(clk, OpCode::CALLDATACOPY); - } - - 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_r_in_tag = static_cast(AvmMemoryTag::FF), + .main_sel_op_calldata_copy = 1, + .main_sel_resolve_ind_addr_c = static_cast(indirect_flag), + .main_sel_slice_gadget = static_cast(tag_match), + .main_tag_err = static_cast(!tag_match), + .main_w_in_tag = static_cast(AvmMemoryTag::FF), + }); } /************************************************************************************************** @@ -2310,7 +2253,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 @@ -2839,110 +2781,52 @@ std::vector AvmTraceBuilder::op_return(uint8_t indirect, uint32_t ret_offset return {}; } - // We parallelize loading 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 ret_offset: - // ret_offset + pos: Ia memory load operation - // ret_offset + pos + 1: Ib memory load operation - // ret_offset + pos + 2: Ic memory load operation - // In indirect mode, ret_offset is first resolved by the first indirect load. + auto clk = static_cast(main_trace.size()) + 1; - uint32_t pos = 0; - std::vector returnMem; uint32_t direct_ret_offset = ret_offset; // Will be overwritten in indirect mode. - while (pos < ret_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); - auto clk = static_cast(main_trace.size()) + 1; - - uint32_t mem_op_a(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, ret_offset); - direct_ret_offset = uint32_t(ind_read.val); - tag_match = ind_read.tag_match; - } - - uint32_t mem_addr_a = direct_ret_offset + pos; - - // Reading and loading to Ia - auto read_a = mem_trace_builder.read_and_load_from_memory( - call_ptr, clk, IntermRegister::IA, mem_addr_a, AvmMemoryTag::FF, AvmMemoryTag::FF); - tag_match = tag_match && read_a.tag_match; - - FF ia = read_a.val; - returnMem.push_back(ia); - - if (ret_size - pos > 1) { - mem_op_b = 1; - mem_addr_b = direct_ret_offset + pos + 1; + bool indirect_flag = false; + bool tag_match = true; - // Reading and loading to Ib - auto read_b = mem_trace_builder.read_and_load_from_memory( - call_ptr, clk, IntermRegister::IB, mem_addr_b, AvmMemoryTag::FF, AvmMemoryTag::FF); - tag_match = tag_match && read_b.tag_match; - ib = read_b.val; - returnMem.push_back(ib); - } + // 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. - if (ret_size - pos > 2) { - mem_op_c = 1; - mem_addr_c = direct_ret_offset + pos + 2; + 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, ret_offset); + direct_ret_offset = uint32_t(ind_read.val); + tag_match = ind_read.tag_match; + } - // Reading and loading to Ic - auto read_c = mem_trace_builder.read_and_load_from_memory( - call_ptr, clk, IntermRegister::IC, mem_addr_c, AvmMemoryTag::FF, AvmMemoryTag::FF); - tag_match = tag_match && read_c.tag_match; - ic = read_c.val; - returnMem.push_back(ic); - } + if (tag_match) { + returndata = mem_trace_builder.read_return_opcode(clk, call_ptr, direct_ret_offset, ret_size); + slice_trace_builder.create_return_slice(returndata, clk, call_ptr, direct_ret_offset, ret_size); + } - // Constrain gas cost on the first row - if (pos == 0) { - gas_trace_builder.constrain_gas_lookup(clk, OpCode::RETURN); - } + // Constrain gas cost + gas_trace_builder.constrain_gas_lookup(clk, OpCode::RETURN); - 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(ret_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_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), - .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_op_halt = FF(1), - .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)), - }); + main_trace.push_back(Row{ + .main_clk = clk, + .main_call_ptr = call_ptr, + .main_ib = ret_size, + .main_ind_addr_c = indirect_flag ? ret_offset : 0, + .main_internal_return_ptr = FF(internal_return_ptr), + .main_mem_addr_c = direct_ret_offset, + .main_pc = pc, + .main_r_in_tag = static_cast(AvmMemoryTag::FF), + .main_sel_op_external_return = 1, + .main_sel_op_halt = 1, + .main_sel_resolve_ind_addr_c = static_cast(indirect_flag), + .main_sel_slice_gadget = static_cast(tag_match), + .main_tag_err = static_cast(!tag_match), + .main_w_in_tag = static_cast(AvmMemoryTag::FF), + }); - if (ret_size - pos > 2) { // Guard to prevent overflow if ret_size is close to uint32_t maximum value. - pos += 3; - } else { - pos = ret_size; - } - } pc = UINT32_MAX; // This ensures that no subsequent opcode will be executed. - return returnMem; + return returndata; } std::vector AvmTraceBuilder::op_revert(uint8_t indirect, uint32_t ret_offset, uint32_t ret_size) @@ -3407,11 +3291,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 +3349,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 +3742,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 +3754,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 +3766,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,45 +3813,51 @@ 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_slice = FF(static_cast(src.m_sel_op_slice)); 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/return memory operations are handled differently and are activated by m_sel_op_slice. + if (!src.m_sel_op_slice) { + 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) { - dest.mem_skip_check_tag = dest.mem_sel_op_d + dest.mem_sel_op_a * (-dest.mem_sel_mov_ia_to_ic + 1) + - dest.mem_sel_op_b * (-dest.mem_sel_mov_ib_to_ic + 1); + if (src.m_sel_cmov || src.m_sel_op_slice) { + dest.mem_skip_check_tag = + dest.mem_sel_op_cmov * (dest.mem_sel_op_d + dest.mem_sel_op_a * (-dest.mem_sel_mov_ia_to_ic + 1) + + dest.mem_sel_op_b * (-dest.mem_sel_mov_ib_to_ic + 1)) + + dest.mem_sel_op_slice; } if (i + 1 < mem_trace_size) { @@ -4208,6 +4102,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 +4549,26 @@ 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; + } + + // returndata column inclusion and selector + for (size_t i = 0; i < returndata.size(); i++) { + main_trace.at(i).main_returndata = returndata.at(i); + main_trace.at(i).main_sel_returndata = 1; + } + + // returndata loookup counts for return operations + for (auto const& [cd_offset, count] : slice_trace_builder.ret_lookup_counts) { + main_trace.at(cd_offset).lookup_ret_value_counts = count; } // Get tag_err counts from the mem_trace_builder @@ -4692,6 +4610,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..5ec749707034 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,8 +186,10 @@ class AvmTraceBuilder { AvmKeccakTraceBuilder keccak_trace_builder; AvmPedersenTraceBuilder pedersen_trace_builder; AvmEccTraceBuilder ecc_trace_builder; + AvmSliceTraceBuilder slice_trace_builder; std::vector calldata{}; + std::vector returndata{}; Row create_kernel_lookup_opcode( uint8_t indirect, uint32_t dst_offset, uint32_t selector, FF value, AvmMemoryTag w_tag); 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..5a71af4bf302 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.cpp @@ -0,0 +1,74 @@ +#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(); + ret_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 col_offset, + uint32_t copy_size, + uint32_t direct_dst_offset) +{ + create_slice(calldata, clk, space_id, col_offset, copy_size, direct_dst_offset, true); +} + +void AvmSliceTraceBuilder::create_return_slice( + std::vector const& returndata, uint32_t clk, uint8_t space_id, uint32_t direct_ret_offset, uint32_t ret_size) +{ + create_slice(returndata, clk, space_id, 0, ret_size, direct_ret_offset, false); +} + +void AvmSliceTraceBuilder::create_slice(std::vector const& col_data, + uint32_t clk, + uint8_t space_id, + uint32_t col_offset, + uint32_t copy_size, + uint32_t addr, + bool rw) +{ + for (uint32_t i = 0; i < copy_size; i++) { + slice_trace.push_back({ + .clk = clk, + .space_id = space_id, + .addr_ff = FF(addr + i), + .val = col_data.at(col_offset + i), + .col_offset = col_offset + i, + .cnt = copy_size - i, + .one_min_inv = FF(1) - FF(copy_size - i).invert(), + .sel_start = i == 0, + .sel_cd_cpy = rw, + .sel_return = !rw, + }); + + rw ? cd_lookup_counts[col_offset + i]++ : ret_lookup_counts[col_offset + i]++; + } + + // Last extra row for a slice operation. cnt is zero and we have to add extra dummy + // values for addr and col_offset to satisfy the constraints: #[ADDR_INCREMENT] and #[COL_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. + // col_offset is fine as the circuit trace cannot reach a size of 2^32. + slice_trace.emplace_back(SliceTraceEntry{ + .clk = clk, + .space_id = space_id, + .addr_ff = FF(addr + copy_size - 1) + 1, + .col_offset = col_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..b67666881b38 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_slice_trace.hpp @@ -0,0 +1,75 @@ +#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/returndata value is copied. + // column offset -> count + std::unordered_map cd_lookup_counts; + std::unordered_map ret_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/return operation + // row might be FF(2^32). + FF val{}; + uint32_t col_offset = 0; + uint32_t cnt = 0; + FF one_min_inv{}; + + bool sel_start = false; + bool sel_cd_cpy = false; + bool sel_return = 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 col_offset, + uint32_t copy_size, + uint32_t direct_dst_offset); + void create_return_slice(std::vector const& returndata, + uint32_t clk, + uint8_t space_id, + uint32_t direct_ret_offset, + uint32_t ret_size); + + private: + std::vector slice_trace; + void create_slice(std::vector const& col_data, + uint32_t clk, + uint8_t space_id, + uint32_t col_offset, + uint32_t copy_size, + uint32_t addr, + bool rw); +}; + +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_col_offset = src.col_offset; + dest.slice_cnt = src.cnt; + dest.slice_one_min_inv = src.one_min_inv; + dest.slice_sel_start = static_cast(src.sel_start); + dest.slice_sel_cd_cpy = static_cast(src.sel_cd_cpy); + dest.slice_sel_return = static_cast(src.sel_return); + dest.slice_sel_mem_active = static_cast(src.sel_return || 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..f39307155a5c --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp @@ -0,0 +1,853 @@ +#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", + "main_returndata", + "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_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_external_return", + "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_returndata", + "main_sel_rng_16", + "main_sel_rng_8", + "main_sel_slice_gadget", + "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_cmov", + "mem_sel_op_d", + "mem_sel_op_slice", + "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_clk", + "slice_cnt", + "slice_col_offset", + "slice_one_min_inv", + "slice_sel_cd_cpy", + "slice_sel_mem_active", + "slice_sel_return", + "slice_sel_start", + "slice_space_id", + "slice_val", + "perm_slice_mem", + "perm_main_alu", + "perm_main_bin", + "perm_main_conv", + "perm_main_pos2_perm", + "perm_main_pedersen", + "perm_main_slice", + "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_ret_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_ret_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.main_returndata) // + << "," << 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_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_external_return) // + << "," << 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_returndata) // + << "," << field_to_string(row.main_sel_rng_16) // + << "," << field_to_string(row.main_sel_rng_8) // + << "," << field_to_string(row.main_sel_slice_gadget) // + << "," << 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_cmov) // + << "," << field_to_string(row.mem_sel_op_d) // + << "," << field_to_string(row.mem_sel_op_slice) // + << "," << 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_clk) // + << "," << field_to_string(row.slice_cnt) // + << "," << field_to_string(row.slice_col_offset) // + << "," << field_to_string(row.slice_one_min_inv) // + << "," << field_to_string(row.slice_sel_cd_cpy) // + << "," << field_to_string(row.slice_sel_mem_active) // + << "," << field_to_string(row.slice_sel_return) // + << "," << field_to_string(row.slice_sel_start) // + << "," << field_to_string(row.slice_space_id) // + << "," << field_to_string(row.slice_val) // + << "," << field_to_string(row.perm_slice_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_slice) // + << "," << 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_ret_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_ret_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..9a2382b1d0fd 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 = 411; + static constexpr size_t num_polys = 411 + 74; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -53,6 +53,7 @@ class AvmCircuitBuilder { polys.kernel_kernel_side_effect_out[i] = rows[i].kernel_kernel_side_effect_out; polys.kernel_kernel_metadata_out[i] = rows[i].kernel_kernel_metadata_out; polys.main_calldata[i] = rows[i].main_calldata; + polys.main_returndata[i] = rows[i].main_returndata; polys.alu_a_hi[i] = rows[i].alu_a_hi; polys.alu_a_lo[i] = rows[i].alu_a_lo; polys.alu_b_hi[i] = rows[i].alu_b_hi; @@ -222,6 +223,7 @@ 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_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; @@ -247,6 +250,7 @@ class AvmCircuitBuilder { polys.main_sel_op_emit_unencrypted_log[i] = rows[i].main_sel_op_emit_unencrypted_log; polys.main_sel_op_eq[i] = rows[i].main_sel_op_eq; polys.main_sel_op_external_call[i] = rows[i].main_sel_op_external_call; + polys.main_sel_op_external_return[i] = rows[i].main_sel_op_external_return; polys.main_sel_op_fdiv[i] = rows[i].main_sel_op_fdiv; polys.main_sel_op_fee_per_da_gas[i] = rows[i].main_sel_op_fee_per_da_gas; polys.main_sel_op_fee_per_l2_gas[i] = rows[i].main_sel_op_fee_per_l2_gas; @@ -289,8 +293,10 @@ class AvmCircuitBuilder { polys.main_sel_resolve_ind_addr_b[i] = rows[i].main_sel_resolve_ind_addr_b; polys.main_sel_resolve_ind_addr_c[i] = rows[i].main_sel_resolve_ind_addr_c; polys.main_sel_resolve_ind_addr_d[i] = rows[i].main_sel_resolve_ind_addr_d; + polys.main_sel_returndata[i] = rows[i].main_sel_returndata; polys.main_sel_rng_16[i] = rows[i].main_sel_rng_16; polys.main_sel_rng_8[i] = rows[i].main_sel_rng_8; + polys.main_sel_slice_gadget[i] = rows[i].main_sel_slice_gadget; polys.main_space_id[i] = rows[i].main_space_id; polys.main_tag_err[i] = rows[i].main_tag_err; polys.main_w_in_tag[i] = rows[i].main_w_in_tag; @@ -313,6 +319,7 @@ class AvmCircuitBuilder { polys.mem_sel_op_c[i] = rows[i].mem_sel_op_c; 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_op_slice[i] = rows[i].mem_sel_op_slice; polys.mem_sel_resolve_ind_addr_a[i] = rows[i].mem_sel_resolve_ind_addr_a; polys.mem_sel_resolve_ind_addr_b[i] = rows[i].mem_sel_resolve_ind_addr_b; polys.mem_sel_resolve_ind_addr_c[i] = rows[i].mem_sel_resolve_ind_addr_c; @@ -339,8 +346,21 @@ 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_clk[i] = rows[i].slice_clk; + polys.slice_cnt[i] = rows[i].slice_cnt; + polys.slice_col_offset[i] = rows[i].slice_col_offset; + 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_mem_active[i] = rows[i].slice_sel_mem_active; + polys.slice_sel_return[i] = rows[i].slice_sel_return; + polys.slice_sel_start[i] = rows[i].slice_sel_start; + 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_ret_value_counts[i] = rows[i].lookup_ret_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 +473,15 @@ 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_clk_shift = Polynomial(polys.slice_clk.shifted()); + polys.slice_cnt_shift = Polynomial(polys.slice_cnt.shifted()); + polys.slice_col_offset_shift = Polynomial(polys.slice_col_offset.shifted()); + polys.slice_sel_cd_cpy_shift = Polynomial(polys.slice_sel_cd_cpy.shifted()); + polys.slice_sel_mem_active_shift = Polynomial(polys.slice_sel_mem_active.shifted()); + polys.slice_sel_return_shift = Polynomial(polys.slice_sel_return.shifted()); + polys.slice_sel_start_shift = Polynomial(polys.slice_sel_start.shifted()); + polys.slice_space_id_shift = Polynomial(polys.slice_space_id.shifted()); return polys; } @@ -552,6 +581,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 +603,9 @@ class AvmCircuitBuilder { }; // Check lookups + auto perm_slice_mem = [=]() { + return evaluate_logderivative.template operator()>("PERM_SLICE_MEM"); + }; auto perm_main_alu = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_ALU"); }; @@ -585,6 +621,9 @@ class AvmCircuitBuilder { auto perm_main_pedersen = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_PEDERSEN"); }; + auto perm_main_slice = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_SLICE"); + }; auto perm_main_mem_a = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_A"); }; @@ -620,6 +659,12 @@ class AvmCircuitBuilder { return evaluate_logderivative.template operator()>( "LOOKUP_BYTE_OPERATIONS"); }; + auto lookup_cd_value = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_CD_VALUE"); + }; + auto lookup_ret_value = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_RET_VALUE"); + }; auto lookup_opcode_gas = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_OPCODE_GAS"); }; @@ -757,15 +802,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_slice_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_slice)); 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 +824,8 @@ 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_ret_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 ae9c54f49c16..7ea67f9bfb65 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" @@ -49,6 +51,7 @@ #include "barretenberg/relations/generated/avm/lookup_opcode_gas.hpp" #include "barretenberg/relations/generated/avm/lookup_pow_2_0.hpp" #include "barretenberg/relations/generated/avm/lookup_pow_2_1.hpp" +#include "barretenberg/relations/generated/avm/lookup_ret_value.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_0.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_1.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_10.hpp" @@ -79,6 +82,8 @@ #include "barretenberg/relations/generated/avm/perm_main_mem_ind_addr_d.hpp" #include "barretenberg/relations/generated/avm/perm_main_pedersen.hpp" #include "barretenberg/relations/generated/avm/perm_main_pos2_perm.hpp" +#include "barretenberg/relations/generated/avm/perm_main_slice.hpp" +#include "barretenberg/relations/generated/avm/perm_slice_mem.hpp" #include "barretenberg/relations/generated/avm/range_check_da_gas_hi.hpp" #include "barretenberg/relations/generated/avm/range_check_da_gas_lo.hpp" #include "barretenberg/relations/generated/avm/range_check_l2_gas_hi.hpp" @@ -107,11 +112,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 = 409; 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 = 485; using MainRelations = std::tuple< // Relations @@ -123,6 +128,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 +136,13 @@ class AvmFlavor { using LookupRelations = std::tuple< // Lookups + perm_slice_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_slice_relation, perm_main_mem_a_relation, perm_main_mem_b_relation, perm_main_mem_c_relation, @@ -145,6 +153,8 @@ class AvmFlavor { perm_main_mem_ind_addr_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, + lookup_cd_value_relation, + lookup_ret_value_relation, lookup_opcode_gas_relation, range_check_l2_gas_hi_relation, range_check_l2_gas_lo_relation, @@ -224,6 +234,7 @@ class AvmFlavor { kernel_kernel_side_effect_out, kernel_kernel_metadata_out, main_calldata, + main_returndata, alu_a_hi, alu_a_lo, alu_b_hi, @@ -392,6 +403,7 @@ class AvmFlavor { main_rwd, main_sel_alu, main_sel_bin, + main_sel_calldata, main_sel_gas_accounting_active, main_sel_last, main_sel_mem_op_a, @@ -405,6 +417,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, @@ -417,6 +430,7 @@ class AvmFlavor { main_sel_op_emit_unencrypted_log, main_sel_op_eq, main_sel_op_external_call, + main_sel_op_external_return, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, @@ -459,8 +473,10 @@ class AvmFlavor { main_sel_resolve_ind_addr_b, main_sel_resolve_ind_addr_c, main_sel_resolve_ind_addr_d, + main_sel_returndata, main_sel_rng_16, main_sel_rng_8, + main_sel_slice_gadget, main_space_id, main_tag_err, main_w_in_tag, @@ -483,6 +499,7 @@ class AvmFlavor { mem_sel_op_c, mem_sel_op_cmov, mem_sel_op_d, + mem_sel_op_slice, mem_sel_resolve_ind_addr_a, mem_sel_resolve_ind_addr_b, mem_sel_resolve_ind_addr_c, @@ -509,8 +526,21 @@ class AvmFlavor { sha256_output, sha256_sel_sha256_compression, sha256_state, + slice_addr, + slice_clk, + slice_cnt, + slice_col_offset, + slice_one_min_inv, + slice_sel_cd_cpy, + slice_sel_mem_active, + slice_sel_return, + slice_sel_start, + slice_space_id, + slice_val, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_cd_value_counts, + lookup_ret_value_counts, lookup_opcode_gas_counts, range_check_l2_gas_hi_counts, range_check_l2_gas_lo_counts, @@ -555,11 +585,13 @@ class AvmFlavor { template class DerivedWitnessEntities { public: DEFINE_FLAVOR_MEMBERS(DataType, + perm_slice_mem, perm_main_alu, perm_main_bin, perm_main_conv, perm_main_pos2_perm, perm_main_pedersen, + perm_main_slice, perm_main_mem_a, perm_main_mem_b, perm_main_mem_c, @@ -570,6 +602,8 @@ class AvmFlavor { perm_main_mem_ind_addr_d, lookup_byte_lengths, lookup_byte_operations, + lookup_cd_value, + lookup_ret_value, lookup_opcode_gas, range_check_l2_gas_hi, range_check_l2_gas_lo, @@ -678,7 +712,16 @@ class AvmFlavor { mem_sel_mem_shift, mem_tag_shift, mem_tsp_shift, - mem_val_shift) + mem_val_shift, + slice_addr_shift, + slice_clk_shift, + slice_cnt_shift, + slice_col_offset_shift, + slice_sel_cd_cpy_shift, + slice_sel_mem_active_shift, + slice_sel_return_shift, + slice_sel_start_shift, + slice_space_id_shift) }; template @@ -748,7 +791,16 @@ class AvmFlavor { entities.mem_sel_mem, entities.mem_tag, entities.mem_tsp, - entities.mem_val }; + entities.mem_val, + entities.slice_addr, + entities.slice_clk, + entities.slice_cnt, + entities.slice_col_offset, + entities.slice_sel_cd_cpy, + entities.slice_sel_mem_active, + entities.slice_sel_return, + entities.slice_sel_start, + entities.slice_space_id }; } template @@ -849,7 +901,16 @@ class AvmFlavor { mem_sel_mem, mem_tag, mem_tsp, - mem_val }; + mem_val, + slice_addr, + slice_clk, + slice_cnt, + slice_col_offset, + slice_sel_cd_cpy, + slice_sel_mem_active, + slice_sel_return, + slice_sel_start, + slice_space_id }; } }; @@ -873,6 +934,7 @@ class AvmFlavor { kernel_kernel_side_effect_out, kernel_kernel_metadata_out, main_calldata, + main_returndata, alu_a_hi, alu_a_lo, alu_b_hi, @@ -1041,6 +1103,7 @@ class AvmFlavor { main_rwd, main_sel_alu, main_sel_bin, + main_sel_calldata, main_sel_gas_accounting_active, main_sel_last, main_sel_mem_op_a, @@ -1054,6 +1117,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, @@ -1066,6 +1130,7 @@ class AvmFlavor { main_sel_op_emit_unencrypted_log, main_sel_op_eq, main_sel_op_external_call, + main_sel_op_external_return, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, @@ -1108,8 +1173,10 @@ class AvmFlavor { main_sel_resolve_ind_addr_b, main_sel_resolve_ind_addr_c, main_sel_resolve_ind_addr_d, + main_sel_returndata, main_sel_rng_16, main_sel_rng_8, + main_sel_slice_gadget, main_space_id, main_tag_err, main_w_in_tag, @@ -1132,6 +1199,7 @@ class AvmFlavor { mem_sel_op_c, mem_sel_op_cmov, mem_sel_op_d, + mem_sel_op_slice, mem_sel_resolve_ind_addr_a, mem_sel_resolve_ind_addr_b, mem_sel_resolve_ind_addr_c, @@ -1158,11 +1226,24 @@ class AvmFlavor { sha256_output, sha256_sel_sha256_compression, sha256_state, + slice_addr, + slice_clk, + slice_cnt, + slice_col_offset, + slice_one_min_inv, + slice_sel_cd_cpy, + slice_sel_mem_active, + slice_sel_return, + slice_sel_start, + slice_space_id, + slice_val, + perm_slice_mem, perm_main_alu, perm_main_bin, perm_main_conv, perm_main_pos2_perm, perm_main_pedersen, + perm_main_slice, perm_main_mem_a, perm_main_mem_b, perm_main_mem_c, @@ -1173,6 +1254,8 @@ class AvmFlavor { perm_main_mem_ind_addr_d, lookup_byte_lengths, lookup_byte_operations, + lookup_cd_value, + lookup_ret_value, lookup_opcode_gas, range_check_l2_gas_hi, range_check_l2_gas_lo, @@ -1214,6 +1297,8 @@ class AvmFlavor { lookup_div_u16_7, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_cd_value_counts, + lookup_ret_value_counts, lookup_opcode_gas_counts, range_check_l2_gas_hi_counts, range_check_l2_gas_lo_counts, @@ -1317,9 +1402,18 @@ class AvmFlavor { mem_sel_mem_shift, mem_tag_shift, mem_tsp_shift, - mem_val_shift) + mem_val_shift, + slice_addr_shift, + slice_clk_shift, + slice_cnt_shift, + slice_col_offset_shift, + slice_sel_cd_cpy_shift, + slice_sel_mem_active_shift, + slice_sel_return_shift, + slice_sel_start_shift, + slice_space_id_shift) - AllConstRefValues(const RefArray& il) + AllConstRefValues(const RefArray& il) : main_clk(il[0]) , main_sel_first(il[1]) , kernel_kernel_inputs(il[2]) @@ -1327,451 +1421,484 @@ class AvmFlavor { , kernel_kernel_side_effect_out(il[4]) , kernel_kernel_metadata_out(il[5]) , main_calldata(il[6]) - , alu_a_hi(il[7]) - , alu_a_lo(il[8]) - , alu_b_hi(il[9]) - , alu_b_lo(il[10]) - , alu_borrow(il[11]) - , alu_cf(il[12]) - , alu_clk(il[13]) - , alu_cmp_rng_ctr(il[14]) - , alu_div_u16_r0(il[15]) - , alu_div_u16_r1(il[16]) - , alu_div_u16_r2(il[17]) - , alu_div_u16_r3(il[18]) - , alu_div_u16_r4(il[19]) - , alu_div_u16_r5(il[20]) - , alu_div_u16_r6(il[21]) - , alu_div_u16_r7(il[22]) - , alu_divisor_hi(il[23]) - , alu_divisor_lo(il[24]) - , alu_ff_tag(il[25]) - , alu_ia(il[26]) - , alu_ib(il[27]) - , alu_ic(il[28]) - , alu_in_tag(il[29]) - , alu_op_add(il[30]) - , alu_op_cast(il[31]) - , alu_op_cast_prev(il[32]) - , alu_op_div(il[33]) - , alu_op_div_a_lt_b(il[34]) - , alu_op_div_std(il[35]) - , alu_op_eq(il[36]) - , alu_op_eq_diff_inv(il[37]) - , alu_op_lt(il[38]) - , alu_op_lte(il[39]) - , alu_op_mul(il[40]) - , alu_op_not(il[41]) - , alu_op_shl(il[42]) - , alu_op_shr(il[43]) - , alu_op_sub(il[44]) - , alu_p_a_borrow(il[45]) - , alu_p_b_borrow(il[46]) - , alu_p_sub_a_hi(il[47]) - , alu_p_sub_a_lo(il[48]) - , alu_p_sub_b_hi(il[49]) - , alu_p_sub_b_lo(il[50]) - , alu_partial_prod_hi(il[51]) - , alu_partial_prod_lo(il[52]) - , alu_quotient_hi(il[53]) - , alu_quotient_lo(il[54]) - , alu_remainder(il[55]) - , alu_res_hi(il[56]) - , alu_res_lo(il[57]) - , alu_sel_alu(il[58]) - , alu_sel_cmp(il[59]) - , alu_sel_div_rng_chk(il[60]) - , alu_sel_rng_chk(il[61]) - , alu_sel_rng_chk_lookup(il[62]) - , alu_sel_shift_which(il[63]) - , alu_shift_lt_bit_len(il[64]) - , alu_t_sub_s_bits(il[65]) - , alu_two_pow_s(il[66]) - , alu_two_pow_t_sub_s(il[67]) - , alu_u128_tag(il[68]) - , alu_u16_r0(il[69]) - , alu_u16_r1(il[70]) - , alu_u16_r10(il[71]) - , alu_u16_r11(il[72]) - , alu_u16_r12(il[73]) - , alu_u16_r13(il[74]) - , alu_u16_r14(il[75]) - , alu_u16_r2(il[76]) - , alu_u16_r3(il[77]) - , alu_u16_r4(il[78]) - , alu_u16_r5(il[79]) - , alu_u16_r6(il[80]) - , alu_u16_r7(il[81]) - , alu_u16_r8(il[82]) - , alu_u16_r9(il[83]) - , alu_u16_tag(il[84]) - , alu_u32_tag(il[85]) - , alu_u64_tag(il[86]) - , alu_u8_r0(il[87]) - , alu_u8_r1(il[88]) - , alu_u8_tag(il[89]) - , binary_acc_ia(il[90]) - , binary_acc_ib(il[91]) - , binary_acc_ic(il[92]) - , binary_clk(il[93]) - , binary_ia_bytes(il[94]) - , binary_ib_bytes(il[95]) - , binary_ic_bytes(il[96]) - , binary_in_tag(il[97]) - , binary_mem_tag_ctr(il[98]) - , binary_mem_tag_ctr_inv(il[99]) - , binary_op_id(il[100]) - , binary_sel_bin(il[101]) - , binary_start(il[102]) - , byte_lookup_sel_bin(il[103]) - , byte_lookup_table_byte_lengths(il[104]) - , byte_lookup_table_in_tags(il[105]) - , byte_lookup_table_input_a(il[106]) - , byte_lookup_table_input_b(il[107]) - , byte_lookup_table_op_id(il[108]) - , byte_lookup_table_output(il[109]) - , conversion_clk(il[110]) - , conversion_input(il[111]) - , conversion_num_limbs(il[112]) - , conversion_radix(il[113]) - , conversion_sel_to_radix_le(il[114]) - , gas_da_gas_fixed_table(il[115]) - , gas_l2_gas_fixed_table(il[116]) - , gas_sel_gas_cost(il[117]) - , keccakf1600_clk(il[118]) - , keccakf1600_input(il[119]) - , keccakf1600_output(il[120]) - , keccakf1600_sel_keccakf1600(il[121]) - , kernel_emit_l2_to_l1_msg_write_offset(il[122]) - , kernel_emit_note_hash_write_offset(il[123]) - , kernel_emit_nullifier_write_offset(il[124]) - , kernel_emit_unencrypted_log_write_offset(il[125]) - , kernel_kernel_in_offset(il[126]) - , kernel_kernel_out_offset(il[127]) - , kernel_l1_to_l2_msg_exists_write_offset(il[128]) - , kernel_note_hash_exist_write_offset(il[129]) - , kernel_nullifier_exists_write_offset(il[130]) - , kernel_nullifier_non_exists_write_offset(il[131]) - , kernel_q_public_input_kernel_add_to_table(il[132]) - , kernel_q_public_input_kernel_out_add_to_table(il[133]) - , kernel_side_effect_counter(il[134]) - , kernel_sload_write_offset(il[135]) - , kernel_sstore_write_offset(il[136]) - , main_abs_da_rem_gas_hi(il[137]) - , main_abs_da_rem_gas_lo(il[138]) - , main_abs_l2_rem_gas_hi(il[139]) - , main_abs_l2_rem_gas_lo(il[140]) - , main_alu_in_tag(il[141]) - , main_bin_op_id(il[142]) - , main_call_ptr(il[143]) - , main_da_gas_op_cost(il[144]) - , main_da_gas_remaining(il[145]) - , main_da_out_of_gas(il[146]) - , main_ia(il[147]) - , main_ib(il[148]) - , main_ic(il[149]) - , main_id(il[150]) - , main_id_zero(il[151]) - , main_ind_addr_a(il[152]) - , main_ind_addr_b(il[153]) - , main_ind_addr_c(il[154]) - , main_ind_addr_d(il[155]) - , main_internal_return_ptr(il[156]) - , main_inv(il[157]) - , main_l2_gas_op_cost(il[158]) - , main_l2_gas_remaining(il[159]) - , main_l2_out_of_gas(il[160]) - , main_mem_addr_a(il[161]) - , main_mem_addr_b(il[162]) - , main_mem_addr_c(il[163]) - , main_mem_addr_d(il[164]) - , main_op_err(il[165]) - , main_opcode_val(il[166]) - , main_pc(il[167]) - , main_r_in_tag(il[168]) - , main_rwa(il[169]) - , main_rwb(il[170]) - , main_rwc(il[171]) - , main_rwd(il[172]) - , main_sel_alu(il[173]) - , main_sel_bin(il[174]) - , main_sel_gas_accounting_active(il[175]) - , main_sel_last(il[176]) - , main_sel_mem_op_a(il[177]) - , main_sel_mem_op_activate_gas(il[178]) - , main_sel_mem_op_b(il[179]) - , main_sel_mem_op_c(il[180]) - , main_sel_mem_op_d(il[181]) - , main_sel_mov_ia_to_ic(il[182]) - , main_sel_mov_ib_to_ic(il[183]) - , main_sel_op_add(il[184]) - , main_sel_op_address(il[185]) - , main_sel_op_and(il[186]) - , main_sel_op_block_number(il[187]) - , main_sel_op_cast(il[188]) - , main_sel_op_chain_id(il[189]) - , main_sel_op_cmov(il[190]) - , main_sel_op_coinbase(il[191]) - , main_sel_op_dagasleft(il[192]) - , main_sel_op_div(il[193]) - , main_sel_op_emit_l2_to_l1_msg(il[194]) - , main_sel_op_emit_note_hash(il[195]) - , main_sel_op_emit_nullifier(il[196]) - , main_sel_op_emit_unencrypted_log(il[197]) - , main_sel_op_eq(il[198]) - , main_sel_op_external_call(il[199]) - , main_sel_op_fdiv(il[200]) - , main_sel_op_fee_per_da_gas(il[201]) - , main_sel_op_fee_per_l2_gas(il[202]) - , main_sel_op_function_selector(il[203]) - , main_sel_op_get_contract_instance(il[204]) - , main_sel_op_halt(il[205]) - , main_sel_op_internal_call(il[206]) - , main_sel_op_internal_return(il[207]) - , main_sel_op_jump(il[208]) - , main_sel_op_jumpi(il[209]) - , main_sel_op_keccak(il[210]) - , main_sel_op_l1_to_l2_msg_exists(il[211]) - , main_sel_op_l2gasleft(il[212]) - , main_sel_op_lt(il[213]) - , main_sel_op_lte(il[214]) - , main_sel_op_mov(il[215]) - , main_sel_op_mul(il[216]) - , main_sel_op_not(il[217]) - , main_sel_op_note_hash_exists(il[218]) - , main_sel_op_nullifier_exists(il[219]) - , main_sel_op_or(il[220]) - , main_sel_op_pedersen(il[221]) - , main_sel_op_poseidon2(il[222]) - , main_sel_op_radix_le(il[223]) - , main_sel_op_sender(il[224]) - , main_sel_op_sha256(il[225]) - , main_sel_op_shl(il[226]) - , main_sel_op_shr(il[227]) - , main_sel_op_sload(il[228]) - , main_sel_op_sstore(il[229]) - , main_sel_op_storage_address(il[230]) - , main_sel_op_sub(il[231]) - , main_sel_op_timestamp(il[232]) - , main_sel_op_transaction_fee(il[233]) - , main_sel_op_version(il[234]) - , main_sel_op_xor(il[235]) - , main_sel_q_kernel_lookup(il[236]) - , main_sel_q_kernel_output_lookup(il[237]) - , main_sel_resolve_ind_addr_a(il[238]) - , main_sel_resolve_ind_addr_b(il[239]) - , main_sel_resolve_ind_addr_c(il[240]) - , main_sel_resolve_ind_addr_d(il[241]) - , main_sel_rng_16(il[242]) - , main_sel_rng_8(il[243]) - , main_space_id(il[244]) - , main_tag_err(il[245]) - , main_w_in_tag(il[246]) - , mem_addr(il[247]) - , mem_clk(il[248]) - , mem_diff_hi(il[249]) - , mem_diff_lo(il[250]) - , mem_diff_mid(il[251]) - , mem_glob_addr(il[252]) - , mem_last(il[253]) - , mem_lastAccess(il[254]) - , mem_one_min_inv(il[255]) - , mem_r_in_tag(il[256]) - , mem_rw(il[257]) - , mem_sel_mem(il[258]) - , mem_sel_mov_ia_to_ic(il[259]) - , mem_sel_mov_ib_to_ic(il[260]) - , mem_sel_op_a(il[261]) - , mem_sel_op_b(il[262]) - , mem_sel_op_c(il[263]) - , mem_sel_op_cmov(il[264]) - , mem_sel_op_d(il[265]) - , mem_sel_resolve_ind_addr_a(il[266]) - , mem_sel_resolve_ind_addr_b(il[267]) - , mem_sel_resolve_ind_addr_c(il[268]) - , mem_sel_resolve_ind_addr_d(il[269]) - , mem_sel_rng_chk(il[270]) - , mem_skip_check_tag(il[271]) - , mem_space_id(il[272]) - , mem_tag(il[273]) - , mem_tag_err(il[274]) - , mem_tsp(il[275]) - , mem_val(il[276]) - , mem_w_in_tag(il[277]) - , pedersen_clk(il[278]) - , pedersen_input(il[279]) - , pedersen_output(il[280]) - , pedersen_sel_pedersen(il[281]) - , poseidon2_clk(il[282]) - , poseidon2_input(il[283]) - , poseidon2_output(il[284]) - , poseidon2_sel_poseidon_perm(il[285]) - , powers_power_of_2(il[286]) - , sha256_clk(il[287]) - , sha256_input(il[288]) - , sha256_output(il[289]) - , sha256_sel_sha256_compression(il[290]) - , sha256_state(il[291]) - , perm_main_alu(il[292]) - , perm_main_bin(il[293]) - , perm_main_conv(il[294]) - , perm_main_pos2_perm(il[295]) - , perm_main_pedersen(il[296]) - , perm_main_mem_a(il[297]) - , perm_main_mem_b(il[298]) - , perm_main_mem_c(il[299]) - , perm_main_mem_d(il[300]) - , perm_main_mem_ind_addr_a(il[301]) - , perm_main_mem_ind_addr_b(il[302]) - , perm_main_mem_ind_addr_c(il[303]) - , perm_main_mem_ind_addr_d(il[304]) - , lookup_byte_lengths(il[305]) - , lookup_byte_operations(il[306]) - , lookup_opcode_gas(il[307]) - , range_check_l2_gas_hi(il[308]) - , range_check_l2_gas_lo(il[309]) - , range_check_da_gas_hi(il[310]) - , range_check_da_gas_lo(il[311]) - , kernel_output_lookup(il[312]) - , lookup_into_kernel(il[313]) - , incl_main_tag_err(il[314]) - , incl_mem_tag_err(il[315]) - , lookup_mem_rng_chk_lo(il[316]) - , lookup_mem_rng_chk_mid(il[317]) - , lookup_mem_rng_chk_hi(il[318]) - , lookup_pow_2_0(il[319]) - , lookup_pow_2_1(il[320]) - , lookup_u8_0(il[321]) - , lookup_u8_1(il[322]) - , lookup_u16_0(il[323]) - , lookup_u16_1(il[324]) - , lookup_u16_2(il[325]) - , lookup_u16_3(il[326]) - , lookup_u16_4(il[327]) - , lookup_u16_5(il[328]) - , lookup_u16_6(il[329]) - , lookup_u16_7(il[330]) - , lookup_u16_8(il[331]) - , lookup_u16_9(il[332]) - , lookup_u16_10(il[333]) - , lookup_u16_11(il[334]) - , lookup_u16_12(il[335]) - , lookup_u16_13(il[336]) - , lookup_u16_14(il[337]) - , lookup_div_u16_0(il[338]) - , lookup_div_u16_1(il[339]) - , lookup_div_u16_2(il[340]) - , lookup_div_u16_3(il[341]) - , lookup_div_u16_4(il[342]) - , lookup_div_u16_5(il[343]) - , lookup_div_u16_6(il[344]) - , lookup_div_u16_7(il[345]) - , lookup_byte_lengths_counts(il[346]) - , lookup_byte_operations_counts(il[347]) - , lookup_opcode_gas_counts(il[348]) - , range_check_l2_gas_hi_counts(il[349]) - , range_check_l2_gas_lo_counts(il[350]) - , range_check_da_gas_hi_counts(il[351]) - , range_check_da_gas_lo_counts(il[352]) - , kernel_output_lookup_counts(il[353]) - , lookup_into_kernel_counts(il[354]) - , incl_main_tag_err_counts(il[355]) - , incl_mem_tag_err_counts(il[356]) - , lookup_mem_rng_chk_lo_counts(il[357]) - , lookup_mem_rng_chk_mid_counts(il[358]) - , lookup_mem_rng_chk_hi_counts(il[359]) - , lookup_pow_2_0_counts(il[360]) - , lookup_pow_2_1_counts(il[361]) - , lookup_u8_0_counts(il[362]) - , lookup_u8_1_counts(il[363]) - , lookup_u16_0_counts(il[364]) - , lookup_u16_1_counts(il[365]) - , lookup_u16_2_counts(il[366]) - , lookup_u16_3_counts(il[367]) - , lookup_u16_4_counts(il[368]) - , lookup_u16_5_counts(il[369]) - , lookup_u16_6_counts(il[370]) - , lookup_u16_7_counts(il[371]) - , lookup_u16_8_counts(il[372]) - , lookup_u16_9_counts(il[373]) - , lookup_u16_10_counts(il[374]) - , lookup_u16_11_counts(il[375]) - , lookup_u16_12_counts(il[376]) - , lookup_u16_13_counts(il[377]) - , lookup_u16_14_counts(il[378]) - , lookup_div_u16_0_counts(il[379]) - , lookup_div_u16_1_counts(il[380]) - , lookup_div_u16_2_counts(il[381]) - , lookup_div_u16_3_counts(il[382]) - , lookup_div_u16_4_counts(il[383]) - , lookup_div_u16_5_counts(il[384]) - , lookup_div_u16_6_counts(il[385]) - , lookup_div_u16_7_counts(il[386]) - , alu_a_hi_shift(il[387]) - , alu_a_lo_shift(il[388]) - , alu_b_hi_shift(il[389]) - , alu_b_lo_shift(il[390]) - , alu_cmp_rng_ctr_shift(il[391]) - , alu_div_u16_r0_shift(il[392]) - , alu_div_u16_r1_shift(il[393]) - , alu_div_u16_r2_shift(il[394]) - , alu_div_u16_r3_shift(il[395]) - , alu_div_u16_r4_shift(il[396]) - , alu_div_u16_r5_shift(il[397]) - , alu_div_u16_r6_shift(il[398]) - , alu_div_u16_r7_shift(il[399]) - , alu_op_add_shift(il[400]) - , alu_op_cast_prev_shift(il[401]) - , alu_op_cast_shift(il[402]) - , alu_op_div_shift(il[403]) - , alu_op_mul_shift(il[404]) - , alu_op_shl_shift(il[405]) - , alu_op_shr_shift(il[406]) - , alu_op_sub_shift(il[407]) - , alu_p_sub_a_hi_shift(il[408]) - , alu_p_sub_a_lo_shift(il[409]) - , alu_p_sub_b_hi_shift(il[410]) - , alu_p_sub_b_lo_shift(il[411]) - , alu_sel_alu_shift(il[412]) - , alu_sel_cmp_shift(il[413]) - , alu_sel_div_rng_chk_shift(il[414]) - , alu_sel_rng_chk_lookup_shift(il[415]) - , alu_sel_rng_chk_shift(il[416]) - , alu_u16_r0_shift(il[417]) - , alu_u16_r1_shift(il[418]) - , alu_u16_r2_shift(il[419]) - , alu_u16_r3_shift(il[420]) - , alu_u16_r4_shift(il[421]) - , alu_u16_r5_shift(il[422]) - , alu_u16_r6_shift(il[423]) - , alu_u8_r0_shift(il[424]) - , alu_u8_r1_shift(il[425]) - , binary_acc_ia_shift(il[426]) - , binary_acc_ib_shift(il[427]) - , binary_acc_ic_shift(il[428]) - , binary_mem_tag_ctr_shift(il[429]) - , binary_op_id_shift(il[430]) - , kernel_emit_l2_to_l1_msg_write_offset_shift(il[431]) - , kernel_emit_note_hash_write_offset_shift(il[432]) - , kernel_emit_nullifier_write_offset_shift(il[433]) - , kernel_emit_unencrypted_log_write_offset_shift(il[434]) - , kernel_l1_to_l2_msg_exists_write_offset_shift(il[435]) - , kernel_note_hash_exist_write_offset_shift(il[436]) - , kernel_nullifier_exists_write_offset_shift(il[437]) - , kernel_nullifier_non_exists_write_offset_shift(il[438]) - , kernel_side_effect_counter_shift(il[439]) - , kernel_sload_write_offset_shift(il[440]) - , kernel_sstore_write_offset_shift(il[441]) - , main_da_gas_remaining_shift(il[442]) - , main_internal_return_ptr_shift(il[443]) - , main_l2_gas_remaining_shift(il[444]) - , main_pc_shift(il[445]) - , mem_glob_addr_shift(il[446]) - , mem_rw_shift(il[447]) - , mem_sel_mem_shift(il[448]) - , mem_tag_shift(il[449]) - , mem_tsp_shift(il[450]) - , mem_val_shift(il[451]) + , main_returndata(il[7]) + , alu_a_hi(il[8]) + , alu_a_lo(il[9]) + , alu_b_hi(il[10]) + , alu_b_lo(il[11]) + , alu_borrow(il[12]) + , alu_cf(il[13]) + , alu_clk(il[14]) + , alu_cmp_rng_ctr(il[15]) + , alu_div_u16_r0(il[16]) + , alu_div_u16_r1(il[17]) + , alu_div_u16_r2(il[18]) + , alu_div_u16_r3(il[19]) + , alu_div_u16_r4(il[20]) + , alu_div_u16_r5(il[21]) + , alu_div_u16_r6(il[22]) + , alu_div_u16_r7(il[23]) + , alu_divisor_hi(il[24]) + , alu_divisor_lo(il[25]) + , alu_ff_tag(il[26]) + , alu_ia(il[27]) + , alu_ib(il[28]) + , alu_ic(il[29]) + , alu_in_tag(il[30]) + , alu_op_add(il[31]) + , alu_op_cast(il[32]) + , alu_op_cast_prev(il[33]) + , alu_op_div(il[34]) + , alu_op_div_a_lt_b(il[35]) + , alu_op_div_std(il[36]) + , alu_op_eq(il[37]) + , alu_op_eq_diff_inv(il[38]) + , alu_op_lt(il[39]) + , alu_op_lte(il[40]) + , alu_op_mul(il[41]) + , alu_op_not(il[42]) + , alu_op_shl(il[43]) + , alu_op_shr(il[44]) + , alu_op_sub(il[45]) + , alu_p_a_borrow(il[46]) + , alu_p_b_borrow(il[47]) + , alu_p_sub_a_hi(il[48]) + , alu_p_sub_a_lo(il[49]) + , alu_p_sub_b_hi(il[50]) + , alu_p_sub_b_lo(il[51]) + , alu_partial_prod_hi(il[52]) + , alu_partial_prod_lo(il[53]) + , alu_quotient_hi(il[54]) + , alu_quotient_lo(il[55]) + , alu_remainder(il[56]) + , alu_res_hi(il[57]) + , alu_res_lo(il[58]) + , alu_sel_alu(il[59]) + , alu_sel_cmp(il[60]) + , alu_sel_div_rng_chk(il[61]) + , alu_sel_rng_chk(il[62]) + , alu_sel_rng_chk_lookup(il[63]) + , alu_sel_shift_which(il[64]) + , alu_shift_lt_bit_len(il[65]) + , alu_t_sub_s_bits(il[66]) + , alu_two_pow_s(il[67]) + , alu_two_pow_t_sub_s(il[68]) + , alu_u128_tag(il[69]) + , alu_u16_r0(il[70]) + , alu_u16_r1(il[71]) + , alu_u16_r10(il[72]) + , alu_u16_r11(il[73]) + , alu_u16_r12(il[74]) + , alu_u16_r13(il[75]) + , alu_u16_r14(il[76]) + , alu_u16_r2(il[77]) + , alu_u16_r3(il[78]) + , alu_u16_r4(il[79]) + , alu_u16_r5(il[80]) + , alu_u16_r6(il[81]) + , alu_u16_r7(il[82]) + , alu_u16_r8(il[83]) + , alu_u16_r9(il[84]) + , alu_u16_tag(il[85]) + , alu_u32_tag(il[86]) + , alu_u64_tag(il[87]) + , alu_u8_r0(il[88]) + , alu_u8_r1(il[89]) + , alu_u8_tag(il[90]) + , binary_acc_ia(il[91]) + , binary_acc_ib(il[92]) + , binary_acc_ic(il[93]) + , binary_clk(il[94]) + , binary_ia_bytes(il[95]) + , binary_ib_bytes(il[96]) + , binary_ic_bytes(il[97]) + , binary_in_tag(il[98]) + , binary_mem_tag_ctr(il[99]) + , binary_mem_tag_ctr_inv(il[100]) + , binary_op_id(il[101]) + , binary_sel_bin(il[102]) + , binary_start(il[103]) + , byte_lookup_sel_bin(il[104]) + , byte_lookup_table_byte_lengths(il[105]) + , byte_lookup_table_in_tags(il[106]) + , byte_lookup_table_input_a(il[107]) + , byte_lookup_table_input_b(il[108]) + , byte_lookup_table_op_id(il[109]) + , byte_lookup_table_output(il[110]) + , conversion_clk(il[111]) + , conversion_input(il[112]) + , conversion_num_limbs(il[113]) + , conversion_radix(il[114]) + , conversion_sel_to_radix_le(il[115]) + , gas_da_gas_fixed_table(il[116]) + , gas_l2_gas_fixed_table(il[117]) + , gas_sel_gas_cost(il[118]) + , keccakf1600_clk(il[119]) + , keccakf1600_input(il[120]) + , keccakf1600_output(il[121]) + , keccakf1600_sel_keccakf1600(il[122]) + , kernel_emit_l2_to_l1_msg_write_offset(il[123]) + , kernel_emit_note_hash_write_offset(il[124]) + , kernel_emit_nullifier_write_offset(il[125]) + , kernel_emit_unencrypted_log_write_offset(il[126]) + , kernel_kernel_in_offset(il[127]) + , kernel_kernel_out_offset(il[128]) + , kernel_l1_to_l2_msg_exists_write_offset(il[129]) + , kernel_note_hash_exist_write_offset(il[130]) + , kernel_nullifier_exists_write_offset(il[131]) + , kernel_nullifier_non_exists_write_offset(il[132]) + , kernel_q_public_input_kernel_add_to_table(il[133]) + , kernel_q_public_input_kernel_out_add_to_table(il[134]) + , kernel_side_effect_counter(il[135]) + , kernel_sload_write_offset(il[136]) + , kernel_sstore_write_offset(il[137]) + , main_abs_da_rem_gas_hi(il[138]) + , main_abs_da_rem_gas_lo(il[139]) + , main_abs_l2_rem_gas_hi(il[140]) + , main_abs_l2_rem_gas_lo(il[141]) + , main_alu_in_tag(il[142]) + , main_bin_op_id(il[143]) + , main_call_ptr(il[144]) + , main_da_gas_op_cost(il[145]) + , main_da_gas_remaining(il[146]) + , main_da_out_of_gas(il[147]) + , main_ia(il[148]) + , main_ib(il[149]) + , main_ic(il[150]) + , main_id(il[151]) + , main_id_zero(il[152]) + , main_ind_addr_a(il[153]) + , main_ind_addr_b(il[154]) + , main_ind_addr_c(il[155]) + , main_ind_addr_d(il[156]) + , main_internal_return_ptr(il[157]) + , main_inv(il[158]) + , main_l2_gas_op_cost(il[159]) + , main_l2_gas_remaining(il[160]) + , main_l2_out_of_gas(il[161]) + , main_mem_addr_a(il[162]) + , main_mem_addr_b(il[163]) + , main_mem_addr_c(il[164]) + , main_mem_addr_d(il[165]) + , main_op_err(il[166]) + , main_opcode_val(il[167]) + , main_pc(il[168]) + , main_r_in_tag(il[169]) + , main_rwa(il[170]) + , main_rwb(il[171]) + , main_rwc(il[172]) + , main_rwd(il[173]) + , main_sel_alu(il[174]) + , main_sel_bin(il[175]) + , main_sel_calldata(il[176]) + , main_sel_gas_accounting_active(il[177]) + , main_sel_last(il[178]) + , main_sel_mem_op_a(il[179]) + , main_sel_mem_op_activate_gas(il[180]) + , main_sel_mem_op_b(il[181]) + , main_sel_mem_op_c(il[182]) + , main_sel_mem_op_d(il[183]) + , main_sel_mov_ia_to_ic(il[184]) + , main_sel_mov_ib_to_ic(il[185]) + , main_sel_op_add(il[186]) + , main_sel_op_address(il[187]) + , main_sel_op_and(il[188]) + , main_sel_op_block_number(il[189]) + , main_sel_op_calldata_copy(il[190]) + , main_sel_op_cast(il[191]) + , main_sel_op_chain_id(il[192]) + , main_sel_op_cmov(il[193]) + , main_sel_op_coinbase(il[194]) + , main_sel_op_dagasleft(il[195]) + , main_sel_op_div(il[196]) + , main_sel_op_emit_l2_to_l1_msg(il[197]) + , main_sel_op_emit_note_hash(il[198]) + , main_sel_op_emit_nullifier(il[199]) + , main_sel_op_emit_unencrypted_log(il[200]) + , main_sel_op_eq(il[201]) + , main_sel_op_external_call(il[202]) + , main_sel_op_external_return(il[203]) + , main_sel_op_fdiv(il[204]) + , main_sel_op_fee_per_da_gas(il[205]) + , main_sel_op_fee_per_l2_gas(il[206]) + , main_sel_op_function_selector(il[207]) + , main_sel_op_get_contract_instance(il[208]) + , main_sel_op_halt(il[209]) + , main_sel_op_internal_call(il[210]) + , main_sel_op_internal_return(il[211]) + , main_sel_op_jump(il[212]) + , main_sel_op_jumpi(il[213]) + , main_sel_op_keccak(il[214]) + , main_sel_op_l1_to_l2_msg_exists(il[215]) + , main_sel_op_l2gasleft(il[216]) + , main_sel_op_lt(il[217]) + , main_sel_op_lte(il[218]) + , main_sel_op_mov(il[219]) + , main_sel_op_mul(il[220]) + , main_sel_op_not(il[221]) + , main_sel_op_note_hash_exists(il[222]) + , main_sel_op_nullifier_exists(il[223]) + , main_sel_op_or(il[224]) + , main_sel_op_pedersen(il[225]) + , main_sel_op_poseidon2(il[226]) + , main_sel_op_radix_le(il[227]) + , main_sel_op_sender(il[228]) + , main_sel_op_sha256(il[229]) + , main_sel_op_shl(il[230]) + , main_sel_op_shr(il[231]) + , main_sel_op_sload(il[232]) + , main_sel_op_sstore(il[233]) + , main_sel_op_storage_address(il[234]) + , main_sel_op_sub(il[235]) + , main_sel_op_timestamp(il[236]) + , main_sel_op_transaction_fee(il[237]) + , main_sel_op_version(il[238]) + , main_sel_op_xor(il[239]) + , main_sel_q_kernel_lookup(il[240]) + , main_sel_q_kernel_output_lookup(il[241]) + , main_sel_resolve_ind_addr_a(il[242]) + , main_sel_resolve_ind_addr_b(il[243]) + , main_sel_resolve_ind_addr_c(il[244]) + , main_sel_resolve_ind_addr_d(il[245]) + , main_sel_returndata(il[246]) + , main_sel_rng_16(il[247]) + , main_sel_rng_8(il[248]) + , main_sel_slice_gadget(il[249]) + , main_space_id(il[250]) + , main_tag_err(il[251]) + , main_w_in_tag(il[252]) + , mem_addr(il[253]) + , mem_clk(il[254]) + , mem_diff_hi(il[255]) + , mem_diff_lo(il[256]) + , mem_diff_mid(il[257]) + , mem_glob_addr(il[258]) + , mem_last(il[259]) + , mem_lastAccess(il[260]) + , mem_one_min_inv(il[261]) + , mem_r_in_tag(il[262]) + , mem_rw(il[263]) + , mem_sel_mem(il[264]) + , mem_sel_mov_ia_to_ic(il[265]) + , mem_sel_mov_ib_to_ic(il[266]) + , mem_sel_op_a(il[267]) + , mem_sel_op_b(il[268]) + , mem_sel_op_c(il[269]) + , mem_sel_op_cmov(il[270]) + , mem_sel_op_d(il[271]) + , mem_sel_op_slice(il[272]) + , mem_sel_resolve_ind_addr_a(il[273]) + , mem_sel_resolve_ind_addr_b(il[274]) + , mem_sel_resolve_ind_addr_c(il[275]) + , mem_sel_resolve_ind_addr_d(il[276]) + , mem_sel_rng_chk(il[277]) + , mem_skip_check_tag(il[278]) + , mem_space_id(il[279]) + , mem_tag(il[280]) + , mem_tag_err(il[281]) + , mem_tsp(il[282]) + , mem_val(il[283]) + , mem_w_in_tag(il[284]) + , pedersen_clk(il[285]) + , pedersen_input(il[286]) + , pedersen_output(il[287]) + , pedersen_sel_pedersen(il[288]) + , poseidon2_clk(il[289]) + , poseidon2_input(il[290]) + , poseidon2_output(il[291]) + , poseidon2_sel_poseidon_perm(il[292]) + , powers_power_of_2(il[293]) + , sha256_clk(il[294]) + , sha256_input(il[295]) + , sha256_output(il[296]) + , sha256_sel_sha256_compression(il[297]) + , sha256_state(il[298]) + , slice_addr(il[299]) + , slice_clk(il[300]) + , slice_cnt(il[301]) + , slice_col_offset(il[302]) + , slice_one_min_inv(il[303]) + , slice_sel_cd_cpy(il[304]) + , slice_sel_mem_active(il[305]) + , slice_sel_return(il[306]) + , slice_sel_start(il[307]) + , slice_space_id(il[308]) + , slice_val(il[309]) + , perm_slice_mem(il[310]) + , perm_main_alu(il[311]) + , perm_main_bin(il[312]) + , perm_main_conv(il[313]) + , perm_main_pos2_perm(il[314]) + , perm_main_pedersen(il[315]) + , perm_main_slice(il[316]) + , perm_main_mem_a(il[317]) + , perm_main_mem_b(il[318]) + , perm_main_mem_c(il[319]) + , perm_main_mem_d(il[320]) + , perm_main_mem_ind_addr_a(il[321]) + , perm_main_mem_ind_addr_b(il[322]) + , perm_main_mem_ind_addr_c(il[323]) + , perm_main_mem_ind_addr_d(il[324]) + , lookup_byte_lengths(il[325]) + , lookup_byte_operations(il[326]) + , lookup_cd_value(il[327]) + , lookup_ret_value(il[328]) + , lookup_opcode_gas(il[329]) + , range_check_l2_gas_hi(il[330]) + , range_check_l2_gas_lo(il[331]) + , range_check_da_gas_hi(il[332]) + , range_check_da_gas_lo(il[333]) + , kernel_output_lookup(il[334]) + , lookup_into_kernel(il[335]) + , incl_main_tag_err(il[336]) + , incl_mem_tag_err(il[337]) + , lookup_mem_rng_chk_lo(il[338]) + , lookup_mem_rng_chk_mid(il[339]) + , lookup_mem_rng_chk_hi(il[340]) + , lookup_pow_2_0(il[341]) + , lookup_pow_2_1(il[342]) + , lookup_u8_0(il[343]) + , lookup_u8_1(il[344]) + , lookup_u16_0(il[345]) + , lookup_u16_1(il[346]) + , lookup_u16_2(il[347]) + , lookup_u16_3(il[348]) + , lookup_u16_4(il[349]) + , lookup_u16_5(il[350]) + , lookup_u16_6(il[351]) + , lookup_u16_7(il[352]) + , lookup_u16_8(il[353]) + , lookup_u16_9(il[354]) + , lookup_u16_10(il[355]) + , lookup_u16_11(il[356]) + , lookup_u16_12(il[357]) + , lookup_u16_13(il[358]) + , lookup_u16_14(il[359]) + , lookup_div_u16_0(il[360]) + , lookup_div_u16_1(il[361]) + , lookup_div_u16_2(il[362]) + , lookup_div_u16_3(il[363]) + , lookup_div_u16_4(il[364]) + , lookup_div_u16_5(il[365]) + , lookup_div_u16_6(il[366]) + , lookup_div_u16_7(il[367]) + , lookup_byte_lengths_counts(il[368]) + , lookup_byte_operations_counts(il[369]) + , lookup_cd_value_counts(il[370]) + , lookup_ret_value_counts(il[371]) + , lookup_opcode_gas_counts(il[372]) + , range_check_l2_gas_hi_counts(il[373]) + , range_check_l2_gas_lo_counts(il[374]) + , range_check_da_gas_hi_counts(il[375]) + , range_check_da_gas_lo_counts(il[376]) + , kernel_output_lookup_counts(il[377]) + , lookup_into_kernel_counts(il[378]) + , incl_main_tag_err_counts(il[379]) + , incl_mem_tag_err_counts(il[380]) + , lookup_mem_rng_chk_lo_counts(il[381]) + , lookup_mem_rng_chk_mid_counts(il[382]) + , lookup_mem_rng_chk_hi_counts(il[383]) + , lookup_pow_2_0_counts(il[384]) + , lookup_pow_2_1_counts(il[385]) + , lookup_u8_0_counts(il[386]) + , lookup_u8_1_counts(il[387]) + , lookup_u16_0_counts(il[388]) + , lookup_u16_1_counts(il[389]) + , lookup_u16_2_counts(il[390]) + , lookup_u16_3_counts(il[391]) + , lookup_u16_4_counts(il[392]) + , lookup_u16_5_counts(il[393]) + , lookup_u16_6_counts(il[394]) + , lookup_u16_7_counts(il[395]) + , lookup_u16_8_counts(il[396]) + , lookup_u16_9_counts(il[397]) + , lookup_u16_10_counts(il[398]) + , lookup_u16_11_counts(il[399]) + , lookup_u16_12_counts(il[400]) + , lookup_u16_13_counts(il[401]) + , lookup_u16_14_counts(il[402]) + , lookup_div_u16_0_counts(il[403]) + , lookup_div_u16_1_counts(il[404]) + , lookup_div_u16_2_counts(il[405]) + , lookup_div_u16_3_counts(il[406]) + , lookup_div_u16_4_counts(il[407]) + , lookup_div_u16_5_counts(il[408]) + , lookup_div_u16_6_counts(il[409]) + , lookup_div_u16_7_counts(il[410]) + , alu_a_hi_shift(il[411]) + , alu_a_lo_shift(il[412]) + , alu_b_hi_shift(il[413]) + , alu_b_lo_shift(il[414]) + , alu_cmp_rng_ctr_shift(il[415]) + , alu_div_u16_r0_shift(il[416]) + , alu_div_u16_r1_shift(il[417]) + , alu_div_u16_r2_shift(il[418]) + , alu_div_u16_r3_shift(il[419]) + , alu_div_u16_r4_shift(il[420]) + , alu_div_u16_r5_shift(il[421]) + , alu_div_u16_r6_shift(il[422]) + , alu_div_u16_r7_shift(il[423]) + , alu_op_add_shift(il[424]) + , alu_op_cast_prev_shift(il[425]) + , alu_op_cast_shift(il[426]) + , alu_op_div_shift(il[427]) + , alu_op_mul_shift(il[428]) + , alu_op_shl_shift(il[429]) + , alu_op_shr_shift(il[430]) + , alu_op_sub_shift(il[431]) + , alu_p_sub_a_hi_shift(il[432]) + , alu_p_sub_a_lo_shift(il[433]) + , alu_p_sub_b_hi_shift(il[434]) + , alu_p_sub_b_lo_shift(il[435]) + , alu_sel_alu_shift(il[436]) + , alu_sel_cmp_shift(il[437]) + , alu_sel_div_rng_chk_shift(il[438]) + , alu_sel_rng_chk_lookup_shift(il[439]) + , alu_sel_rng_chk_shift(il[440]) + , alu_u16_r0_shift(il[441]) + , alu_u16_r1_shift(il[442]) + , alu_u16_r2_shift(il[443]) + , alu_u16_r3_shift(il[444]) + , alu_u16_r4_shift(il[445]) + , alu_u16_r5_shift(il[446]) + , alu_u16_r6_shift(il[447]) + , alu_u8_r0_shift(il[448]) + , alu_u8_r1_shift(il[449]) + , binary_acc_ia_shift(il[450]) + , binary_acc_ib_shift(il[451]) + , binary_acc_ic_shift(il[452]) + , binary_mem_tag_ctr_shift(il[453]) + , binary_op_id_shift(il[454]) + , kernel_emit_l2_to_l1_msg_write_offset_shift(il[455]) + , kernel_emit_note_hash_write_offset_shift(il[456]) + , kernel_emit_nullifier_write_offset_shift(il[457]) + , kernel_emit_unencrypted_log_write_offset_shift(il[458]) + , kernel_l1_to_l2_msg_exists_write_offset_shift(il[459]) + , kernel_note_hash_exist_write_offset_shift(il[460]) + , kernel_nullifier_exists_write_offset_shift(il[461]) + , kernel_nullifier_non_exists_write_offset_shift(il[462]) + , kernel_side_effect_counter_shift(il[463]) + , kernel_sload_write_offset_shift(il[464]) + , kernel_sstore_write_offset_shift(il[465]) + , main_da_gas_remaining_shift(il[466]) + , main_internal_return_ptr_shift(il[467]) + , main_l2_gas_remaining_shift(il[468]) + , main_pc_shift(il[469]) + , mem_glob_addr_shift(il[470]) + , mem_rw_shift(il[471]) + , mem_sel_mem_shift(il[472]) + , mem_tag_shift(il[473]) + , mem_tsp_shift(il[474]) + , mem_val_shift(il[475]) + , slice_addr_shift(il[476]) + , slice_clk_shift(il[477]) + , slice_cnt_shift(il[478]) + , slice_col_offset_shift(il[479]) + , slice_sel_cd_cpy_shift(il[480]) + , slice_sel_mem_active_shift(il[481]) + , slice_sel_return_shift(il[482]) + , slice_sel_start_shift(il[483]) + , slice_space_id_shift(il[484]) {} }; @@ -1814,6 +1941,7 @@ class AvmFlavor { kernel_kernel_side_effect_out[row_idx], kernel_kernel_metadata_out[row_idx], main_calldata[row_idx], + main_returndata[row_idx], alu_a_hi[row_idx], alu_a_lo[row_idx], alu_b_hi[row_idx], @@ -1982,6 +2110,7 @@ class AvmFlavor { main_rwd[row_idx], main_sel_alu[row_idx], main_sel_bin[row_idx], + main_sel_calldata[row_idx], main_sel_gas_accounting_active[row_idx], main_sel_last[row_idx], main_sel_mem_op_a[row_idx], @@ -1995,6 +2124,7 @@ class AvmFlavor { main_sel_op_address[row_idx], main_sel_op_and[row_idx], main_sel_op_block_number[row_idx], + main_sel_op_calldata_copy[row_idx], main_sel_op_cast[row_idx], main_sel_op_chain_id[row_idx], main_sel_op_cmov[row_idx], @@ -2007,6 +2137,7 @@ class AvmFlavor { main_sel_op_emit_unencrypted_log[row_idx], main_sel_op_eq[row_idx], main_sel_op_external_call[row_idx], + main_sel_op_external_return[row_idx], main_sel_op_fdiv[row_idx], main_sel_op_fee_per_da_gas[row_idx], main_sel_op_fee_per_l2_gas[row_idx], @@ -2049,8 +2180,10 @@ class AvmFlavor { main_sel_resolve_ind_addr_b[row_idx], main_sel_resolve_ind_addr_c[row_idx], main_sel_resolve_ind_addr_d[row_idx], + main_sel_returndata[row_idx], main_sel_rng_16[row_idx], main_sel_rng_8[row_idx], + main_sel_slice_gadget[row_idx], main_space_id[row_idx], main_tag_err[row_idx], main_w_in_tag[row_idx], @@ -2073,6 +2206,7 @@ class AvmFlavor { mem_sel_op_c[row_idx], mem_sel_op_cmov[row_idx], mem_sel_op_d[row_idx], + mem_sel_op_slice[row_idx], mem_sel_resolve_ind_addr_a[row_idx], mem_sel_resolve_ind_addr_b[row_idx], mem_sel_resolve_ind_addr_c[row_idx], @@ -2099,11 +2233,24 @@ class AvmFlavor { sha256_output[row_idx], sha256_sel_sha256_compression[row_idx], sha256_state[row_idx], + slice_addr[row_idx], + slice_clk[row_idx], + slice_cnt[row_idx], + slice_col_offset[row_idx], + slice_one_min_inv[row_idx], + slice_sel_cd_cpy[row_idx], + slice_sel_mem_active[row_idx], + slice_sel_return[row_idx], + slice_sel_start[row_idx], + slice_space_id[row_idx], + slice_val[row_idx], + perm_slice_mem[row_idx], perm_main_alu[row_idx], perm_main_bin[row_idx], perm_main_conv[row_idx], perm_main_pos2_perm[row_idx], perm_main_pedersen[row_idx], + perm_main_slice[row_idx], perm_main_mem_a[row_idx], perm_main_mem_b[row_idx], perm_main_mem_c[row_idx], @@ -2114,6 +2261,8 @@ class AvmFlavor { perm_main_mem_ind_addr_d[row_idx], lookup_byte_lengths[row_idx], lookup_byte_operations[row_idx], + lookup_cd_value[row_idx], + lookup_ret_value[row_idx], lookup_opcode_gas[row_idx], range_check_l2_gas_hi[row_idx], range_check_l2_gas_lo[row_idx], @@ -2155,6 +2304,8 @@ class AvmFlavor { lookup_div_u16_7[row_idx], lookup_byte_lengths_counts[row_idx], lookup_byte_operations_counts[row_idx], + lookup_cd_value_counts[row_idx], + lookup_ret_value_counts[row_idx], lookup_opcode_gas_counts[row_idx], range_check_l2_gas_hi_counts[row_idx], range_check_l2_gas_lo_counts[row_idx], @@ -2258,7 +2409,16 @@ class AvmFlavor { mem_sel_mem_shift[row_idx], mem_tag_shift[row_idx], mem_tsp_shift[row_idx], - mem_val_shift[row_idx] }); + mem_val_shift[row_idx], + slice_addr_shift[row_idx], + slice_clk_shift[row_idx], + slice_cnt_shift[row_idx], + slice_col_offset_shift[row_idx], + slice_sel_cd_cpy_shift[row_idx], + slice_sel_mem_active_shift[row_idx], + slice_sel_return_shift[row_idx], + slice_sel_start_shift[row_idx], + slice_space_id_shift[row_idx] }); } }; @@ -2313,6 +2473,7 @@ class AvmFlavor { Base::kernel_kernel_side_effect_out = "KERNEL_KERNEL_SIDE_EFFECT_OUT"; Base::kernel_kernel_metadata_out = "KERNEL_KERNEL_METADATA_OUT"; Base::main_calldata = "MAIN_CALLDATA"; + Base::main_returndata = "MAIN_RETURNDATA"; Base::alu_a_hi = "ALU_A_HI"; Base::alu_a_lo = "ALU_A_LO"; Base::alu_b_hi = "ALU_B_HI"; @@ -2481,6 +2642,7 @@ 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_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"; @@ -2494,6 +2656,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"; @@ -2506,6 +2669,7 @@ class AvmFlavor { Base::main_sel_op_emit_unencrypted_log = "MAIN_SEL_OP_EMIT_UNENCRYPTED_LOG"; Base::main_sel_op_eq = "MAIN_SEL_OP_EQ"; Base::main_sel_op_external_call = "MAIN_SEL_OP_EXTERNAL_CALL"; + Base::main_sel_op_external_return = "MAIN_SEL_OP_EXTERNAL_RETURN"; Base::main_sel_op_fdiv = "MAIN_SEL_OP_FDIV"; Base::main_sel_op_fee_per_da_gas = "MAIN_SEL_OP_FEE_PER_DA_GAS"; Base::main_sel_op_fee_per_l2_gas = "MAIN_SEL_OP_FEE_PER_L2_GAS"; @@ -2548,8 +2712,10 @@ class AvmFlavor { Base::main_sel_resolve_ind_addr_b = "MAIN_SEL_RESOLVE_IND_ADDR_B"; Base::main_sel_resolve_ind_addr_c = "MAIN_SEL_RESOLVE_IND_ADDR_C"; Base::main_sel_resolve_ind_addr_d = "MAIN_SEL_RESOLVE_IND_ADDR_D"; + Base::main_sel_returndata = "MAIN_SEL_RETURNDATA"; Base::main_sel_rng_16 = "MAIN_SEL_RNG_16"; Base::main_sel_rng_8 = "MAIN_SEL_RNG_8"; + Base::main_sel_slice_gadget = "MAIN_SEL_SLICE_GADGET"; Base::main_space_id = "MAIN_SPACE_ID"; Base::main_tag_err = "MAIN_TAG_ERR"; Base::main_w_in_tag = "MAIN_W_IN_TAG"; @@ -2572,6 +2738,7 @@ class AvmFlavor { Base::mem_sel_op_c = "MEM_SEL_OP_C"; Base::mem_sel_op_cmov = "MEM_SEL_OP_CMOV"; Base::mem_sel_op_d = "MEM_SEL_OP_D"; + Base::mem_sel_op_slice = "MEM_SEL_OP_SLICE"; Base::mem_sel_resolve_ind_addr_a = "MEM_SEL_RESOLVE_IND_ADDR_A"; Base::mem_sel_resolve_ind_addr_b = "MEM_SEL_RESOLVE_IND_ADDR_B"; Base::mem_sel_resolve_ind_addr_c = "MEM_SEL_RESOLVE_IND_ADDR_C"; @@ -2598,11 +2765,24 @@ 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_clk = "SLICE_CLK"; + Base::slice_cnt = "SLICE_CNT"; + Base::slice_col_offset = "SLICE_COL_OFFSET"; + Base::slice_one_min_inv = "SLICE_ONE_MIN_INV"; + Base::slice_sel_cd_cpy = "SLICE_SEL_CD_CPY"; + Base::slice_sel_mem_active = "SLICE_SEL_MEM_ACTIVE"; + Base::slice_sel_return = "SLICE_SEL_RETURN"; + Base::slice_sel_start = "SLICE_SEL_START"; + Base::slice_space_id = "SLICE_SPACE_ID"; + Base::slice_val = "SLICE_VAL"; + Base::perm_slice_mem = "PERM_SLICE_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_slice = "PERM_MAIN_SLICE"; 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"; @@ -2613,6 +2793,8 @@ 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_ret_value = "LOOKUP_RET_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"; @@ -2654,6 +2836,8 @@ 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_ret_value_counts = "LOOKUP_RET_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..fcb1803a2cbf 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.cpp @@ -25,6 +25,7 @@ template std::vector AvmFullRow::names() "kernel_kernel_side_effect_out", "kernel_kernel_metadata_out", "main_calldata", + "main_returndata", "alu_a_hi", "alu_a_lo", "alu_b_hi", @@ -193,6 +194,7 @@ template std::vector AvmFullRow::names() "main_rwd", "main_sel_alu", "main_sel_bin", + "main_sel_calldata", "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", @@ -218,6 +221,7 @@ template std::vector AvmFullRow::names() "main_sel_op_emit_unencrypted_log", "main_sel_op_eq", "main_sel_op_external_call", + "main_sel_op_external_return", "main_sel_op_fdiv", "main_sel_op_fee_per_da_gas", "main_sel_op_fee_per_l2_gas", @@ -260,8 +264,10 @@ template std::vector AvmFullRow::names() "main_sel_resolve_ind_addr_b", "main_sel_resolve_ind_addr_c", "main_sel_resolve_ind_addr_d", + "main_sel_returndata", "main_sel_rng_16", "main_sel_rng_8", + "main_sel_slice_gadget", "main_space_id", "main_tag_err", "main_w_in_tag", @@ -284,6 +290,7 @@ template std::vector AvmFullRow::names() "mem_sel_op_c", "mem_sel_op_cmov", "mem_sel_op_d", + "mem_sel_op_slice", "mem_sel_resolve_ind_addr_a", "mem_sel_resolve_ind_addr_b", "mem_sel_resolve_ind_addr_c", @@ -310,11 +317,24 @@ template std::vector AvmFullRow::names() "sha256_output", "sha256_sel_sha256_compression", "sha256_state", + "slice_addr", + "slice_clk", + "slice_cnt", + "slice_col_offset", + "slice_one_min_inv", + "slice_sel_cd_cpy", + "slice_sel_mem_active", + "slice_sel_return", + "slice_sel_start", + "slice_space_id", + "slice_val", + "perm_slice_mem", "perm_main_alu", "perm_main_bin", "perm_main_conv", "perm_main_pos2_perm", "perm_main_pedersen", + "perm_main_slice", "perm_main_mem_a", "perm_main_mem_b", "perm_main_mem_c", @@ -325,6 +345,8 @@ template std::vector AvmFullRow::names() "perm_main_mem_ind_addr_d", "lookup_byte_lengths", "lookup_byte_operations", + "lookup_cd_value", + "lookup_ret_value", "lookup_opcode_gas", "range_check_l2_gas_hi", "range_check_l2_gas_lo", @@ -366,6 +388,8 @@ template std::vector AvmFullRow::names() "lookup_div_u16_7", "lookup_byte_lengths_counts", "lookup_byte_operations_counts", + "lookup_cd_value_counts", + "lookup_ret_value_counts", "lookup_opcode_gas_counts", "range_check_l2_gas_hi_counts", "range_check_l2_gas_lo_counts", @@ -416,6 +440,7 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << 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.main_returndata) // << "," << field_to_string(row.alu_a_hi) // << "," << field_to_string(row.alu_a_lo) // << "," << field_to_string(row.alu_b_hi) // @@ -584,6 +609,7 @@ 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_gas_accounting_active) // << "," << field_to_string(row.main_sel_last) // << "," << field_to_string(row.main_sel_mem_op_a) // @@ -597,6 +623,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) // @@ -609,6 +636,7 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << 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_external_return) // << "," << 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) // @@ -651,8 +679,10 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << 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_returndata) // << "," << field_to_string(row.main_sel_rng_16) // << "," << field_to_string(row.main_sel_rng_8) // + << "," << field_to_string(row.main_sel_slice_gadget) // << "," << field_to_string(row.main_space_id) // << "," << field_to_string(row.main_tag_err) // << "," << field_to_string(row.main_w_in_tag) // @@ -675,6 +705,7 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << field_to_string(row.mem_sel_op_c) // << "," << field_to_string(row.mem_sel_op_cmov) // << "," << field_to_string(row.mem_sel_op_d) // + << "," << field_to_string(row.mem_sel_op_slice) // << "," << 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) // @@ -701,11 +732,24 @@ 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_clk) // + << "," << field_to_string(row.slice_cnt) // + << "," << field_to_string(row.slice_col_offset) // + << "," << field_to_string(row.slice_one_min_inv) // + << "," << field_to_string(row.slice_sel_cd_cpy) // + << "," << field_to_string(row.slice_sel_mem_active) // + << "," << field_to_string(row.slice_sel_return) // + << "," << field_to_string(row.slice_sel_start) // + << "," << field_to_string(row.slice_space_id) // + << "," << field_to_string(row.slice_val) // + << "," << field_to_string(row.perm_slice_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_slice) // << "," << 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 +760,8 @@ 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_ret_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 +803,8 @@ 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_ret_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..053deb3a1afb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_full_row.hpp @@ -14,6 +14,7 @@ template struct AvmFullRow { FF kernel_kernel_side_effect_out{}; FF kernel_kernel_metadata_out{}; FF main_calldata{}; + FF main_returndata{}; FF alu_a_hi{}; FF alu_a_lo{}; FF alu_b_hi{}; @@ -182,6 +183,7 @@ template struct AvmFullRow { FF main_rwd{}; FF main_sel_alu{}; FF main_sel_bin{}; + FF main_sel_calldata{}; 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{}; @@ -207,6 +210,7 @@ template struct AvmFullRow { FF main_sel_op_emit_unencrypted_log{}; FF main_sel_op_eq{}; FF main_sel_op_external_call{}; + FF main_sel_op_external_return{}; FF main_sel_op_fdiv{}; FF main_sel_op_fee_per_da_gas{}; FF main_sel_op_fee_per_l2_gas{}; @@ -249,8 +253,10 @@ template struct AvmFullRow { FF main_sel_resolve_ind_addr_b{}; FF main_sel_resolve_ind_addr_c{}; FF main_sel_resolve_ind_addr_d{}; + FF main_sel_returndata{}; FF main_sel_rng_16{}; FF main_sel_rng_8{}; + FF main_sel_slice_gadget{}; FF main_space_id{}; FF main_tag_err{}; FF main_w_in_tag{}; @@ -273,6 +279,7 @@ template struct AvmFullRow { FF mem_sel_op_c{}; FF mem_sel_op_cmov{}; FF mem_sel_op_d{}; + FF mem_sel_op_slice{}; FF mem_sel_resolve_ind_addr_a{}; FF mem_sel_resolve_ind_addr_b{}; FF mem_sel_resolve_ind_addr_c{}; @@ -299,11 +306,24 @@ template struct AvmFullRow { FF sha256_output{}; FF sha256_sel_sha256_compression{}; FF sha256_state{}; + FF slice_addr{}; + FF slice_clk{}; + FF slice_cnt{}; + FF slice_col_offset{}; + FF slice_one_min_inv{}; + FF slice_sel_cd_cpy{}; + FF slice_sel_mem_active{}; + FF slice_sel_return{}; + FF slice_sel_start{}; + FF slice_space_id{}; + FF slice_val{}; + FF perm_slice_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_slice{}; FF perm_main_mem_a{}; FF perm_main_mem_b{}; FF perm_main_mem_c{}; @@ -314,6 +334,8 @@ template struct AvmFullRow { FF perm_main_mem_ind_addr_d{}; FF lookup_byte_lengths{}; FF lookup_byte_operations{}; + FF lookup_cd_value{}; + FF lookup_ret_value{}; FF lookup_opcode_gas{}; FF range_check_l2_gas_hi{}; FF range_check_l2_gas_lo{}; @@ -355,6 +377,8 @@ 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_ret_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..a795633e1e39 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_slice_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_slice = + transcript->template receive_from_prover(commitment_labels.perm_main_slice); commitments.perm_main_mem_a = transcript->template receive_from_prover(commitment_labels.perm_main_mem_a); commitments.perm_main_mem_b = @@ -106,6 +109,10 @@ 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_ret_value = + transcript->template receive_from_prover(commitment_labels.lookup_ret_value); commitments.lookup_opcode_gas = transcript->template receive_from_prover(commitment_labels.lookup_opcode_gas); commitments.range_check_l2_gas_hi = @@ -211,6 +218,10 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector const returndata = { 37, 4, 11, 0, 41 }; + + validate_trace(std::move(trace), public_inputs, calldata, returndata, true); } // Test on basic subtraction over finite field type. @@ -409,6 +411,7 @@ TEST_F(AvmArithmeticTestsFF, subtraction) EXPECT_EQ(alu_row.alu_cf, FF(0)); EXPECT_EQ(alu_row.alu_u8_r0, FF(0)); + std::vector const returndata = { 8, 9, 17 }; validate_trace(std::move(trace), public_inputs, calldata); } @@ -431,7 +434,8 @@ TEST_F(AvmArithmeticTestsFF, multiplication) EXPECT_EQ(alu_row.alu_cf, FF(0)); EXPECT_EQ(alu_row.alu_u8_r0, FF(0)); - validate_trace(std::move(trace), public_inputs, calldata); + std::vector const returndata = { 5, 100, 20 }; + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Test on multiplication by zero over finite field type. @@ -453,7 +457,8 @@ TEST_F(AvmArithmeticTestsFF, multiplicationByZero) EXPECT_EQ(alu_row.alu_cf, FF(0)); EXPECT_EQ(alu_row.alu_u8_r0, FF(0)); - validate_trace(std::move(trace), public_inputs, calldata); + std::vector const returndata = { 127, 0, 0 }; + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Test on basic division over finite field type. @@ -478,7 +483,8 @@ TEST_F(AvmArithmeticTestsFF, fDivision) EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); - validate_trace(std::move(trace), public_inputs, calldata); + std::vector const returndata = { 15, 315, 0 }; + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Test on division with zero numerator over finite field type. @@ -503,7 +509,8 @@ TEST_F(AvmArithmeticTestsFF, fDivisionNumeratorZero) EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); - validate_trace(std::move(trace), public_inputs, calldata); + std::vector const returndata = { 0, 0, 0 }; + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Test on division by zero over finite field type. @@ -579,7 +586,7 @@ TEST_F(AvmArithmeticTestsFF, mixedOperationsWithError) trace_builder.halt(); auto trace = trace_builder.finalize(); - validate_trace(std::move(trace), public_inputs, calldata, true); + validate_trace(std::move(trace), public_inputs, calldata, {}, true); } // Test of equality on FF elements @@ -587,10 +594,10 @@ TEST_F(AvmArithmeticTestsFF, equality) { // Pick a field-sized number FF elem = FF::modulus - FF(1); - std::vector const calldata = { elem, elem, 1 }; + std::vector const calldata = { elem, elem }; gen_trace_builder(calldata); - trace_builder.op_calldata_copy(0, 0, 3, 0); - trace_builder.op_eq(0, 0, 1, 2, AvmMemoryTag::FF); // Memory Layout [q - 1, q -1, 1,0..] + trace_builder.op_calldata_copy(0, 0, 2, 0); + trace_builder.op_eq(0, 0, 1, 2, AvmMemoryTag::FF); // Memory Layout [q - 1, q - 1, 1, 0..] trace_builder.op_return(0, 0, 3); auto trace = trace_builder.finalize(); @@ -599,17 +606,19 @@ TEST_F(AvmArithmeticTestsFF, equality) EXPECT_EQ(alu_row.alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.alu_op_eq_diff_inv, FF(0)); // Expect 0 as inv of (q-1) - (q-1) - validate_trace(std::move(trace), public_inputs, calldata); + + std::vector const returndata = { elem, elem, 1 }; + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Test correct non-equality of FF elements TEST_F(AvmArithmeticTestsFF, nonEquality) { FF elem = FF::modulus - FF(1); - std::vector const calldata = { elem, elem + FF(1), 0 }; + std::vector const calldata = { elem, elem + FF(1) }; gen_trace_builder(calldata); - trace_builder.op_calldata_copy(0, 0, 3, 0); - trace_builder.op_eq(0, 0, 1, 2, AvmMemoryTag::FF); // Memory Layout [q - 1, q, 1,0..] + trace_builder.op_calldata_copy(0, 0, 2, 0); + trace_builder.op_eq(0, 0, 1, 2, AvmMemoryTag::FF); // Memory Layout [q - 1, q, 0, 0..] trace_builder.op_return(0, 0, 0); auto trace = trace_builder.finalize(); @@ -618,7 +627,9 @@ TEST_F(AvmArithmeticTestsFF, nonEquality) EXPECT_EQ(alu_row.alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.alu_op_eq_diff_inv, FF(-1).invert()); - validate_trace(std::move(trace), public_inputs, calldata); + + std::vector const returndata = { elem, 0, 0 }; + validate_trace(std::move(trace), public_inputs, calldata, returndata); } TEST_P(AvmArithmeticTestsDiv, division) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index e70b50106af9..55bafff7034b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -492,7 +492,7 @@ TEST_P(AvmBitwiseTestsAnd, AllAndTest) auto trace = trace_builder.finalize(); common_validate_bit_op(trace, 0, a, b, output, FF(0), FF(1), FF(2), mem_tag); - validate_trace(std::move(trace), public_inputs, {}, true); + validate_trace(std::move(trace), public_inputs, {}, { output }, true); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsAnd, @@ -509,7 +509,7 @@ TEST_P(AvmBitwiseTestsOr, AllOrTest) auto trace = trace_builder.finalize(); common_validate_bit_op(trace, 1, a, b, output, FF(0), FF(1), FF(2), mem_tag); - validate_trace(std::move(trace), public_inputs); + validate_trace(std::move(trace), public_inputs, {}, { output }); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsOr, @@ -526,7 +526,7 @@ TEST_P(AvmBitwiseTestsXor, AllXorTest) auto trace = trace_builder.finalize(); common_validate_bit_op(trace, 2, a, b, output, FF(0), FF(1), FF(2), mem_tag); - validate_trace(std::move(trace), public_inputs); + validate_trace(std::move(trace), public_inputs, {}, { output }); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -543,7 +543,7 @@ TEST_P(AvmBitwiseTestsShr, AllShrTest) trace_builder.op_return(0, 2, 1); auto trace = trace_builder.finalize(); common_validate_shift_op(trace, a, b, output, FF(0), FF(1), FF(2), mem_tag, true); - validate_trace(std::move(trace), public_inputs); + validate_trace(std::move(trace), public_inputs, {}, { output }); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -561,7 +561,7 @@ TEST_P(AvmBitwiseTestsShl, AllShlTest) auto trace = trace_builder.finalize(); common_validate_shift_op(trace, a, b, output, FF(0), FF(1), FF(2), mem_tag, false); - validate_trace(std::move(trace), public_inputs); + validate_trace(std::move(trace), public_inputs, {}, { output }); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, 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..28055ca5f098 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,13 +108,13 @@ 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 // the boolean variable force_proof to validate_trace second argument. if (force_proof) { - validate_trace(std::move(trace), public_inputs, calldata, true); + validate_trace(std::move(trace), public_inputs, calldata, {}, true); } else { validate_trace(std::move(trace), public_inputs, calldata); } @@ -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_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp index f961e542cb47..453d6443233c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp @@ -87,7 +87,7 @@ TEST_F(AvmControlFlowTests, simpleCall) EXPECT_EQ(halt_row->main_pc, FF(CALL_PC)); EXPECT_EQ(halt_row->main_internal_return_ptr, FF(1)); } - validate_trace(std::move(trace), public_inputs, {}, true); + validate_trace(std::move(trace), public_inputs, {}, {}, true); } TEST_F(AvmControlFlowTests, simpleJump) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_execution.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_execution.test.cpp index 24829d562f4c..98591c279454 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_execution.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_execution.test.cpp @@ -100,7 +100,7 @@ TEST_F(AvmExecutionTests, basicAddReturn) ElementsAre(VariantWith(0), VariantWith(0), VariantWith(0))))); auto trace = gen_trace_from_instr(instructions); - validate_trace(std::move(trace), public_inputs, {}, true); + validate_trace(std::move(trace), public_inputs, {}, {}, true); } // Positive test for SET and SUB opcodes @@ -165,7 +165,7 @@ TEST_F(AvmExecutionTests, setAndSubOpcodes) // Find the first row enabling the subtraction selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_sub == 1; }); EXPECT_EQ(row->main_ic, 10000); // 47123 - 37123 = 10000 - validate_trace(std::move(trace), public_inputs, {}, true); + validate_trace(std::move(trace), public_inputs, {}, {}, true); } // Positive test for multiple MUL opcodes @@ -805,7 +805,7 @@ TEST_F(AvmExecutionTests, toRadixLeOpcode) } EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs, { FF::modulus - FF(1) }); + validate_trace(std::move(trace), public_inputs, { FF::modulus - FF(1) }, returndata); } // // Positive test with SHA256COMPRESSION. @@ -873,7 +873,7 @@ TEST_F(AvmExecutionTests, sha256CompressionOpcode) EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs, calldata); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Positive test with SHA256 @@ -941,7 +941,7 @@ TEST_F(AvmExecutionTests, sha256Opcode) EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Positive test with POSEIDON2_PERM. @@ -992,7 +992,7 @@ TEST_F(AvmExecutionTests, poseidon2PermutationOpCode) EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs, calldata); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Positive test with Keccakf1600. @@ -1066,7 +1066,7 @@ TEST_F(AvmExecutionTests, keccakf1600OpCode) EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Positive test with Keccak. @@ -1124,7 +1124,7 @@ TEST_F(AvmExecutionTests, keccakOpCode) EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Positive test with Pedersen. @@ -1177,7 +1177,7 @@ TEST_F(AvmExecutionTests, pedersenHashOpCode) EXPECT_EQ(returndata[0], expected_output); - validate_trace(std::move(trace), public_inputs, calldata); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // // Positive test with EmbeddedCurveAdd @@ -1239,7 +1239,7 @@ TEST_F(AvmExecutionTests, embeddedCurveAddOpCode) EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs, calldata); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Positive test with MSM @@ -1316,7 +1316,7 @@ TEST_F(AvmExecutionTests, msmOpCode) EXPECT_EQ(returndata, expected_output); - validate_trace(std::move(trace), public_inputs, calldata); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Positive test for Kernel Input opcodes @@ -2229,7 +2229,7 @@ TEST_F(AvmExecutionTests, opCallOpcodes) auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints); EXPECT_EQ(returndata, std::vector({ 9, 8, 1 })); // The 1 represents the success - validate_trace(std::move(trace), public_inputs, calldata); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } TEST_F(AvmExecutionTests, opGetContractInstanceOpcodes) @@ -2268,7 +2268,7 @@ TEST_F(AvmExecutionTests, opGetContractInstanceOpcodes) auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints); EXPECT_EQ(returndata, std::vector({ 1, 2, 3, 4, 5, 6 })); // The first one represents true - validate_trace(std::move(trace), public_inputs, calldata); + validate_trace(std::move(trace), public_inputs, calldata, returndata); } // Negative test detecting an invalid opcode byte. TEST_F(AvmExecutionTests, invalidOpcode) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp index 47e82b751023..bf61c566d184 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp @@ -68,7 +68,7 @@ TEST_F(AvmIndirectMemTests, allIndirectAdd) EXPECT_EQ(row->main_sel_mem_op_b, FF(1)); EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); - validate_trace(std::move(trace), public_inputs, {}, true); + validate_trace(std::move(trace), public_inputs, {}, {}, true); } // Testing a subtraction operation with direct input operands a, b, and an indirect 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..1a6ca8a13803 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,14 +393,14 @@ 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)), MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1))); - validate_trace(std::move(trace), public_inputs, {}, true); + validate_trace(std::move(trace), public_inputs, {}, {}, true); } /****************************************************************************** @@ -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_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp index 05a02bb3862f..5708e65c00be 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp @@ -77,7 +77,7 @@ TEST_F(AvmMemoryTests, mismatchedTagAddOperation) EXPECT_EQ(row->mem_r_in_tag, FF(static_cast(AvmMemoryTag::U8))); EXPECT_EQ(row->mem_tag, FF(static_cast(AvmMemoryTag::FF))); - validate_trace(std::move(trace), public_inputs, calldata, true); + validate_trace(std::move(trace), public_inputs, calldata, {}, true); } // Testing an equality operation with a mismatched memory tag. 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..8f581c51a527 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_slice.test.cpp @@ -0,0 +1,337 @@ +#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 col_offset, uint32_t copy_size, uint32_t dst_offset) + { + ASSERT_LE(col_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), col_offset, copy_size, dst_offset); + trace_builder.op_return(0, 0, 0); + trace = trace_builder.finalize(); + } + + void validate_single_calldata_copy_trace(uint32_t col_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_slice == 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, (col_offset + count) * (col_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::FF)), + 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_row_idx = 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, (col_offset + count) * (col_offset + count)), + SLICE_ROW_FIELD_EQ(addr, dst_offset + count), + SLICE_ROW_FIELD_EQ(col_offset, col_offset + count), + SLICE_ROW_FIELD_EQ(cnt, copy_size - count), + SLICE_ROW_FIELD_EQ(sel_start, static_cast(count == 0)))); + count++; + + if (count == copy_size) { + last_row_idx = slice_row.main_clk; + } + } + + // Check that the extra final row is well-formed. + EXPECT_THAT(trace.at(static_cast(last_row_idx + 1)), + AllOf(SLICE_ROW_FIELD_EQ(addr, FF(dst_offset) + FF(copy_size)), + SLICE_ROW_FIELD_EQ(col_offset, col_offset + copy_size), + SLICE_ROW_FIELD_EQ(cnt, 0), + SLICE_ROW_FIELD_EQ(clk, clk), + SLICE_ROW_FIELD_EQ(sel_cd_cpy, 0), + SLICE_ROW_FIELD_EQ(sel_start, 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_slice == 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_SLICE_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_slice = 0; + trace.at(10).mem_skip_check_tag = 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_SLICE_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..283d08e7c3ef 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -25,19 +25,21 @@ std::vector gen_three_op_params(std::vector opera */ void validate_trace_check_circuit(std::vector&& trace) { - validate_trace(std::move(trace), {}, {}, false); + validate_trace(std::move(trace), {}, {}, {}, false); }; /** * @brief Helper routine which checks the circuit constraints and depending on - * the boolean with_proof value performs a proof generation and verification. + * the boolean with_proof value performs a proof generation and verification. * * @param trace The execution trace */ void validate_trace(std::vector&& trace, VmPublicInputs const& public_inputs, std::vector const& calldata, - bool with_proof) + std::vector const& returndata, + bool with_proof, + bool expect_proof_failure) { auto circuit_builder = AvmCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); @@ -51,11 +53,15 @@ void validate_trace(std::vector&& trace, AvmVerifier verifier = composer.create_verifier(circuit_builder); std::vector> public_inputs_as_vec = - bb::avm_trace::copy_public_inputs_columns(public_inputs, calldata); + bb::avm_trace::copy_public_inputs_columns(public_inputs, calldata, returndata); 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..2a64252f9d86 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,9 @@ 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); + std::vector const& returndata = {}, + 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,