From ed2f98ee9d7f540fbdfae09a0117bf22aaf6ebc7 Mon Sep 17 00:00:00 2001 From: Facundo Date: Thu, 20 Jun 2024 11:13:07 +0100 Subject: [PATCH] chore(avm): renamings and comments (#7128) Painful. Also cleaned up the generated files. Some hadn't been deleted when the renaming took place. --- barretenberg/cpp/pil/avm/alu.pil | 90 +- barretenberg/cpp/pil/avm/binary.pil | 26 +- barretenberg/cpp/pil/avm/byte_lookup.pil | 2 +- .../cpp/pil/avm/gadgets/conversion.pil | 6 +- .../cpp/pil/avm/gadgets/keccakf1600.pil | 6 +- barretenberg/cpp/pil/avm/gadgets/pedersen.pil | 7 +- .../cpp/pil/avm/gadgets/poseidon2.pil | 6 +- barretenberg/cpp/pil/avm/gadgets/sha256.pil | 6 +- barretenberg/cpp/pil/avm/gas.pil | 3 +- barretenberg/cpp/pil/avm/kernel.pil | 2 +- barretenberg/cpp/pil/avm/main.pil | 424 +++--- barretenberg/cpp/pil/avm/mem.pil | 109 +- .../relations/generated/avm/alu.hpp | 90 +- .../relations/generated/avm/binary.hpp | 16 +- .../relations/generated/avm/conversion.hpp | 4 +- .../relations/generated/avm/declare_views.hpp | 146 +- .../relations/generated/avm/keccakf1600.hpp | 4 +- .../relations/generated/avm/kernel.hpp | 35 +- .../generated/avm/kernel_output_lookup.hpp | 8 +- .../generated/avm/lookup_byte_lengths.hpp | 8 +- .../generated/avm/lookup_byte_operations.hpp | 14 +- .../generated/avm/lookup_div_u16_0.hpp | 8 +- .../generated/avm/lookup_div_u16_1.hpp | 8 +- .../generated/avm/lookup_div_u16_2.hpp | 8 +- .../generated/avm/lookup_div_u16_3.hpp | 8 +- .../generated/avm/lookup_div_u16_4.hpp | 8 +- .../generated/avm/lookup_div_u16_5.hpp | 8 +- .../generated/avm/lookup_div_u16_6.hpp | 8 +- .../generated/avm/lookup_div_u16_7.hpp | 8 +- .../generated/avm/lookup_into_kernel.hpp | 8 +- .../generated/avm/lookup_mem_rng_chk_hi.hpp | 8 +- .../generated/avm/lookup_mem_rng_chk_lo.hpp | 8 +- .../generated/avm/lookup_mem_rng_chk_mid.hpp | 8 +- .../generated/avm/lookup_opcode_gas.hpp | 22 +- .../generated/avm/lookup_pow_2_0.hpp | 8 +- .../generated/avm/lookup_pow_2_1.hpp | 8 +- .../relations/generated/avm/lookup_u16_0.hpp | 8 +- .../relations/generated/avm/lookup_u16_1.hpp | 8 +- .../relations/generated/avm/lookup_u16_10.hpp | 8 +- .../relations/generated/avm/lookup_u16_11.hpp | 8 +- .../relations/generated/avm/lookup_u16_12.hpp | 8 +- .../relations/generated/avm/lookup_u16_13.hpp | 8 +- .../relations/generated/avm/lookup_u16_14.hpp | 8 +- .../relations/generated/avm/lookup_u16_2.hpp | 8 +- .../relations/generated/avm/lookup_u16_3.hpp | 8 +- .../relations/generated/avm/lookup_u16_4.hpp | 8 +- .../relations/generated/avm/lookup_u16_5.hpp | 8 +- .../relations/generated/avm/lookup_u16_6.hpp | 8 +- .../relations/generated/avm/lookup_u16_7.hpp | 8 +- .../relations/generated/avm/lookup_u16_8.hpp | 8 +- .../relations/generated/avm/lookup_u16_9.hpp | 8 +- .../relations/generated/avm/lookup_u8_0.hpp | 8 +- .../relations/generated/avm/lookup_u8_1.hpp | 8 +- .../relations/generated/avm/main.hpp | 209 +-- .../relations/generated/avm/mem.hpp | 104 +- .../relations/generated/avm/pedersen.hpp | 4 +- .../relations/generated/avm/perm_main_alu.hpp | 14 +- .../relations/generated/avm/perm_main_bin.hpp | 10 +- .../relations/generated/avm/perm_main_cmp.hpp | 102 -- .../generated/avm/perm_main_conv.hpp | 6 +- .../generated/avm/perm_main_mem_a.hpp | 34 +- .../generated/avm/perm_main_mem_b.hpp | 34 +- .../generated/avm/perm_main_mem_c.hpp | 18 +- .../generated/avm/perm_main_mem_d.hpp | 26 +- ...ind_d.hpp => perm_main_mem_ind_addr_a.hpp} | 34 +- ...ind_a.hpp => perm_main_mem_ind_addr_b.hpp} | 34 +- ...ind_b.hpp => perm_main_mem_ind_addr_c.hpp} | 34 +- ...ind_c.hpp => perm_main_mem_ind_addr_d.hpp} | 34 +- .../generated/avm/perm_main_pedersen.hpp | 6 +- .../generated/avm/perm_main_pos2_perm.hpp | 6 +- .../generated/avm/perm_main_sha256.hpp | 102 -- .../relations/generated/avm/poseidon2.hpp | 4 +- .../relations/generated/avm/pow_2_lookups.hpp | 170 --- .../generated/avm/range_check_da_gas_hi.hpp | 8 +- .../generated/avm/range_check_da_gas_lo.hpp | 8 +- .../generated/avm/range_check_l2_gas_hi.hpp | 8 +- .../generated/avm/range_check_l2_gas_lo.hpp | 8 +- .../relations/generated/avm/sha256.hpp | 4 +- .../vm/avm_trace/avm_alu_trace.cpp | 9 - .../vm/avm_trace/avm_alu_trace.hpp | 2 +- .../vm/avm_trace/avm_binary_trace.cpp | 5 - .../vm/avm_trace/avm_binary_trace.hpp | 2 +- .../vm/avm_trace/avm_gas_trace.cpp | 2 - .../vm/avm_trace/avm_gas_trace.hpp | 4 +- .../barretenberg/vm/avm_trace/avm_helper.cpp | 183 +-- .../vm/avm_trace/avm_mem_trace.cpp | 37 +- .../vm/avm_trace/avm_mem_trace.hpp | 49 +- .../barretenberg/vm/avm_trace/avm_trace.cpp | 1068 +++++++------- .../gadgets/avm_conversion_trace.cpp | 8 +- .../gadgets/avm_conversion_trace.hpp | 2 +- .../vm/avm_trace/gadgets/avm_ecc.cpp | 6 +- .../vm/avm_trace/gadgets/avm_ecc.hpp | 3 +- .../vm/avm_trace/gadgets/avm_keccak.cpp | 5 - .../vm/avm_trace/gadgets/avm_keccak.hpp | 2 +- .../vm/avm_trace/gadgets/avm_pedersen.cpp | 5 - .../vm/avm_trace/gadgets/avm_pedersen.hpp | 2 +- .../vm/avm_trace/gadgets/avm_poseidon2.cpp | 5 - .../vm/avm_trace/gadgets/avm_poseidon2.hpp | 4 +- .../vm/avm_trace/gadgets/avm_sha256.cpp | 5 - .../vm/avm_trace/gadgets/avm_sha256.hpp | 3 +- .../vm/generated/avm_circuit_builder.cpp | 387 ++--- .../vm/generated/avm_circuit_builder.hpp | 328 ++--- .../barretenberg/vm/generated/avm_flavor.hpp | 1294 ++++++++--------- .../barretenberg/vm/generated/avm_prover.cpp | 296 ++-- .../vm/generated/avm_verifier.cpp | 209 +-- .../vm/tests/avm_arithmetic.test.cpp | 39 +- .../vm/tests/avm_bitwise.test.cpp | 43 +- .../barretenberg/vm/tests/avm_cast.test.cpp | 188 +-- .../vm/tests/avm_comparison.test.cpp | 17 +- .../vm/tests/avm_control_flow.test.cpp | 59 +- .../vm/tests/avm_execution.test.cpp | 92 +- .../barretenberg/vm/tests/avm_gas.test.cpp | 2 +- .../vm/tests/avm_indirect_mem.test.cpp | 72 +- .../vm/tests/avm_inter_table.test.cpp | 216 +-- .../barretenberg/vm/tests/avm_kernel.test.cpp | 130 +- .../vm/tests/avm_mem_opcodes.test.cpp | 471 +++--- .../barretenberg/vm/tests/helpers.test.cpp | 2 +- .../barretenberg/vm/tests/helpers.test.hpp | 6 +- 118 files changed, 3611 insertions(+), 3954 deletions(-) delete mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cmp.hpp rename barretenberg/cpp/src/barretenberg/relations/generated/avm/{perm_main_mem_ind_d.hpp => perm_main_mem_ind_addr_a.hpp} (75%) rename barretenberg/cpp/src/barretenberg/relations/generated/avm/{perm_main_mem_ind_a.hpp => perm_main_mem_ind_addr_b.hpp} (75%) rename barretenberg/cpp/src/barretenberg/relations/generated/avm/{perm_main_mem_ind_b.hpp => perm_main_mem_ind_addr_c.hpp} (75%) rename barretenberg/cpp/src/barretenberg/relations/generated/avm/{perm_main_mem_ind_c.hpp => perm_main_mem_ind_addr_d.hpp} (75%) delete mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_sha256.hpp delete mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/pow_2_lookups.hpp diff --git a/barretenberg/cpp/pil/avm/alu.pil b/barretenberg/cpp/pil/avm/alu.pil index 5ebf510d2c5..cae0003f39f 100644 --- a/barretenberg/cpp/pil/avm/alu.pil +++ b/barretenberg/cpp/pil/avm/alu.pil @@ -1,5 +1,3 @@ -include "main.pil"; - namespace alu(256); // ========= Table ALU-TR ================================================= @@ -19,14 +17,14 @@ namespace alu(256); pol commit op_eq; pol commit op_cast; pol commit op_cast_prev; // Predicate on whether op_cast is enabled at previous row - pol commit alu_sel; // Predicate to activate the copy of intermediate registers to ALU table. + pol commit sel_alu; // Predicate to activate the copy of intermediate registers to ALU table. pol commit op_lt; pol commit op_lte; - pol commit cmp_sel; // Predicate if LT or LTE is set - pol commit rng_chk_sel; // Predicate representing a range check row. + pol commit sel_cmp; // Predicate if LT or LTE is set + pol commit sel_rng_chk; // Predicate representing a range check row. pol commit op_shl; pol commit op_shr; - pol commit shift_sel; // Predicate if SHR or SHR is set + pol commit sel_shift_which; // Predicate if SHR or SHR is set // Instruction tag (1: u8, 2: u16, 3: u32, 4: u64, 5: u128, 6: field) copied from Main table pol commit in_tag; @@ -64,9 +62,9 @@ namespace alu(256); pol commit cf; // Compute predicate telling whether there is a row entry in the ALU table. - alu_sel = op_add + op_sub + op_mul + op_not + op_eq + op_cast + op_lt + op_lte + op_shr + op_shl + op_div; - cmp_sel = op_lt + op_lte; - shift_sel = op_shl + op_shr; + sel_alu = op_add + op_sub + op_mul + op_not + op_eq + op_cast + op_lt + op_lte + op_shr + op_shl + op_div; + sel_cmp = op_lt + op_lte; + sel_shift_which = op_shl + op_shr; // ========= Type Constraints ============================================= // TODO: Range constraints @@ -86,7 +84,7 @@ namespace alu(256); u128_tag * (1 - u128_tag) = 0; // Mutual exclusion of the flattened instruction tag. - alu_sel * (ff_tag + u8_tag + u16_tag + u32_tag + u64_tag + u128_tag - 1) = 0; + sel_alu * (ff_tag + u8_tag + u16_tag + u32_tag + u64_tag + u128_tag - 1) = 0; // Correct flattening of the instruction tag. in_tag = u8_tag + 2 * u16_tag + 3 * u32_tag + 4 * u64_tag + 5 * u128_tag + 6 * ff_tag; @@ -227,9 +225,9 @@ namespace alu(256); // TODO decide if it is done here or in another trace // Do not allow ff_tag to be set if we are doing bitwise - pol BITWISE_SEL = op_not; // Add more bitwise operations + pol SEL_BITWISE = op_not; // Add more bitwise operations #[ALU_FF_NOT_XOR] - BITWISE_SEL * ff_tag = 0; + SEL_BITWISE * ff_tag = 0; // The value 2^k - 1 pol UINT_MAX = u8_tag * 2**8 + @@ -264,9 +262,9 @@ namespace alu(256); // Need an additional helper that holds the inverse of the difference; pol commit op_eq_diff_inv; - // If EQ or CMP_SEL selector is set, ic needs to be boolean + // If EQ or sel_cmp selector is set, ic needs to be boolean #[ALU_RES_IS_BOOL] - (cmp_sel + op_eq) * (ic * (1 - ic)) = 0; + (sel_cmp + op_eq) * (ic * (1 - ic)) = 0; #[ALU_OP_EQ] op_eq * (DIFF * (ic * (1 - op_eq_diff_inv) + op_eq_diff_inv) - 1 + ic) = 0; @@ -296,13 +294,13 @@ namespace alu(256); pol commit a_hi; // Check INPUT_IA is well formed from its lo and hi limbs #[INPUT_DECOMP_1] - INPUT_IA = (a_lo + 2 ** 128 * a_hi) * (cmp_sel + op_cast); + INPUT_IA = (a_lo + 2 ** 128 * a_hi) * (sel_cmp + op_cast); pol commit b_lo; pol commit b_hi; // Check INPUT_IB is well formed from its lo and hi limbs #[INPUT_DECOMP_2] - INPUT_IB = (b_lo + 2 ** 128 * b_hi) * cmp_sel; + INPUT_IB = (b_lo + 2 ** 128 * b_hi) * sel_cmp; pol commit p_sub_a_lo; // p_lo - a_lo pol commit p_sub_a_hi; // p_hi - a_hi @@ -317,9 +315,9 @@ namespace alu(256); // First condition is if borrow = 0, second condition is if borrow = 1 // This underflow check is done by the 128-bit check that is performed on each of these lo and hi limbs. #[SUB_LO_1] - (p_sub_a_lo - (53438638232309528389504892708671455232 - a_lo + p_a_borrow * 2 ** 128)) * (cmp_sel + op_cast + op_div_std) = 0; + (p_sub_a_lo - (53438638232309528389504892708671455232 - a_lo + p_a_borrow * 2 ** 128)) * (sel_cmp + op_cast + op_div_std) = 0; #[SUB_HI_1] - (p_sub_a_hi - (64323764613183177041862057485226039389 - a_hi - p_a_borrow)) * (cmp_sel + op_cast + op_div_std) = 0; + (p_sub_a_hi - (64323764613183177041862057485226039389 - a_hi - p_a_borrow)) * (sel_cmp + op_cast + op_div_std) = 0; pol commit p_sub_b_lo; pol commit p_sub_b_hi; @@ -330,9 +328,9 @@ namespace alu(256); // This is achieved by checking (p_lo > b_lo && p_hi >= bhi) || (p_lo <= b_lo && p_hi > b_hi) // First condition is if borrow = 0, second condition is if borrow = 1; #[SUB_LO_2] - (p_sub_b_lo - (53438638232309528389504892708671455232 - b_lo + p_b_borrow * 2 ** 128)) * cmp_sel = 0; + (p_sub_b_lo - (53438638232309528389504892708671455232 - b_lo + p_b_borrow * 2 ** 128)) * sel_cmp = 0; #[SUB_HI_2] - (p_sub_b_hi - (64323764613183177041862057485226039389 - b_hi - p_b_borrow)) * cmp_sel = 0; + (p_sub_b_hi - (64323764613183177041862057485226039389 - b_hi - p_b_borrow)) * sel_cmp = 0; // Calculate the combined relation: (a - b - 1) * q + (b -a ) * (1-q) // Check that (a > b) by checking (a_lo > b_lo && a_hi >= bhi) || (alo <= b_lo && a_hi > b_hi) @@ -410,9 +408,9 @@ namespace alu(256); pol commit res_lo; pol commit res_hi; #[RES_LO] - (res_lo - (A_SUB_B_LO * IS_GT + B_SUB_A_LO * (1 - IS_GT))) * cmp_sel = 0; + (res_lo - (A_SUB_B_LO * IS_GT + B_SUB_A_LO * (1 - IS_GT))) * sel_cmp = 0; #[RES_HI] - (res_hi - (A_SUB_B_HI * IS_GT + B_SUB_A_HI * (1 - IS_GT))) * cmp_sel = 0; + (res_hi - (A_SUB_B_HI * IS_GT + B_SUB_A_HI * (1 - IS_GT))) * sel_cmp = 0; // ========= RANGE OPERATIONS =============================== @@ -426,25 +424,25 @@ namespace alu(256); // if this row is a comparison operation, the next range_check_remaining value is set to 4 // it is not set to 5 since we do 1 as part of the comparison. #[CMP_CTR_REL_2] - (cmp_rng_ctr' - 4) * cmp_sel = 0; + (cmp_rng_ctr' - 4) * sel_cmp = 0; - rng_chk_sel * (1 - rng_chk_sel) = 0; - // If we have remaining range checks, we cannot have cmp_sel set. This prevents malicious truncating of the range + sel_rng_chk * (1 - sel_rng_chk) = 0; + // If we have remaining range checks, we cannot have sel_cmp set. This prevents malicious truncating of the range // checks by adding a new LT/LTE operation before all the range checks from the previous computation are complete. - rng_chk_sel * cmp_sel = 0; + sel_rng_chk * sel_cmp = 0; - // rng_chk_sel = 1 when cmp_rng_ctr != 0 and rng_chk_sel = 0 when cmp_rng_ctr = 0; + // sel_rng_chk = 1 when cmp_rng_ctr != 0 and sel_rng_chk = 0 when cmp_rng_ctr = 0; #[CTR_NON_ZERO_REL] - cmp_rng_ctr * ((1 - rng_chk_sel) * (1 - op_eq_diff_inv) + op_eq_diff_inv) - rng_chk_sel = 0; + cmp_rng_ctr * ((1 - sel_rng_chk) * (1 - op_eq_diff_inv) + op_eq_diff_inv) - sel_rng_chk = 0; // We perform a range check if we have some range checks remaining or we are performing a comparison op - pol RNG_CHK_OP = rng_chk_sel + cmp_sel + op_cast + op_cast_prev + shift_lt_bit_len + op_div; + pol RNG_CHK_OP = sel_rng_chk + sel_cmp + op_cast + op_cast_prev + shift_lt_bit_len + op_div; - pol commit rng_chk_lookup_selector; + pol commit sel_rng_chk_lookup; // TODO: Possible optimisation here if we swap the op_shl and op_shr with shift_lt_bit_len. // Shift_lt_bit_len is a more restrictive form therefore we can avoid performing redundant range checks when we know the result == 0. #[RNG_CHK_LOOKUP_SELECTOR] - rng_chk_lookup_selector' = cmp_sel' + rng_chk_sel' + op_add' + op_sub' + op_mul' + op_mul * u128_tag + op_cast' + op_cast_prev' + op_shl' + op_shr' + op_div'; + sel_rng_chk_lookup' = sel_cmp' + sel_rng_chk' + op_add' + op_sub' + op_mul' + op_mul * u128_tag + op_cast' + op_cast_prev' + op_shl' + op_shr' + op_div'; // Perform 128-bit range check on lo part #[LOWER_CMP_RNG_CHK] @@ -463,17 +461,17 @@ namespace alu(256); // Briefly: given a > b and p > a and p > a - b - 1, it is sufficient confirm that p > b without a range check // To accomplish this we would likely change the order of the range_check so we can skip p_sub_b #[SHIFT_RELS_0] - (a_lo' - b_lo) * rng_chk_sel' = 0; - (a_hi' - b_hi) * rng_chk_sel' = 0; + (a_lo' - b_lo) * sel_rng_chk' = 0; + (a_hi' - b_hi) * sel_rng_chk' = 0; #[SHIFT_RELS_1] - (b_lo' - p_sub_a_lo) * rng_chk_sel' = 0; - (b_hi' - p_sub_a_hi) * rng_chk_sel' = 0; + (b_lo' - p_sub_a_lo) * sel_rng_chk' = 0; + (b_hi' - p_sub_a_hi) * sel_rng_chk' = 0; #[SHIFT_RELS_2] - (p_sub_a_lo' - p_sub_b_lo) * rng_chk_sel'= 0; - (p_sub_a_hi' - p_sub_b_hi) * rng_chk_sel'= 0; + (p_sub_a_lo' - p_sub_b_lo) * sel_rng_chk'= 0; + (p_sub_a_hi' - p_sub_b_hi) * sel_rng_chk'= 0; #[SHIFT_RELS_3] - (p_sub_b_lo' - res_lo) * rng_chk_sel'= 0; - (p_sub_b_hi' - res_hi) * rng_chk_sel'= 0; + (p_sub_b_lo' - res_lo) * sel_rng_chk'= 0; + (p_sub_b_hi' - res_hi) * sel_rng_chk'= 0; // ========= CAST Operation Constraints =============================== // We handle the input ia independently of its tag, i.e., we suppose it can take @@ -514,7 +512,7 @@ namespace alu(256); // 128-bit multiplication and CAST need two rows in ALU trace. We need to ensure // that another ALU operation does not start in the second row. #[TWO_LINE_OP_NO_OVERLAP] - (op_mul * u128_tag + op_cast) * alu_sel' = 0; + (op_mul * u128_tag + op_cast) * sel_alu' = 0; // ========= SHIFT LEFT/RIGHT OPERATIONS =============================== // Given (1) an input b, within the range [0, 2**128-1], @@ -600,7 +598,7 @@ namespace alu(256); // There is no chance of an underflow involving ib to result in a t_sub_b_bits < 2**8 ib is range checked to be < 2**8 // The range checking of t_sub_b_bits in the range [0, 2**8) is done by the lookup for 2**t_sub_s_bits #[SHIFT_LT_BIT_LEN] - t_sub_s_bits = shift_sel * (shift_lt_bit_len * (MAX_BITS - ib) + (1 - shift_lt_bit_len) * (ib - MAX_BITS)); + t_sub_s_bits = sel_shift_which * (shift_lt_bit_len * (MAX_BITS - ib) + (1 - shift_lt_bit_len) * (ib - MAX_BITS)); // ========= SHIFT RIGHT OPERATIONS =============================== // a_hi * 2**s + a_lo = a @@ -699,7 +697,7 @@ namespace alu(256); (cmp_rng_ctr' - 2) * op_div_std = 0; // If we have more range checks left we cannot do more divisions operations that might truncate the steps - rng_chk_sel * op_div_std = 0; + sel_rng_chk * op_div_std = 0; // Check PRODUCT = ia - remainder #[DIVISION_RELATION] @@ -710,10 +708,10 @@ namespace alu(256); // TODO: We need extra slice registers because we are performing an additional 64-bit range check in the same row, look into re-using old columns or refactoring // range checks to be more modular. // boolean to account for the division-specific 64-bit range checks. - pol commit div_rng_chk_selector; - div_rng_chk_selector * (1 - div_rng_chk_selector) = 0; - // div_rng_chk_selector && div_rng_chk_selector' = 1 if op_div_std = 1 - div_rng_chk_selector * div_rng_chk_selector' = op_div_std; + pol commit sel_div_rng_chk; + sel_div_rng_chk * (1 - sel_div_rng_chk) = 0; + // sel_div_rng_chk && sel_div_rng_chk' = 1 if op_div_std = 1 + sel_div_rng_chk * sel_div_rng_chk' = op_div_std; pol commit div_u16_r0; pol commit div_u16_r1; diff --git a/barretenberg/cpp/pil/avm/binary.pil b/barretenberg/cpp/pil/avm/binary.pil index 35f27914d58..441f4c56bd1 100644 --- a/barretenberg/cpp/pil/avm/binary.pil +++ b/barretenberg/cpp/pil/avm/binary.pil @@ -7,8 +7,8 @@ namespace binary(256); pol commit clk; // Selector for Binary Operation - pol commit bin_sel; - bin_sel * (1 - bin_sel) = 0; + pol commit sel_bin; + sel_bin * (1 - sel_bin) = 0; // Byte recomposition column, the value in these columns are part of the equivalence // check to main wherever Start is set to 1. @@ -46,31 +46,31 @@ namespace binary(256); #[MEM_TAG_REL] (mem_tag_ctr' - mem_tag_ctr + 1) * mem_tag_ctr = 0; - // Bin_sel is a boolean that is set to 1 if mem_tag_ctr != 0. + // sel_bin is a boolean that is set to 1 if mem_tag_ctr != 0. // This is checked by two relation conditions and utilising mem_tag_ctr_inv pol commit mem_tag_ctr_inv; - // bin_sel is set to 1 when mem_tag_ctr != 0, and 0 otherwise. - // we constrain it such that bin_sel = mem_tag_ctr * mem_tag_ctr_inv unless mem_tag_ctr = 0 the bin_sel = 0 + // sel_bin is set to 1 when mem_tag_ctr != 0, and 0 otherwise. + // we constrain it such that sel_bin = mem_tag_ctr * mem_tag_ctr_inv unless mem_tag_ctr = 0 the sel_bin = 0 // In here we use the consolidated equality relation because it doesnt require us to enforce // this additional relation: mem_tag_ctr_inv = 1 when mem_tag_ctr = 0. (allows default zero value in trace) - #[BIN_SEL_CTR_REL] - mem_tag_ctr * ((1 - bin_sel) * (1 - mem_tag_ctr_inv) + mem_tag_ctr_inv) - bin_sel = 0; + #[SEL_BIN_CTR_REL] + mem_tag_ctr * ((1 - sel_bin) * (1 - mem_tag_ctr_inv) + mem_tag_ctr_inv) - sel_bin = 0; // Forces accumulator to start at zero when mem_tag_ctr == 0 - (1 - bin_sel) * acc_ia = 0; - (1 - bin_sel) * acc_ib = 0; - (1 - bin_sel) * acc_ic = 0; + (1 - sel_bin) * acc_ia = 0; + (1 - sel_bin) * acc_ib = 0; + (1 - sel_bin) * acc_ic = 0; #[LOOKUP_BYTE_LENGTHS] start {in_tag, mem_tag_ctr} in - byte_lookup.bin_sel {byte_lookup.table_in_tags, byte_lookup.table_byte_lengths}; + byte_lookup.sel_bin {byte_lookup.table_in_tags, byte_lookup.table_byte_lengths}; #[LOOKUP_BYTE_OPERATIONS] - bin_sel {op_id, ia_bytes, ib_bytes, ic_bytes} + sel_bin {op_id, ia_bytes, ib_bytes, ic_bytes} in - byte_lookup.bin_sel {byte_lookup.table_op_id, byte_lookup.table_input_a, byte_lookup.table_input_b, byte_lookup.table_output}; + byte_lookup.sel_bin {byte_lookup.table_op_id, byte_lookup.table_input_a, byte_lookup.table_input_b, byte_lookup.table_output}; #[ACC_REL_A] (acc_ia - ia_bytes - 256 * acc_ia') * mem_tag_ctr = 0; diff --git a/barretenberg/cpp/pil/avm/byte_lookup.pil b/barretenberg/cpp/pil/avm/byte_lookup.pil index 58bb7d4ea00..a91272a86e6 100644 --- a/barretenberg/cpp/pil/avm/byte_lookup.pil +++ b/barretenberg/cpp/pil/avm/byte_lookup.pil @@ -8,7 +8,7 @@ namespace byte_lookup(256); pol commit table_output; // output = a AND/OR/XOR b // Selector to indicate when to utilise the lookup table // TODO: Support for 1-sided lookups may make this redundant. - pol commit bin_sel; + pol commit sel_bin; // These two columns are a mapping between instruction tags and their byte lengths // {U8: 1, U16: 2, ... , U128: 16} diff --git a/barretenberg/cpp/pil/avm/gadgets/conversion.pil b/barretenberg/cpp/pil/avm/gadgets/conversion.pil index 4f34f0f7d3f..115a0571075 100644 --- a/barretenberg/cpp/pil/avm/gadgets/conversion.pil +++ b/barretenberg/cpp/pil/avm/gadgets/conversion.pil @@ -1,12 +1,10 @@ -include "../main.pil"; - namespace conversion(256); pol commit clk; // Selector for Radix Operation - pol commit to_radix_le_sel; - to_radix_le_sel * (1 - to_radix_le_sel) = 0; + pol commit sel_to_radix_le; + sel_to_radix_le * (1 - sel_to_radix_le) = 0; // ===== DRAFT: Planned Constraints for To Radix LE // Similar to the binary trace; multi-row decomposition of the input using the number of limbs specified as the row count. diff --git a/barretenberg/cpp/pil/avm/gadgets/keccakf1600.pil b/barretenberg/cpp/pil/avm/gadgets/keccakf1600.pil index c6e814e1be0..72dd78005d7 100644 --- a/barretenberg/cpp/pil/avm/gadgets/keccakf1600.pil +++ b/barretenberg/cpp/pil/avm/gadgets/keccakf1600.pil @@ -1,12 +1,10 @@ -include "../main.pil"; - namespace keccakf1600(256); pol commit clk; // Selector for Keccak Permutation Operation - pol commit keccakf1600_sel; - keccakf1600_sel * (1 - keccakf1600_sel) = 0; + pol commit sel_keccakf1600; + sel_keccakf1600 * (1 - sel_keccakf1600) = 0; // These will all be arrays, but we just store the first element for permutation to the main trace for now pol commit input; diff --git a/barretenberg/cpp/pil/avm/gadgets/pedersen.pil b/barretenberg/cpp/pil/avm/gadgets/pedersen.pil index e38704dbe73..cf881233ca4 100644 --- a/barretenberg/cpp/pil/avm/gadgets/pedersen.pil +++ b/barretenberg/cpp/pil/avm/gadgets/pedersen.pil @@ -1,13 +1,10 @@ - -include "../main.pil"; - namespace pedersen(256); pol commit clk; // Selector for Pedersen Hash Operation - pol commit pedersen_sel; - pedersen_sel * (1 - pedersen_sel) = 0; + pol commit sel_pedersen; + sel_pedersen * (1 - sel_pedersen) = 0; // These will all be arrays, but we just store the first element for permutation to the main trace for now pol commit input; diff --git a/barretenberg/cpp/pil/avm/gadgets/poseidon2.pil b/barretenberg/cpp/pil/avm/gadgets/poseidon2.pil index 95b1990cc27..b89685bc018 100644 --- a/barretenberg/cpp/pil/avm/gadgets/poseidon2.pil +++ b/barretenberg/cpp/pil/avm/gadgets/poseidon2.pil @@ -1,12 +1,10 @@ -include "../main.pil"; - namespace poseidon2(256); pol commit clk; // Selector for Radix Operation - pol commit poseidon_perm_sel; - poseidon_perm_sel * (1 - poseidon_perm_sel) = 0; + pol commit sel_poseidon_perm; + sel_poseidon_perm * (1 - sel_poseidon_perm) = 0; // These will all be arrays, but we just store the first element for permutation to the main trace for now pol commit input; diff --git a/barretenberg/cpp/pil/avm/gadgets/sha256.pil b/barretenberg/cpp/pil/avm/gadgets/sha256.pil index dc88d50ab3d..2de296cbb24 100644 --- a/barretenberg/cpp/pil/avm/gadgets/sha256.pil +++ b/barretenberg/cpp/pil/avm/gadgets/sha256.pil @@ -1,12 +1,10 @@ -include "../main.pil"; - namespace sha256(256); pol commit clk; // Selector for Radix Operation - pol commit sha256_compression_sel; - sha256_compression_sel * (1 - sha256_compression_sel) = 0; + pol commit sel_sha256_compression; + sel_sha256_compression * (1 - sel_sha256_compression) = 0; // These will all be arrays, but we just store the first element for permutation to the main trace for now pol commit state; diff --git a/barretenberg/cpp/pil/avm/gas.pil b/barretenberg/cpp/pil/avm/gas.pil index ab016d1cd12..0a1ed20bdb2 100644 --- a/barretenberg/cpp/pil/avm/gas.pil +++ b/barretenberg/cpp/pil/avm/gas.pil @@ -1,8 +1,7 @@ - namespace gas(256); // TODO: WILL BE FIXED - we should be able to have this be a fixed column / the lookup tables are fixed so require no selectors // TODO: All the columns here will have to be constant (when supported by our powdr fork and proving system) - pol commit gas_cost_sel; + pol commit sel_gas_cost; // TODO(ISSUE_NUMBER): Constrain variable gas costs pol commit l2_gas_fixed_table; diff --git a/barretenberg/cpp/pil/avm/kernel.pil b/barretenberg/cpp/pil/avm/kernel.pil index e713c877e13..f7d402826eb 100644 --- a/barretenberg/cpp/pil/avm/kernel.pil +++ b/barretenberg/cpp/pil/avm/kernel.pil @@ -58,7 +58,7 @@ namespace kernel(256); pol commit emit_l2_to_l1_msg_write_offset; - pol NOT_LAST = (1 - main.last); + pol NOT_LAST = (1 - main.sel_last); // Constraints to increase the offsets when the opcodes are found #[NOTE_HASH_EXISTS_INC_CONSISTENCY_CHECK] diff --git a/barretenberg/cpp/pil/avm/main.pil b/barretenberg/cpp/pil/avm/main.pil index 0389fe25a46..36b2b6e2b97 100644 --- a/barretenberg/cpp/pil/avm/main.pil +++ b/barretenberg/cpp/pil/avm/main.pil @@ -1,4 +1,3 @@ - include "mem.pil"; include "alu.pil"; include "binary.pil"; @@ -14,12 +13,12 @@ include "gadgets/pedersen.pil"; namespace main(256); //===== CONSTANT POLYNOMIALS ================================================== pol constant clk(i) { i }; - pol constant first = [1] + [0]*; // Used mostly to toggle off the first row consisting - // only in first element of shifted polynomials. + pol constant sel_first = [1] + [0]*; // Used mostly to toggle off the first row consisting + // only in first element of shifted polynomials. //===== KERNEL INPUTS ========================================================= // Kernel lookup selector opcodes - pol commit q_kernel_lookup; + pol commit sel_q_kernel_lookup; // CALL CONTEXT pol commit sel_op_sender; @@ -43,7 +42,7 @@ namespace main(256); pol commit sel_op_dagasleft; //===== KERNEL OUTPUTS ======================================================== - pol commit q_kernel_output_lookup; + pol commit sel_q_kernel_output_lookup; pol commit sel_op_note_hash_exists; pol commit sel_op_emit_note_hash; @@ -57,23 +56,24 @@ namespace main(256); pol commit sel_op_sload; pol commit sel_op_sstore; + // TODO: Opcode value (byte) will be constrained by the bytecode validation circuit + pol commit opcode_val; + //===== GAS ACCOUNTING ======================================================== // 1. The gas lookup table (in gas.pil) is constant and maps the opcode value to L2/DA gas (fixed) cost. // 2. Read gas_op from gas table based on the opcode value // 3. TODO(#6588): constrain gas start and gas end - // TODO: Opcode value (byte) will be constrained by the bytecode validation circuit - pol commit opcode_val; - // "gas_remaining" values correspond to the gas quantity which remains BEFORE the execution of the opcode // of the pertaining line. This means that the last value will be written on the row following the last // opcode execution. pol commit l2_gas_remaining; pol commit da_gas_remaining; + // These are the gas costs of the opcode execution. // TODO: allow lookups to evaluate expressions - pol commit l2_gas_op; - pol commit da_gas_op; + pol commit l2_gas_op_cost; + pol commit da_gas_op_cost; // Boolean indicating whether the current opcode gas consumption is higher than remaining gas pol commit l2_out_of_gas; @@ -91,41 +91,41 @@ namespace main(256); // Constrain that the gas decrements correctly per instruction #[L2_GAS_REMAINING_DECREMENT] - gas_cost_active * (l2_gas_remaining' - l2_gas_remaining + l2_gas_op) = 0; + sel_gas_accounting_active * (l2_gas_remaining' - l2_gas_remaining + l2_gas_op_cost) = 0; #[DA_GAS_REMAINING_DECREMENT] - gas_cost_active * (da_gas_remaining' - da_gas_remaining + da_gas_op) = 0; + sel_gas_accounting_active * (da_gas_remaining' - da_gas_remaining + da_gas_op_cost) = 0; // Constrain that the remaining gas is unchanged otherwise (multi-line operations) #[L2_GAS_INACTIVE] - (1 - gas_cost_active) * l2_gas_op = 0; + (1 - sel_gas_accounting_active) * l2_gas_op_cost = 0; #[DA_GAS_INACTIVE] - (1 - gas_cost_active) * da_gas_op = 0; + (1 - sel_gas_accounting_active) * da_gas_op_cost = 0; // TODO: constrain that it stays the same if an opcode selector is not active -> TODO: will this break when the opcode takes multiple rows // So we also need to constrain that it is the first line of the opcodes execution // Prove that l2_out_of_gas == 0 <==> l2_gas_remaining' >= 0 // Same for da gas - // TODO: Ensure that remaining gas values are initialized as u32 and that gas l2_gas_op/da_gas_op are u32. - gas_cost_active * ((1 - 2 * l2_out_of_gas) * l2_gas_remaining' - 2**16 * abs_l2_rem_gas_hi - abs_l2_rem_gas_lo) = 0; - gas_cost_active * ((1 - 2 * da_out_of_gas) * da_gas_remaining' - 2**16 * abs_da_rem_gas_hi - abs_da_rem_gas_lo) = 0; + // TODO: Ensure that remaining gas values are initialized as u32 and that gas l2_gas_op_cost/da_gas_op_cost are u32. + sel_gas_accounting_active * ((1 - 2 * l2_out_of_gas) * l2_gas_remaining' - 2**16 * abs_l2_rem_gas_hi - abs_l2_rem_gas_lo) = 0; + sel_gas_accounting_active * ((1 - 2 * da_out_of_gas) * da_gas_remaining' - 2**16 * abs_da_rem_gas_hi - abs_da_rem_gas_lo) = 0; #[LOOKUP_OPCODE_GAS] - gas_cost_active {opcode_val, l2_gas_op, da_gas_op} + sel_gas_accounting_active {opcode_val, l2_gas_op_cost, da_gas_op_cost} in - gas.gas_cost_sel {clk, gas.l2_gas_fixed_table, gas.da_gas_fixed_table}; + gas.sel_gas_cost {clk, gas.l2_gas_fixed_table, gas.da_gas_fixed_table}; #[RANGE_CHECK_L2_GAS_HI] - gas_cost_active {abs_l2_rem_gas_hi} in sel_rng_16 {clk}; + sel_gas_accounting_active {abs_l2_rem_gas_hi} in sel_rng_16 {clk}; #[RANGE_CHECK_L2_GAS_LO] - gas_cost_active {abs_l2_rem_gas_lo} in sel_rng_16 {clk}; + sel_gas_accounting_active {abs_l2_rem_gas_lo} in sel_rng_16 {clk}; #[RANGE_CHECK_DA_GAS_HI] - gas_cost_active {abs_da_rem_gas_hi} in sel_rng_16 {clk}; + sel_gas_accounting_active {abs_da_rem_gas_hi} in sel_rng_16 {clk}; #[RANGE_CHECK_DA_GAS_LO] - gas_cost_active {abs_da_rem_gas_lo} in sel_rng_16 {clk}; + sel_gas_accounting_active {abs_da_rem_gas_lo} in sel_rng_16 {clk}; //===== Gadget Selectors ====================================================== pol commit sel_op_radix_le; @@ -150,62 +150,47 @@ namespace main(256); // Call Pointer (nested call) pol commit call_ptr; - pol commit sel_internal_call; - pol commit sel_internal_return; - pol commit sel_jump; - pol commit sel_jumpi; - pol commit sel_external_call; + pol commit sel_op_internal_call; + pol commit sel_op_internal_return; + pol commit sel_op_jump; + pol commit sel_op_jumpi; + pol commit sel_op_external_call; // Halt program execution - pol commit sel_halt; + pol commit sel_op_halt; // Memory Space Identifier pol commit space_id; //===== MEMORY OPCODES ========================================================== - pol commit sel_mov; - pol commit sel_cmov; + pol commit sel_op_mov; + pol commit sel_op_cmov; //===== TABLE SUBOP-TR ======================================================== // Boolean selectors for (sub-)operations. Only one operation is activated at // a time. - // ADD pol commit sel_op_add; - // SUB pol commit sel_op_sub; - // MUL pol commit sel_op_mul; - // DIV pol commit sel_op_div; - // FDIV pol commit sel_op_fdiv; - // NOT pol commit sel_op_not; - // EQ pol commit sel_op_eq; - // AND pol commit sel_op_and; - // OR pol commit sel_op_or; - // XOR pol commit sel_op_xor; - // CAST pol commit sel_op_cast; - // LT pol commit sel_op_lt; - // LTE pol commit sel_op_lte; - // SHL pol commit sel_op_shl; - // SHR pol commit sel_op_shr; // Helper selector to characterize an ALU chiplet selector - pol commit alu_sel; + pol commit sel_alu; // Helper selector to characterize a Binary chiplet selector - pol commit bin_sel; + pol commit sel_bin; // Instruction memory tags read/write (1: u8, 2: u16, 3: u32, 4: u64, 5: u128, 6: field) pol commit r_in_tag; @@ -221,6 +206,11 @@ namespace main(256); pol commit inv; pol commit id_zero; // Boolean telling whether id is zero (cmov opcode) + //===== MEMORY MODEL ======================================================== + // ind_addr_a -> (gets resolved to) + // mem_addr_a -> (gets loaded to) + // ia + // Intermediate register values pol commit ia; pol commit ib; @@ -228,40 +218,45 @@ namespace main(256); pol commit id; // Memory operation selector per intermediate register - pol commit mem_op_a; - pol commit mem_op_b; - pol commit mem_op_c; - pol commit mem_op_d; + // They signal that a memory operation is performed on the register. + // This does NOT take into consideration indirections. + pol commit sel_mem_op_a; + pol commit sel_mem_op_b; + pol commit sel_mem_op_c; + pol commit sel_mem_op_d; // Read-write flag per intermediate register: Read = 0, Write = 1 + // This specifies whether the register is read or written to. pol commit rwa; pol commit rwb; pol commit rwc; pol commit rwd; // Indirect register values - pol commit ind_a; - pol commit ind_b; - pol commit ind_c; - pol commit ind_d; - - // Indirect memory operation selector per indirect register - pol commit ind_op_a; - pol commit ind_op_b; - pol commit ind_op_c; - pol commit ind_op_d; + // Cell ind_addr_x holds the indirect address to be resolved into mem_addr_ix. + pol commit ind_addr_a; + pol commit ind_addr_b; + pol commit ind_addr_c; + pol commit ind_addr_d; - // Memory index involved into a memory operation per pertaining intermediate register + // Memory address involved into a memory operation per pertaining intermediate register // We should range constrain it to 32 bits ultimately. For first version of the AVM, // we will assume that these columns are of the right type. - pol commit mem_idx_a; - pol commit mem_idx_b; - pol commit mem_idx_c; - pol commit mem_idx_d; + pol commit mem_addr_a; + pol commit mem_addr_b; + pol commit mem_addr_c; + pol commit mem_addr_d; + + // Indirect memory operation selector per indirect register + // This selects whether ind_addr_x is resolved to mem_addr_ix. + pol commit sel_resolve_ind_addr_a; + pol commit sel_resolve_ind_addr_b; + pol commit sel_resolve_ind_addr_c; + pol commit sel_resolve_ind_addr_d; // Track the last line of the execution trace. It does NOT correspond to the last row of the whole table // of size N. As this depends on the supplied bytecode, this polynomial cannot be constant. - pol commit last; + pol commit sel_last; // Relations on type constraints // TODO: Very likely, we can remove these constraints as the selectors should be derived during @@ -316,26 +311,26 @@ namespace main(256); sel_op_shl * (1 - sel_op_shl) = 0; sel_op_shr * (1 - sel_op_shr) = 0; - sel_internal_call * (1 - sel_internal_call) = 0; - sel_internal_return * (1 - sel_internal_return) = 0; - sel_jump * (1 - sel_jump) = 0; - sel_jumpi * (1 - sel_jumpi) = 0; - sel_halt * (1 - sel_halt) = 0; - sel_external_call * (1 - sel_external_call) = 0; + sel_op_internal_call * (1 - sel_op_internal_call) = 0; + sel_op_internal_return * (1 - sel_op_internal_return) = 0; + sel_op_jump * (1 - sel_op_jump) = 0; + sel_op_jumpi * (1 - sel_op_jumpi) = 0; + sel_op_halt * (1 - sel_op_halt) = 0; + sel_op_external_call * (1 - sel_op_external_call) = 0; // Might be removed if derived from opcode based on a lookup of constants - sel_mov * ( 1 - sel_mov) = 0; - sel_cmov * ( 1 - sel_cmov) = 0; + sel_op_mov * ( 1 - sel_op_mov) = 0; + sel_op_cmov * ( 1 - sel_op_cmov) = 0; op_err * (1 - op_err) = 0; tag_err * (1 - tag_err) = 0; // Potential optimization (boolean constraint derivation from equivalence check to mem)? id_zero * (1 - id_zero) = 0; // Might be removed if derived from opcode based on a lookup of constants - mem_op_a * (1 - mem_op_a) = 0; - mem_op_b * (1 - mem_op_b) = 0; - mem_op_c * (1 - mem_op_c) = 0; - mem_op_d * (1 - mem_op_d) = 0; + sel_mem_op_a * (1 - sel_mem_op_a) = 0; + sel_mem_op_b * (1 - sel_mem_op_b) = 0; + sel_mem_op_c * (1 - sel_mem_op_c) = 0; + sel_mem_op_d * (1 - sel_mem_op_d) = 0; rwa * (1 - rwa) = 0; rwb * (1 - rwb) = 0; @@ -343,21 +338,21 @@ namespace main(256); rwd * (1 - rwd) = 0; // Might be removed if derived from opcode based on a lookup of constants - ind_op_a * (1 - ind_op_a) = 0; - ind_op_b * (1 - ind_op_b) = 0; - ind_op_c * (1 - ind_op_c) = 0; - ind_op_d * (1 - ind_op_d) = 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; + sel_resolve_ind_addr_d * (1 - sel_resolve_ind_addr_d) = 0; // TODO - Potential constraints to be implemented: - // - mem_idx_a, mem_idx_b, mem_idx_c, mem_idx_d to u32 type: + // - mem_addr_a, mem_addr_b, mem_addr_c, mem_addr_d to u32 type: // - For direct memory accesses, this should be enforced by bytecode validation // and instruction decomposition. Namely, in this case, only 32-bit immediate // values should be written into these memory indices. // - For indirect memory accesses, the memory trace constraints ensure that // loaded values come from memory addresses with tag u32. This is enforced in the memory trace - // where each memory entry with flag ind_op_x (for x = a,b,c,d) constrains r_int_tag == 3 (u32). + // where each memory entry with flag sel_resolve_ind_addr_x (for x = a,b,c,d) constrains r_int_tag == 3 (u32). // - // - ind_a, ind_b, ind_c, ind_d to u32 type: Should be guaranteed by bytecode validation and + // - ind_addr_a, ind_addr_b, ind_addr_c, ind_addr_d to u32 type: Should be guaranteed by bytecode validation and // instruction decomposition as only immediate 32-bit values should be written into the indirect registers. // // - 0 <= r_in_tag, w_in_tag <= 6 // This should be constrained by the operation decomposition. @@ -419,38 +414,38 @@ namespace main(256); ); // Ensure that only one kernel lookup is active when the kernel_in_offset is active #[KERNEL_INPUT_ACTIVE_CHECK] - KERNEL_INPUT_SELECTORS * (1 - q_kernel_lookup) = 0; + KERNEL_INPUT_SELECTORS * (1 - sel_q_kernel_lookup) = 0; pol KERNEL_OUTPUT_SELECTORS = ( sel_op_note_hash_exists + sel_op_emit_note_hash + sel_op_nullifier_exists + sel_op_emit_nullifier + sel_op_l1_to_l2_msg_exists + sel_op_emit_unencrypted_log + sel_op_emit_l2_to_l1_msg ); #[KERNEL_OUTPUT_ACTIVE_CHECK] - KERNEL_OUTPUT_SELECTORS * (1 - q_kernel_output_lookup) = 0; + KERNEL_OUTPUT_SELECTORS * (1 - sel_q_kernel_output_lookup) = 0; //===== CONTROL FLOW ======================================================= //===== JUMP =============================================================== #[PC_JUMP] - sel_jump * (pc' - ia) = 0; + sel_op_jump * (pc' - ia) = 0; #[PC_JUMPI] - sel_jumpi * ((1 - id_zero) * (pc' - ia) + id_zero * (pc' - pc - 1)) = 0; + sel_op_jumpi * ((1 - id_zero) * (pc' - ia) + id_zero * (pc' - pc - 1)) = 0; - // TODO: Consolidation with #[PC_JUMP] and sel_internal_call * (pc' - ia) = 0; sel_internal_return * (pc' - ia) = 0; + // TODO: Consolidation with #[PC_JUMP] and sel_op_internal_call * (pc' - ia) = 0; sel_op_internal_return * (pc' - ia) = 0; //===== INTERNAL_CALL ====================================================== // - The program counter in the next row should be equal to the value loaded from the ia register // - We then write the return location (pc + 1) into the call stack (in memory) #[RETURN_POINTER_INCREMENT] - sel_internal_call * (internal_return_ptr' - (internal_return_ptr + 1)) = 0; - sel_internal_call * (internal_return_ptr - mem_idx_b) = 0; - sel_internal_call * (pc' - ia) = 0; - sel_internal_call * ((pc + 1) - ib) = 0; + sel_op_internal_call * (internal_return_ptr' - (internal_return_ptr + 1)) = 0; + sel_op_internal_call * (internal_return_ptr - mem_addr_b) = 0; + sel_op_internal_call * (pc' - ia) = 0; + sel_op_internal_call * ((pc + 1) - ib) = 0; // TODO(md): Below relations may be removed through sub-op table lookup - sel_internal_call * (rwb - 1) = 0; - sel_internal_call * (mem_op_b - 1) = 0; + sel_op_internal_call * (rwb - 1) = 0; + sel_op_internal_call * (sel_mem_op_b - 1) = 0; //===== INTERNAL_RETURN =================================================== // - We load the memory pointer to be the internal_return_ptr @@ -458,44 +453,44 @@ namespace main(256); // - decrement the internal_return_ptr #[RETURN_POINTER_DECREMENT] - sel_internal_return * (internal_return_ptr' - (internal_return_ptr - 1)) = 0; - sel_internal_return * ((internal_return_ptr - 1) - mem_idx_a) = 0; - sel_internal_return * (pc' - ia) = 0; + sel_op_internal_return * (internal_return_ptr' - (internal_return_ptr - 1)) = 0; + sel_op_internal_return * ((internal_return_ptr - 1) - mem_addr_a) = 0; + sel_op_internal_return * (pc' - ia) = 0; // TODO(md): Below relations may be removed through sub-op table lookup - sel_internal_return * rwa = 0; - sel_internal_return * (mem_op_a - 1) = 0; + sel_op_internal_return * rwa = 0; + sel_op_internal_return * (sel_mem_op_a - 1) = 0; //===== CONTROL_FLOW_CONSISTENCY ============================================ - pol INTERNAL_CALL_STACK_SELECTORS = (first + sel_internal_call + sel_internal_return + sel_halt); - pol ALL_CTRL_FLOW_SEL = sel_jump + sel_jumpi + sel_internal_call + sel_internal_return; + pol INTERNAL_CALL_STACK_SELECTORS = (sel_first + sel_op_internal_call + sel_op_internal_return + sel_op_halt); + pol SEL_ALL_CTRL_FLOW = sel_op_jump + sel_op_jumpi + sel_op_internal_call + sel_op_internal_return; - pol ALL_LEFTGAS_SEL = sel_op_dagasleft + sel_op_l2gasleft; - pol ALL_BINARY_SEL = sel_op_and + sel_op_or + sel_op_xor; - pol ALL_GADGET_SEL = sel_op_radix_le + sel_op_sha256 + sel_op_poseidon2 + sel_op_keccak + sel_op_pedersen; - pol ALL_MEMORY_SEL = sel_cmov + sel_mov; - pol OPCODE_SELECTORS = sel_op_fdiv + ALU_ALL_SEL + ALL_BINARY_SEL + ALL_MEMORY_SEL + ALL_GADGET_SEL - + KERNEL_INPUT_SELECTORS + KERNEL_OUTPUT_SELECTORS + ALL_LEFTGAS_SEL; + pol SEL_ALL_LEFTGAS = sel_op_dagasleft + sel_op_l2gasleft; + 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 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; - // TODO: gas_cost_active is activating gas accounting on a given row. All opcode with selectors + // 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 - // setting a newly introduced boolean mem_op_activate_gas which is set in witness generation. + // 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. // Note: External call gas cost is not constrained - pol commit gas_cost_active; - pol commit mem_op_activate_gas; // TODO: remove this one + pol commit sel_gas_accounting_active; + pol commit sel_mem_op_activate_gas; // TODO: remove this one // TODO: remove sload and sstore from here // This temporarily disables gas tracking for sload and sstore because our gas // tracking doesn't work properly for instructions that span multiple rows - gas_cost_active - OPCODE_SELECTORS - ALL_CTRL_FLOW_SEL - sel_op_sload - sel_op_sstore - mem_op_activate_gas = 0; + sel_gas_accounting_active - OPCODE_SELECTORS - SEL_ALL_CTRL_FLOW - sel_op_sload - sel_op_sstore - sel_mem_op_activate_gas = 0; // Program counter must increment if not jumping or returning #[PC_INCREMENT] - (1 - first) * (1 - sel_halt) * OPCODE_SELECTORS * (pc' - (pc + 1)) = 0; + (1 - sel_first) * (1 - sel_op_halt) * OPCODE_SELECTORS * (pc' - (pc + 1)) = 0; - // first == 0 && sel_internal_call == 0 && sel_internal_return == 0 && sel_halt == 0 ==> internal_return_ptr == internal_return_ptr' + // sel_first == 0 && sel_op_internal_call == 0 && sel_op_internal_return == 0 && sel_op_halt == 0 ==> internal_return_ptr == internal_return_ptr' #[INTERNAL_RETURN_POINTER_CONSISTENCY] (1 - INTERNAL_CALL_STACK_SELECTORS) * (internal_return_ptr' - internal_return_ptr) = 0; @@ -503,7 +498,7 @@ namespace main(256); //====== SPACE ID CONSTRAINTS =============================================== #[SPACE_ID_INTERNAL] - (sel_internal_call + sel_internal_return) * (space_id - constants.INTERNAL_CALL_SPACE_ID) = 0; + (sel_op_internal_call + sel_op_internal_return) * (space_id - constants.INTERNAL_CALL_SPACE_ID) = 0; #[SPACE_ID_STANDARD_OPCODES] OPCODE_SELECTORS * (call_ptr - space_id) = 0; @@ -511,49 +506,49 @@ namespace main(256); //====== MEMORY OPCODES CONSTRAINTS ========================================= // TODO: consolidate with zero division error handling - // TODO: Ensure that operation decompostion will ensure mutual exclusivity of sel_cmov and sel_jumpi + // TODO: Ensure that operation decompostion will ensure mutual exclusivity of sel_op_cmov and sel_op_jumpi - // When sel_cmov or sel_jumpi == 1, we need id == 0 <==> id_zero == 0 + // When sel_op_cmov or sel_op_jumpi == 1, we need id == 0 <==> id_zero == 0 // This can be achieved with the 2 following relations. // inv is an extra witness to show that we can invert id, i.e., inv = id^(-1) // If id == 0, we have to set inv = 1 to satisfy the second relation, // because id_zero == 1 from the first relation. #[CMOV_CONDITION_RES_1] - (sel_cmov + sel_jumpi) * (id * inv - 1 + id_zero) = 0; + (sel_op_cmov + sel_op_jumpi) * (id * inv - 1 + id_zero) = 0; #[CMOV_CONDITION_RES_2] - (sel_cmov + sel_jumpi) * id_zero * (1 - inv) = 0; + (sel_op_cmov + sel_op_jumpi) * id_zero * (1 - inv) = 0; // Boolean selectors telling whether we move ia to ic or ib to ic. // Boolean constraints and mutual exclusivity are derived from their - // respective definitions based on sel_mov, sel_cmov, and id_zero. - pol commit sel_mov_a; - pol commit sel_mov_b; + // respective definitions based on sel_op_mov, sel_op_cmov, and id_zero. + pol commit sel_mov_ia_to_ic; + pol commit sel_mov_ib_to_ic; // For MOV, we copy ia to ic. // For CMOV, we copy ia to ic if id is NOT zero, otherwise we copy ib to ic. - sel_mov_a = sel_mov + sel_cmov * (1 - id_zero); - sel_mov_b = sel_cmov * id_zero; + sel_mov_ia_to_ic = sel_op_mov + sel_op_cmov * (1 - id_zero); + sel_mov_ib_to_ic = sel_op_cmov * id_zero; #[MOV_SAME_VALUE_A] - sel_mov_a * (ia - ic) = 0; // Ensure that the correct value is moved/copied. + sel_mov_ia_to_ic * (ia - ic) = 0; // Ensure that the correct value is moved/copied. #[MOV_SAME_VALUE_B] - sel_mov_b * (ib - ic) = 0; // Ensure that the correct value is moved/copied. + sel_mov_ib_to_ic * (ib - ic) = 0; // Ensure that the correct value is moved/copied. #[MOV_MAIN_SAME_TAG] - (sel_mov + sel_cmov) * (r_in_tag - w_in_tag) = 0; + (sel_op_mov + sel_op_cmov) * (r_in_tag - w_in_tag) = 0; //===== ALU CONSTRAINTS ===================================================== - pol ALU_R_TAG_SEL = sel_op_add + sel_op_sub + sel_op_mul + sel_op_div + sel_op_not + sel_op_eq + pol SEL_ALU_R_TAG = sel_op_add + sel_op_sub + sel_op_mul + sel_op_div + sel_op_not + sel_op_eq + sel_op_lt + sel_op_lte + sel_op_shr + sel_op_shl; - pol ALU_W_TAG_SEL = sel_op_cast; - pol ALU_ALL_SEL = ALU_R_TAG_SEL + ALU_W_TAG_SEL; + pol SEL_ALU_W_TAG = sel_op_cast; + pol SEL_ALU_ALL = SEL_ALU_R_TAG + SEL_ALU_W_TAG; // Predicate to activate the copy of intermediate registers to ALU table. If tag_err == 1, // the operation is not copied to the ALU table. - alu_sel = ALU_ALL_SEL * (1 - tag_err) * (1 - op_err); + sel_alu = SEL_ALU_ALL * (1 - tag_err) * (1 - op_err); // Dispatch the correct in_tag for alu - ALU_R_TAG_SEL * (alu_in_tag - r_in_tag) = 0; - ALU_W_TAG_SEL * (alu_in_tag - w_in_tag) = 0; + SEL_ALU_R_TAG * (alu_in_tag - r_in_tag) = 0; + SEL_ALU_W_TAG * (alu_in_tag - w_in_tag) = 0; //===== GASLEFT OPCODES ===================================================== #[L2GASLEFT] @@ -607,53 +602,53 @@ namespace main(256); // Constrain the value of kernel_out_offset to be the correct offset for the operation being performed #[NOTE_HASH_KERNEL_OUTPUT] sel_op_note_hash_exists * (kernel.kernel_out_offset - (kernel.START_NOTE_HASH_EXISTS_WRITE_OFFSET + kernel.note_hash_exist_write_offset)) = 0; - first * kernel.note_hash_exist_write_offset = 0; + sel_first * kernel.note_hash_exist_write_offset = 0; #[EMIT_NOTE_HASH_KERNEL_OUTPUT] sel_op_emit_note_hash * (kernel.kernel_out_offset - (kernel.START_EMIT_NOTE_HASH_WRITE_OFFSET + kernel.emit_note_hash_write_offset)) = 0; - first * kernel.emit_note_hash_write_offset = 0; + sel_first * kernel.emit_note_hash_write_offset = 0; #[NULLIFIER_EXISTS_KERNEL_OUTPUT] sel_op_nullifier_exists * (kernel.kernel_out_offset - ((ib * (kernel.START_NULLIFIER_EXISTS_OFFSET + kernel.nullifier_exists_write_offset)) + ((1 - ib) * (kernel.START_NULLIFIER_NON_EXISTS_OFFSET + kernel.nullifier_non_exists_write_offset)))) = 0; - first * kernel.nullifier_exists_write_offset = 0; - first * kernel.nullifier_non_exists_write_offset = 0; + sel_first * kernel.nullifier_exists_write_offset = 0; + sel_first * kernel.nullifier_non_exists_write_offset = 0; #[EMIT_NULLIFIER_KERNEL_OUTPUT] sel_op_emit_nullifier * (kernel.kernel_out_offset - (kernel.START_EMIT_NULLIFIER_WRITE_OFFSET + kernel.emit_nullifier_write_offset)) = 0; - first * kernel.emit_nullifier_write_offset = 0; + sel_first * kernel.emit_nullifier_write_offset = 0; #[L1_TO_L2_MSG_EXISTS_KERNEL_OUTPUT] sel_op_l1_to_l2_msg_exists * (kernel.kernel_out_offset - (kernel.START_L1_TO_L2_MSG_EXISTS_WRITE_OFFSET + kernel.l1_to_l2_msg_exists_write_offset)) = 0; - first * kernel.l1_to_l2_msg_exists_write_offset = 0; + sel_first * kernel.l1_to_l2_msg_exists_write_offset = 0; #[EMIT_UNENCRYPTED_LOG_KERNEL_OUTPUT] sel_op_emit_unencrypted_log * (kernel.kernel_out_offset - (kernel.START_EMIT_UNENCRYPTED_LOG_WRITE_OFFSET + kernel.emit_unencrypted_log_write_offset)) = 0; - first * kernel.emit_unencrypted_log_write_offset = 0; + sel_first * kernel.emit_unencrypted_log_write_offset = 0; // TODO: Add the equivalent for GETCONTRACTINSTANCE? #[EMIT_L2_TO_L1_MSGS_KERNEL_OUTPUT] sel_op_emit_l2_to_l1_msg * (kernel.kernel_out_offset - (kernel.START_EMIT_L2_TO_l1_MSG + kernel.emit_l2_to_l1_msg_write_offset)) = 0; - first * kernel.emit_l2_to_l1_msg_write_offset = 0; + sel_first * kernel.emit_l2_to_l1_msg_write_offset = 0; #[SLOAD_KERNEL_OUTPUT] sel_op_sload * (kernel.kernel_out_offset - (kernel.START_SLOAD_WRITE_OFFSET + kernel.sload_write_offset)) = 0; - first * kernel.sload_write_offset = 0; + sel_first * kernel.sload_write_offset = 0; #[SSTORE_KERNEL_OUTPUT] sel_op_sstore * (kernel.kernel_out_offset - (kernel.START_SSTORE_WRITE_OFFSET + kernel.sstore_write_offset)) = 0; - first * kernel.sstore_write_offset = 0; + sel_first * kernel.sstore_write_offset = 0; // When we encounter a state writing opcode // We increment the side effect counter by 1 KERNEL_OUTPUT_SELECTORS * (kernel.side_effect_counter' - (kernel.side_effect_counter + 1)) = 0; #[KERNEL_OUTPUT_LOOKUP] - 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}; + 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] - q_kernel_lookup { main.ia, kernel.kernel_in_offset } in kernel.q_public_input_kernel_add_to_table { kernel.kernel_inputs, clk }; + 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] @@ -663,11 +658,11 @@ namespace main(256); tag_err {clk} in mem.tag_err {mem.clk}; #[PERM_MAIN_ALU] - alu_sel {clk, ia, ib, ic, sel_op_add, sel_op_sub, + sel_alu {clk, ia, ib, ic, sel_op_add, sel_op_sub, sel_op_mul, sel_op_div, sel_op_eq, sel_op_not, sel_op_cast, sel_op_lt, sel_op_lte, sel_op_shr, sel_op_shl, alu_in_tag} is - alu.alu_sel {alu.clk, alu.ia, alu.ib, alu.ic, alu.op_add, alu.op_sub, + alu.sel_alu {alu.clk, alu.ia, alu.ib, alu.ic, alu.op_add, alu.op_sub, alu.op_mul, alu.op_div, alu.op_eq, alu.op_not, alu.op_cast, alu.op_lt, alu.op_lte, alu.op_shr, alu.op_shl, alu.in_tag}; @@ -679,187 +674,182 @@ namespace main(256); bin_op_id = sel_op_or + 2 * sel_op_xor; // sel_op_and excluded since op_id = 0 for op_and // Only 1 of the binary selectors should be set (i.e. Mutual Exclusivity) - // Bin_sel is not explicitly constrained to be boolean, however this is enforced through + // sel_Bin is not explicitly constrained to be boolean, however this is enforced through // the operation decomposition step during bytecode unpacking. #[BIN_SEL_2] - bin_sel = sel_op_and + sel_op_or + sel_op_xor; + sel_bin = sel_op_and + sel_op_or + sel_op_xor; #[PERM_MAIN_BIN] - bin_sel {clk, ia, ib, ic, bin_op_id, r_in_tag} + sel_bin {clk, ia, ib, ic, bin_op_id, r_in_tag} is binary.start {binary.clk, binary.acc_ia, binary.acc_ib, binary.acc_ic, binary.op_id, binary.in_tag}; #[PERM_MAIN_CONV] sel_op_radix_le {clk, ia, ic, id} is - conversion.to_radix_le_sel {conversion.clk, conversion.input, conversion.radix, conversion.num_limbs}; + conversion.sel_to_radix_le {conversion.clk, conversion.input, conversion.radix, conversion.num_limbs}; // This will be enabled when we migrate just to sha256Compression, as getting sha256 to work with it is tricky. // #[PERM_MAIN_SHA256] // sel_op_sha256 {clk, ia, ib, ic} // is - // sha256.sha256_compression_sel {sha256.clk, sha256.state, sha256.input, sha256.output}; + // sha256.sel_sha256_compression {sha256.clk, sha256.state, sha256.input, sha256.output}; #[PERM_MAIN_POS2_PERM] sel_op_poseidon2 {clk, ia, ib} is - poseidon2.poseidon_perm_sel {poseidon2.clk, poseidon2.input, poseidon2.output}; + poseidon2.sel_poseidon_perm {poseidon2.clk, poseidon2.input, poseidon2.output}; // This will be enabled when we migrate just to keccakf1600, as getting keccak to work with it is tricky. // #[PERM_MAIN_KECCAK] // sel_op_keccak {clk, ia, ic} // is - // keccakf1600.keccakf1600_sel {keccakf1600.clk, keccakf1600.input, keccakf1600.output}; + // keccakf1600.sel_keccakf1600 {keccakf1600.clk, keccakf1600.input, keccakf1600.output}; #[PERM_MAIN_PEDERSEN] sel_op_pedersen {clk, ia} is - pedersen.pedersen_sel {pedersen.clk, pedersen.input}; + pedersen.sel_pedersen {pedersen.clk, pedersen.input}; #[PERM_MAIN_MEM_A] - mem_op_a {clk, space_id, mem_idx_a, ia, rwa - , r_in_tag, w_in_tag, sel_mov_a, sel_cmov} + 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 - mem.op_a {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw - , mem.r_in_tag, mem.w_in_tag, mem.sel_mov_a, mem.sel_cmov}; + mem.sel_op_a {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw + , mem.r_in_tag, mem.w_in_tag, mem.sel_mov_ia_to_ic, mem.sel_op_cmov}; #[PERM_MAIN_MEM_B] - mem_op_b {clk, space_id, mem_idx_b, ib, rwb - , r_in_tag, w_in_tag, sel_mov_b, sel_cmov} + sel_mem_op_b {clk, space_id, mem_addr_b, ib, rwb, r_in_tag, w_in_tag, sel_mov_ib_to_ic, sel_op_cmov} is - mem.op_b {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw - , mem.r_in_tag, mem.w_in_tag, mem.sel_mov_b, mem.sel_cmov}; + mem.sel_op_b {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw + , mem.r_in_tag, mem.w_in_tag, mem.sel_mov_ib_to_ic, mem.sel_op_cmov}; #[PERM_MAIN_MEM_C] - mem_op_c {clk, space_id, mem_idx_c, ic, rwc - , r_in_tag, w_in_tag} + sel_mem_op_c {clk, space_id, mem_addr_c, ic, rwc, r_in_tag, w_in_tag} is - mem.op_c {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw - , mem.r_in_tag, mem.w_in_tag}; + mem.sel_op_c {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw, mem.r_in_tag, mem.w_in_tag}; #[PERM_MAIN_MEM_D] - mem_op_d {clk, space_id, mem_idx_d, id, rwd - , r_in_tag, w_in_tag, sel_cmov} + sel_mem_op_d {clk, space_id, mem_addr_d, id, rwd, r_in_tag, w_in_tag, sel_op_cmov} is - mem.op_d {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw - , mem.r_in_tag, mem.w_in_tag, mem.sel_cmov}; + mem.sel_op_d {mem.clk, mem.space_id, mem.addr, mem.val, mem.rw + , mem.r_in_tag, mem.w_in_tag, mem.sel_op_cmov}; - #[PERM_MAIN_MEM_IND_A] - ind_op_a {clk, space_id, ind_a, mem_idx_a} + #[PERM_MAIN_MEM_IND_ADDR_A] + sel_resolve_ind_addr_a {clk, space_id, ind_addr_a, mem_addr_a} is - mem.ind_op_a {mem.clk, mem.space_id, mem.addr, mem.val}; + mem.sel_resolve_ind_addr_a {mem.clk, mem.space_id, mem.addr, mem.val}; - #[PERM_MAIN_MEM_IND_B] - ind_op_b {clk, space_id, ind_b, mem_idx_b} + #[PERM_MAIN_MEM_IND_ADDR_B] + sel_resolve_ind_addr_b {clk, space_id, ind_addr_b, mem_addr_b} is - mem.ind_op_b {mem.clk, mem.space_id, mem.addr, mem.val}; + mem.sel_resolve_ind_addr_b {mem.clk, mem.space_id, mem.addr, mem.val}; - #[PERM_MAIN_MEM_IND_C] - ind_op_c {clk, space_id, ind_c, mem_idx_c} + #[PERM_MAIN_MEM_IND_ADDR_C] + sel_resolve_ind_addr_c {clk, space_id, ind_addr_c, mem_addr_c} is - mem.ind_op_c {mem.clk, mem.space_id, mem.addr, mem.val}; + mem.sel_resolve_ind_addr_c {mem.clk, mem.space_id, mem.addr, mem.val}; - #[PERM_MAIN_MEM_IND_D] - ind_op_d {clk, space_id, ind_d, mem_idx_d} + #[PERM_MAIN_MEM_IND_ADDR_D] + sel_resolve_ind_addr_d {clk, space_id, ind_addr_d, mem_addr_d} is - mem.ind_op_d {mem.clk, mem.space_id, mem.addr, mem.val}; + mem.sel_resolve_ind_addr_d {mem.clk, mem.space_id, mem.addr, mem.val}; #[LOOKUP_MEM_RNG_CHK_LO] - mem.rng_chk_sel {mem.diff_lo} in sel_rng_16 {clk}; + mem.sel_rng_chk {mem.diff_lo} in sel_rng_16 {clk}; #[LOOKUP_MEM_RNG_CHK_MID] - mem.rng_chk_sel {mem.diff_mid} in sel_rng_16 {clk}; + mem.sel_rng_chk {mem.diff_mid} in sel_rng_16 {clk}; #[LOOKUP_MEM_RNG_CHK_HI] - mem.rng_chk_sel {mem.diff_hi} in sel_rng_8 {clk}; + mem.sel_rng_chk {mem.diff_hi} in sel_rng_8 {clk}; //====== Inter-table Shift Constraints (Lookups) ============================================ // Currently only used for shift operations but can be generalised for other uses. // Lookup for 2**(ib) #[LOOKUP_POW_2_0] - alu.shift_sel {alu.ib, alu.two_pow_s} in sel_rng_8 {clk, table_pow_2}; + alu.sel_shift_which {alu.ib, alu.two_pow_s} in sel_rng_8 {clk, table_pow_2}; // Lookup for 2**(t-ib) #[LOOKUP_POW_2_1] - alu.shift_sel {alu.t_sub_s_bits , alu.two_pow_t_sub_s} in sel_rng_8 {clk, table_pow_2}; + alu.sel_shift_which {alu.t_sub_s_bits , alu.two_pow_t_sub_s} in sel_rng_8 {clk, table_pow_2}; //====== Inter-table Constraints (Range Checks) ============================================ // TODO: Investigate optimising these range checks. Handling non-FF elements should require less range checks. // One can increase the granularity based on the operation and tag. In the most extreme case, // a specific selector per register might be introduced. #[LOOKUP_U8_0] - alu.rng_chk_lookup_selector { alu.u8_r0 } in sel_rng_8 { clk }; + alu.sel_rng_chk_lookup { alu.u8_r0 } in sel_rng_8 { clk }; #[LOOKUP_U8_1] - alu.rng_chk_lookup_selector { alu.u8_r1 } in sel_rng_8 { clk }; + alu.sel_rng_chk_lookup { alu.u8_r1 } in sel_rng_8 { clk }; #[LOOKUP_U16_0] - alu.rng_chk_lookup_selector {alu.u16_r0 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r0 } in sel_rng_16 { clk }; #[LOOKUP_U16_1] - alu.rng_chk_lookup_selector {alu.u16_r1 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r1 } in sel_rng_16 { clk }; #[LOOKUP_U16_2] - alu.rng_chk_lookup_selector {alu.u16_r2 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r2 } in sel_rng_16 { clk }; #[LOOKUP_U16_3] - alu.rng_chk_lookup_selector {alu.u16_r3 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r3 } in sel_rng_16 { clk }; #[LOOKUP_U16_4] - alu.rng_chk_lookup_selector {alu.u16_r4 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r4 } in sel_rng_16 { clk }; #[LOOKUP_U16_5] - alu.rng_chk_lookup_selector {alu.u16_r5 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r5 } in sel_rng_16 { clk }; #[LOOKUP_U16_6] - alu.rng_chk_lookup_selector {alu.u16_r6 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r6 } in sel_rng_16 { clk }; #[LOOKUP_U16_7] - alu.rng_chk_lookup_selector {alu.u16_r7 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r7 } in sel_rng_16 { clk }; #[LOOKUP_U16_8] - alu.rng_chk_lookup_selector {alu.u16_r8 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r8 } in sel_rng_16 { clk }; #[LOOKUP_U16_9] - alu.rng_chk_lookup_selector {alu.u16_r9 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r9 } in sel_rng_16 { clk }; #[LOOKUP_U16_10] - alu.rng_chk_lookup_selector {alu.u16_r10 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r10 } in sel_rng_16 { clk }; #[LOOKUP_U16_11] - alu.rng_chk_lookup_selector {alu.u16_r11 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r11 } in sel_rng_16 { clk }; #[LOOKUP_U16_12] - alu.rng_chk_lookup_selector {alu.u16_r12 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r12 } in sel_rng_16 { clk }; #[LOOKUP_U16_13] - alu.rng_chk_lookup_selector {alu.u16_r13 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r13 } in sel_rng_16 { clk }; #[LOOKUP_U16_14] - alu.rng_chk_lookup_selector {alu.u16_r14 } in sel_rng_16 { clk }; + alu.sel_rng_chk_lookup { alu.u16_r14 } in sel_rng_16 { clk }; // ==== Additional row range checks for division #[LOOKUP_DIV_U16_0] - alu.div_rng_chk_selector {alu.div_u16_r0} in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r0 } in sel_rng_16 { clk }; #[LOOKUP_DIV_U16_1] - alu.div_rng_chk_selector {alu.div_u16_r1 } in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r1 } in sel_rng_16 { clk }; #[LOOKUP_DIV_U16_2] - alu.div_rng_chk_selector {alu.div_u16_r2 } in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r2 } in sel_rng_16 { clk }; #[LOOKUP_DIV_U16_3] - alu.div_rng_chk_selector {alu.div_u16_r3 } in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r3 } in sel_rng_16 { clk }; #[LOOKUP_DIV_U16_4] - alu.div_rng_chk_selector {alu.div_u16_r4 } in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r4 } in sel_rng_16 { clk }; #[LOOKUP_DIV_U16_5] - alu.div_rng_chk_selector {alu.div_u16_r5 } in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r5 } in sel_rng_16 { clk }; #[LOOKUP_DIV_U16_6] - alu.div_rng_chk_selector {alu.div_u16_r6 } in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r6 } in sel_rng_16 { clk }; #[LOOKUP_DIV_U16_7] - alu.div_rng_chk_selector {alu.div_u16_r7 } in sel_rng_16 { clk }; + alu.sel_div_rng_chk { alu.div_u16_r7 } in sel_rng_16 { clk }; diff --git a/barretenberg/cpp/pil/avm/mem.pil b/barretenberg/cpp/pil/avm/mem.pil index c999e7196f1..a5aa3080f03 100644 --- a/barretenberg/cpp/pil/avm/mem.pil +++ b/barretenberg/cpp/pil/avm/mem.pil @@ -12,31 +12,31 @@ namespace mem(256); pol commit rw; // Enum: 0 (read), 1 (write) pol commit lastAccess; // Boolean (1 when this row is the last of a given address) pol commit last; // Boolean indicating the last row of the memory trace (not execution trace) - pol commit mem_sel; // Selector for every row pertaining to the memory trace - pol commit rng_chk_sel; // Selector for row on which range-checks apply. + pol commit sel_mem; // Selector for every row pertaining to the memory trace + pol commit sel_rng_chk; // Selector for row on which range-checks apply. pol commit r_in_tag; // Instruction memory tag ("foreign key" pointing to main.r_in_tag) pol commit w_in_tag; // Instruction memory tag ("foreign key" pointing to main.w_in_tag) pol commit skip_check_tag; // A boolean value which relaxes the consistency check in memory // trace between tag and r_in_tag. Required for CMOV opcode. - // Indicator of the intermediate register pertaining to the memory operation (foreign key to main.mem_op_XXX) - pol commit op_a; - pol commit op_b; - pol commit op_c; - pol commit op_d; + // Indicator of the intermediate register pertaining to the memory operation (foreign key to main.sel_mem_op_XXX) + pol commit sel_op_a; + pol commit sel_op_b; + pol commit sel_op_c; + pol commit sel_op_d; - // Indicator of the indirect register pertaining to the memory operation (foreign key to main.ind_op_XXX) - pol commit ind_op_a; - pol commit ind_op_b; - pol commit ind_op_c; - pol commit ind_op_d; + // Indicator of the indirect register pertaining to the memory operation (foreign key to main.sel_resolve_ind_addr_XXX) + pol commit sel_resolve_ind_addr_a; + pol commit sel_resolve_ind_addr_b; + pol commit sel_resolve_ind_addr_c; + pol commit sel_resolve_ind_addr_d; // 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_a; - pol commit sel_mov_b; - pol commit sel_cmov; + pol commit sel_mov_ia_to_ic; + pol commit sel_mov_ib_to_ic; + pol commit sel_op_cmov; // Error columns pol commit tag_err; // Boolean (1 if r_in_tag != tag is detected) @@ -53,38 +53,39 @@ namespace mem(256); last * (1 - last) = 0; rw * (1 - rw) = 0; tag_err * (1 - tag_err) = 0; - op_a * (1 - op_a) = 0; - op_b * (1 - op_b) = 0; - op_c * (1 - op_c) = 0; - op_d * (1 - op_d) = 0; - ind_op_a * (1 - ind_op_a) = 0; - ind_op_b * (1 - ind_op_b) = 0; - ind_op_c * (1 - ind_op_c) = 0; - ind_op_d * (1 - ind_op_d) = 0; + sel_op_a * (1 - sel_op_a) = 0; + 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_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; + sel_resolve_ind_addr_d * (1 - sel_resolve_ind_addr_d) = 0; // TODO: 1) Ensure that addr is constrained to be 32 bits by the main trace and/or bytecode decomposition // 2) Ensure that tag, r_in_tag, w_in_tag are properly constrained by the main trace and/or bytecode decomposition - // Definition of mem_sel - mem_sel = op_a + op_b + op_c + op_d + ind_op_a + ind_op_b + ind_op_c + ind_op_d; + // 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; // Maximum one memory operation enabled per row - mem_sel * (mem_sel - 1) = 0; // TODO: might be infered by the main trace + sel_mem * (sel_mem - 1) = 0; // TODO: might be infered by the main trace // Enforce the memory entries to be contiguous, i.e., as soon as - // mem_sel is disabled all subsequent rows have mem_sel disabled. + // sel_mem is disabled all subsequent rows have sel_mem disabled. #[MEM_CONTIGUOUS] - (1 - main.first) * mem_sel' * (1 - mem_sel) = 0; + (1 - main.sel_first) * sel_mem' * (1 - sel_mem) = 0; // Memory trace rows cannot start at first row #[MEM_FIRST_EMPTY] - main.first * mem_sel = 0; + main.sel_first * sel_mem = 0; - // Definition of last, i.e., last row with mem_sel activated + // Definition of last, i.e., last row with sel_mem activated #[MEM_LAST] - (1 - last) * mem_sel * (1 - mem_sel') = 0; + (1 - last) * sel_mem * (1 - sel_mem') = 0; - // Definition of rng_chk_sel. It is a boolean as mem_sel and last are booleans. - rng_chk_sel = mem_sel * (1 - last); + // Definition of sel_rng_chk. It is a boolean as sel_mem and last are booleans. + sel_rng_chk = sel_mem * (1 - last); // sub_clk derivation // Current sub_clk range is [0,12) which is subdivided as follows: @@ -94,9 +95,9 @@ namespace mem(256); // Each sub-range of 4 values correspond to registers ordered as a, b, c, d. pol NUM_SUB_CLK = 12; - pol IND_OP = ind_op_a + ind_op_b + ind_op_c + ind_op_d; - pol SUB_CLK = mem_sel * (ind_op_b + op_b + 2 * (ind_op_c + op_c) + 3 * (ind_op_d + op_d) + 4 * (1 - IND_OP + rw)); - // We need the mem_sel factor as the right factor is not zero when all columns are zero. + pol IND_OP = sel_resolve_ind_addr_a + sel_resolve_ind_addr_b + sel_resolve_ind_addr_c + sel_resolve_ind_addr_d; + 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. #[TIMESTAMP] tsp = NUM_SUB_CLK * clk + SUB_CLK; @@ -105,13 +106,13 @@ namespace mem(256); glob_addr = space_id * 2**32 + addr; #[LAST_ACCESS_FIRST_ROW] - main.first * (1 - lastAccess) = 0; + main.sel_first * (1 - lastAccess) = 0; // Remark: lastAccess == 1 on first row and therefore any relation with the - // multiplicative term (1 - lastAccess) implicitly includes (1 - main.first) + // multiplicative term (1 - lastAccess) implicitly includes (1 - main.sel_first) // Similarly, this includes (1 - last) as well. // lastAccess == 0 ==> glob_addr' == glob_addr - // Optimization: We removed the term (1 - main.first) + // Optimization: We removed the term (1 - main.sel_first) #[MEM_LAST_ACCESS_DELIMITER] (1 - lastAccess) * (glob_addr' - glob_addr) = 0; @@ -120,8 +121,8 @@ namespace mem(256); // This condition does not apply on the last row. // In addition, we need glob_addr' == glob_addr ==> tsp' > tsp - // For all rows pertaining to the memory trace (mem_sel == 1) except the last one, - // i.e., when rng_chk_sel == 1, we compute the difference: + // For all rows pertaining to the memory trace (sel_mem == 1) except the last one, + // i.e., when sel_rng_chk == 1, we compute the difference: // 1) glob_addr' - glob_addr if lastAccess == 1 // 2) tsp' - tsp if lastAccess == 0 (i.e., whenever glob_addr' == glob_addr) pol DIFF = lastAccess * (glob_addr' - glob_addr) + (1 - lastAccess) * (tsp' - tsp); @@ -131,19 +132,19 @@ namespace mem(256); // Therefore, we ensure proper grouping of each global address and each memory access pertaining to a given // global address is sorted according the arrow of time. #[DIFF_RNG_CHK_DEC] - rng_chk_sel * (DIFF - diff_hi * 2**32 - diff_mid * 2**16 - diff_lo) = 0; + sel_rng_chk * (DIFF - diff_hi * 2**32 - diff_mid * 2**16 - diff_lo) = 0; // lastAccess == 0 && rw' == 0 ==> val == val' // This condition does not apply on the last row. // Note: in barretenberg, a shifted polynomial will be 0 on the last row (shift is not cyclic) // Note2: in barretenberg, if a poynomial is shifted, its non-shifted equivalent must be 0 on the first row - // Optimization: We removed the term (1 - main.first) and (1 - last) + // Optimization: We removed the term (1 - main.sel_first) and (1 - last) #[MEM_READ_WRITE_VAL_CONSISTENCY] (1 - lastAccess) * (1 - rw') * (val' - val) = 0; // lastAccess == 0 && rw' == 0 ==> tag == tag' - // Optimization: We removed the term (1 - main.first) and (1 - last) + // Optimization: We removed the term (1 - main.sel_first) and (1 - last) #[MEM_READ_WRITE_TAG_CONSISTENCY] (1 - lastAccess) * (1 - rw') * (tag' - tag) = 0; @@ -155,7 +156,7 @@ namespace mem(256); // Skip check tag #[SKIP_CHECK_TAG] - skip_check_tag = sel_cmov * (op_d + op_a * (1-sel_mov_a) + op_b * (1-sel_mov_b)); + 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)); // Memory tag consistency check for load operations, i.e., rw == 0. // We want to prove that r_in_tag == tag <==> tag_err == 0 @@ -191,16 +192,16 @@ namespace mem(256); //====== Indirect Memory Constraints ===================================== // Enforce r_in_tag == 3, i.e., r_in_tag must be U32 - ind_op_a * (r_in_tag - 3) = 0; - ind_op_b * (r_in_tag - 3) = 0; - ind_op_c * (r_in_tag - 3) = 0; - ind_op_d * (r_in_tag - 3) = 0; + sel_resolve_ind_addr_a * (r_in_tag - 3) = 0; + sel_resolve_ind_addr_b * (r_in_tag - 3) = 0; + sel_resolve_ind_addr_c * (r_in_tag - 3) = 0; + sel_resolve_ind_addr_d * (r_in_tag - 3) = 0; // Indirect operation is always a load - ind_op_a * rw = 0; - ind_op_b * rw = 0; - ind_op_c * rw = 0; - ind_op_d * rw = 0; + sel_resolve_ind_addr_a * rw = 0; + sel_resolve_ind_addr_b * rw = 0; + sel_resolve_ind_addr_c * rw = 0; + sel_resolve_ind_addr_d * rw = 0; //====== MOV/CMOV Opcode Tag Constraint ===================================== // The following constraint ensures that the r_in_tag is set to tag for @@ -210,4 +211,4 @@ namespace mem(256); // Constraint #[MOV_MAIN_SAME_TAG] copies r_in_tag to w_in_tag in the main // trace. Then, #[PERM_MAIN_MEM_C] copies w_in_tag for store operation from Ic. #[MOV_SAME_TAG] - (sel_mov_a + sel_mov_b) * tag_err = 0; // Equivalent to (sel_mov_a + sel_mov_b) * (r_in_tag - tag) = 0 \ No newline at end of file + (sel_mov_ia_to_ic + sel_mov_ib_to_ic) * tag_err = 0; // Equivalent to (sel_mov_ia_to_ic + sel_mov_ib_to_ic) * (r_in_tag - tag) = 0 \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/alu.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/alu.hpp index f1d0c3163cc..eda58900a6e 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/alu.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/alu.hpp @@ -11,8 +11,6 @@ template struct AluRow { FF alu_a_hi_shift{}; FF alu_a_lo{}; FF alu_a_lo_shift{}; - FF alu_alu_sel{}; - FF alu_alu_sel_shift{}; FF alu_b_hi{}; FF alu_b_hi_shift{}; FF alu_b_lo{}; @@ -21,10 +19,6 @@ template struct AluRow { FF alu_cf{}; FF alu_cmp_rng_ctr{}; FF alu_cmp_rng_ctr_shift{}; - FF alu_cmp_sel{}; - FF alu_cmp_sel_shift{}; - FF alu_div_rng_chk_selector{}; - FF alu_div_rng_chk_selector_shift{}; FF alu_div_u16_r0{}; FF alu_div_u16_r0_shift{}; FF alu_div_u16_r1{}; @@ -88,11 +82,17 @@ template struct AluRow { FF alu_remainder{}; FF alu_res_hi{}; FF alu_res_lo{}; - FF alu_rng_chk_lookup_selector_shift{}; - FF alu_rng_chk_sel{}; - FF alu_rng_chk_sel_shift{}; + FF alu_sel_alu{}; + FF alu_sel_alu_shift{}; + FF alu_sel_cmp{}; + FF alu_sel_cmp_shift{}; + FF alu_sel_div_rng_chk{}; + FF alu_sel_div_rng_chk_shift{}; + FF alu_sel_rng_chk{}; + FF alu_sel_rng_chk_lookup_shift{}; + FF alu_sel_rng_chk_shift{}; + FF alu_sel_shift_which{}; FF alu_shift_lt_bit_len{}; - FF alu_shift_sel{}; FF alu_t_sub_s_bits{}; FF alu_two_pow_s{}; FF alu_two_pow_t_sub_s{}; @@ -296,7 +296,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(0); - auto tmp = (alu_alu_sel - + auto tmp = (alu_sel_alu - ((((((((((alu_op_add + alu_op_sub) + alu_op_mul) + alu_op_not) + alu_op_eq) + alu_op_cast) + alu_op_lt) + alu_op_lte) + @@ -310,7 +310,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(1); - auto tmp = (alu_cmp_sel - (alu_op_lt + alu_op_lte)); + auto tmp = (alu_sel_cmp - (alu_op_lt + alu_op_lte)); tmp *= scaling_factor; std::get<1>(evals) += tmp; } @@ -318,7 +318,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(2); - auto tmp = (alu_shift_sel - (alu_op_shl + alu_op_shr)); + auto tmp = (alu_sel_shift_which - (alu_op_shl + alu_op_shr)); tmp *= scaling_factor; std::get<2>(evals) += tmp; } @@ -383,7 +383,7 @@ template class aluImpl { Avm_DECLARE_VIEWS(10); auto tmp = - (alu_alu_sel * + (alu_sel_alu * ((((((alu_ff_tag + alu_u8_tag) + alu_u16_tag) + alu_u32_tag) + alu_u64_tag) + alu_u128_tag) - FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; @@ -557,7 +557,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(22); - auto tmp = ((alu_cmp_sel + alu_op_eq) * (alu_ic * (-alu_ic + FF(1)))); + auto tmp = ((alu_sel_cmp + alu_op_eq) * (alu_ic * (-alu_ic + FF(1)))); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -577,7 +577,7 @@ template class aluImpl { Avm_DECLARE_VIEWS(24); auto tmp = (((alu_op_lt * alu_ib) + ((alu_op_lte + alu_op_cast) * alu_ia)) - - ((alu_a_lo + (alu_a_hi * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL }))) * (alu_cmp_sel + alu_op_cast))); + ((alu_a_lo + (alu_a_hi * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL }))) * (alu_sel_cmp + alu_op_cast))); tmp *= scaling_factor; std::get<24>(evals) += tmp; } @@ -586,7 +586,7 @@ template class aluImpl { Avm_DECLARE_VIEWS(25); auto tmp = (((alu_op_lt * alu_ia) + (alu_op_lte * alu_ib)) - - ((alu_b_lo + (alu_b_hi * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL }))) * alu_cmp_sel)); + ((alu_b_lo + (alu_b_hi * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL }))) * alu_sel_cmp)); tmp *= scaling_factor; std::get<25>(evals) += tmp; } @@ -605,7 +605,7 @@ template class aluImpl { auto tmp = ((alu_p_sub_a_lo - ((-alu_a_lo + FF(uint256_t{ 4891460686036598784UL, 2896914383306846353UL, 0UL, 0UL })) + (alu_p_a_borrow * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL })))) * - ((alu_cmp_sel + alu_op_cast) + alu_op_div_std)); + ((alu_sel_cmp + alu_op_cast) + alu_op_div_std)); tmp *= scaling_factor; std::get<27>(evals) += tmp; } @@ -616,7 +616,7 @@ template class aluImpl { auto tmp = ((alu_p_sub_a_hi - ((-alu_a_hi + FF(uint256_t{ 13281191951274694749UL, 3486998266802970665UL, 0UL, 0UL })) - alu_p_a_borrow)) * - ((alu_cmp_sel + alu_op_cast) + alu_op_div_std)); + ((alu_sel_cmp + alu_op_cast) + alu_op_div_std)); tmp *= scaling_factor; std::get<28>(evals) += tmp; } @@ -635,7 +635,7 @@ template class aluImpl { auto tmp = ((alu_p_sub_b_lo - ((-alu_b_lo + FF(uint256_t{ 4891460686036598784UL, 2896914383306846353UL, 0UL, 0UL })) + (alu_p_b_borrow * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL })))) * - alu_cmp_sel); + alu_sel_cmp); tmp *= scaling_factor; std::get<30>(evals) += tmp; } @@ -646,7 +646,7 @@ template class aluImpl { auto tmp = ((alu_p_sub_b_hi - ((-alu_b_hi + FF(uint256_t{ 13281191951274694749UL, 3486998266802970665UL, 0UL, 0UL })) - alu_p_b_borrow)) * - alu_cmp_sel); + alu_sel_cmp); tmp *= scaling_factor; std::get<31>(evals) += tmp; } @@ -659,7 +659,7 @@ template class aluImpl { ((alu_op_lt * alu_ic) + ((-alu_ic + FF(1)) * alu_op_lte))) + (((alu_b_lo - alu_a_lo) + (alu_borrow * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL }))) * (-((alu_op_lt * alu_ic) + ((-alu_ic + FF(1)) * alu_op_lte)) + FF(1))))) * - alu_cmp_sel); + alu_sel_cmp); tmp *= scaling_factor; std::get<32>(evals) += tmp; } @@ -672,7 +672,7 @@ template class aluImpl { ((((alu_a_hi - alu_b_hi) - alu_borrow) * ((alu_op_lt * alu_ic) + ((-alu_ic + FF(1)) * alu_op_lte))) + (((alu_b_hi - alu_a_hi) - alu_borrow) * (-((alu_op_lt * alu_ic) + ((-alu_ic + FF(1)) * alu_op_lte)) + FF(1))))) * - alu_cmp_sel); + alu_sel_cmp); tmp *= scaling_factor; std::get<33>(evals) += tmp; } @@ -688,7 +688,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(35); - auto tmp = ((alu_cmp_rng_ctr_shift - FF(4)) * alu_cmp_sel); + auto tmp = ((alu_cmp_rng_ctr_shift - FF(4)) * alu_sel_cmp); tmp *= scaling_factor; std::get<35>(evals) += tmp; } @@ -696,7 +696,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(36); - auto tmp = (alu_rng_chk_sel * (-alu_rng_chk_sel + FF(1))); + auto tmp = (alu_sel_rng_chk * (-alu_sel_rng_chk + FF(1))); tmp *= scaling_factor; std::get<36>(evals) += tmp; } @@ -704,7 +704,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(37); - auto tmp = (alu_rng_chk_sel * alu_cmp_sel); + auto tmp = (alu_sel_rng_chk * alu_sel_cmp); tmp *= scaling_factor; std::get<37>(evals) += tmp; } @@ -713,8 +713,8 @@ template class aluImpl { Avm_DECLARE_VIEWS(38); auto tmp = ((alu_cmp_rng_ctr * - (((-alu_rng_chk_sel + FF(1)) * (-alu_op_eq_diff_inv + FF(1))) + alu_op_eq_diff_inv)) - - alu_rng_chk_sel); + (((-alu_sel_rng_chk + FF(1)) * (-alu_op_eq_diff_inv + FF(1))) + alu_op_eq_diff_inv)) - + alu_sel_rng_chk); tmp *= scaling_factor; std::get<38>(evals) += tmp; } @@ -722,8 +722,8 @@ template class aluImpl { { Avm_DECLARE_VIEWS(39); - auto tmp = (alu_rng_chk_lookup_selector_shift - - ((((((((((alu_cmp_sel_shift + alu_rng_chk_sel_shift) + alu_op_add_shift) + alu_op_sub_shift) + + auto tmp = (alu_sel_rng_chk_lookup_shift - + ((((((((((alu_sel_cmp_shift + alu_sel_rng_chk_shift) + alu_op_add_shift) + alu_op_sub_shift) + alu_op_mul_shift) + (alu_op_mul * alu_u128_tag)) + alu_op_cast_shift) + @@ -747,7 +747,7 @@ template class aluImpl { (alu_u16_r4 * FF(uint256_t{ 0UL, 65536UL, 0UL, 0UL }))) + (alu_u16_r5 * FF(uint256_t{ 0UL, 4294967296UL, 0UL, 0UL }))) + (alu_u16_r6 * FF(uint256_t{ 0UL, 281474976710656UL, 0UL, 0UL }))) * - (((((alu_rng_chk_sel + alu_cmp_sel) + alu_op_cast) + alu_op_cast_prev) + alu_shift_lt_bit_len) + + (((((alu_sel_rng_chk + alu_sel_cmp) + alu_op_cast) + alu_op_cast_prev) + alu_shift_lt_bit_len) + alu_op_div))); tmp *= scaling_factor; std::get<40>(evals) += tmp; @@ -764,7 +764,7 @@ template class aluImpl { (alu_u16_r12 * FF(uint256_t{ 0UL, 65536UL, 0UL, 0UL }))) + (alu_u16_r13 * FF(uint256_t{ 0UL, 4294967296UL, 0UL, 0UL }))) + (alu_u16_r14 * FF(uint256_t{ 0UL, 281474976710656UL, 0UL, 0UL }))) * - (((((alu_rng_chk_sel + alu_cmp_sel) + alu_op_cast) + alu_op_cast_prev) + alu_shift_lt_bit_len) + + (((((alu_sel_rng_chk + alu_sel_cmp) + alu_op_cast) + alu_op_cast_prev) + alu_shift_lt_bit_len) + alu_op_div))); tmp *= scaling_factor; std::get<41>(evals) += tmp; @@ -773,7 +773,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(42); - auto tmp = ((alu_a_lo_shift - alu_b_lo) * alu_rng_chk_sel_shift); + auto tmp = ((alu_a_lo_shift - alu_b_lo) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<42>(evals) += tmp; } @@ -781,7 +781,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(43); - auto tmp = ((alu_a_hi_shift - alu_b_hi) * alu_rng_chk_sel_shift); + auto tmp = ((alu_a_hi_shift - alu_b_hi) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<43>(evals) += tmp; } @@ -789,7 +789,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(44); - auto tmp = ((alu_b_lo_shift - alu_p_sub_a_lo) * alu_rng_chk_sel_shift); + auto tmp = ((alu_b_lo_shift - alu_p_sub_a_lo) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<44>(evals) += tmp; } @@ -797,7 +797,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(45); - auto tmp = ((alu_b_hi_shift - alu_p_sub_a_hi) * alu_rng_chk_sel_shift); + auto tmp = ((alu_b_hi_shift - alu_p_sub_a_hi) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<45>(evals) += tmp; } @@ -805,7 +805,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(46); - auto tmp = ((alu_p_sub_a_lo_shift - alu_p_sub_b_lo) * alu_rng_chk_sel_shift); + auto tmp = ((alu_p_sub_a_lo_shift - alu_p_sub_b_lo) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<46>(evals) += tmp; } @@ -813,7 +813,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(47); - auto tmp = ((alu_p_sub_a_hi_shift - alu_p_sub_b_hi) * alu_rng_chk_sel_shift); + auto tmp = ((alu_p_sub_a_hi_shift - alu_p_sub_b_hi) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<47>(evals) += tmp; } @@ -821,7 +821,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(48); - auto tmp = ((alu_p_sub_b_lo_shift - alu_res_lo) * alu_rng_chk_sel_shift); + auto tmp = ((alu_p_sub_b_lo_shift - alu_res_lo) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<48>(evals) += tmp; } @@ -829,7 +829,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(49); - auto tmp = ((alu_p_sub_b_hi_shift - alu_res_hi) * alu_rng_chk_sel_shift); + auto tmp = ((alu_p_sub_b_hi_shift - alu_res_hi) * alu_sel_rng_chk_shift); tmp *= scaling_factor; std::get<49>(evals) += tmp; } @@ -883,7 +883,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(54); - auto tmp = (((alu_op_mul * alu_u128_tag) + alu_op_cast) * alu_alu_sel_shift); + auto tmp = (((alu_op_mul * alu_u128_tag) + alu_op_cast) * alu_sel_alu_shift); tmp *= scaling_factor; std::get<54>(evals) += tmp; } @@ -932,7 +932,7 @@ template class aluImpl { Avm_DECLARE_VIEWS(60); auto tmp = (alu_t_sub_s_bits - - (alu_shift_sel * + (alu_sel_shift_which * ((alu_shift_lt_bit_len * ((((((alu_u8_tag * FF(8)) + (alu_u16_tag * FF(16))) + (alu_u32_tag * FF(32))) + (alu_u64_tag * FF(64))) + @@ -1084,7 +1084,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(77); - auto tmp = (alu_rng_chk_sel * alu_op_div_std); + auto tmp = (alu_sel_rng_chk * alu_op_div_std); tmp *= scaling_factor; std::get<77>(evals) += tmp; } @@ -1104,7 +1104,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(79); - auto tmp = (alu_div_rng_chk_selector * (-alu_div_rng_chk_selector + FF(1))); + auto tmp = (alu_sel_div_rng_chk * (-alu_sel_div_rng_chk + FF(1))); tmp *= scaling_factor; std::get<79>(evals) += tmp; } @@ -1112,7 +1112,7 @@ template class aluImpl { { Avm_DECLARE_VIEWS(80); - auto tmp = ((alu_div_rng_chk_selector * alu_div_rng_chk_selector_shift) - alu_op_div_std); + auto tmp = ((alu_sel_div_rng_chk * alu_sel_div_rng_chk_shift) - alu_op_div_std); tmp *= scaling_factor; std::get<80>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/binary.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/binary.hpp index b9a7b218306..98260f37337 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/binary.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/binary.hpp @@ -13,7 +13,6 @@ template struct BinaryRow { FF binary_acc_ib_shift{}; FF binary_acc_ic{}; FF binary_acc_ic_shift{}; - FF binary_bin_sel{}; FF binary_ia_bytes{}; FF binary_ib_bytes{}; FF binary_ic_bytes{}; @@ -22,6 +21,7 @@ template struct BinaryRow { FF binary_mem_tag_ctr_shift{}; FF binary_op_id{}; FF binary_op_id_shift{}; + FF binary_sel_bin{}; [[maybe_unused]] static std::vector names(); }; @@ -36,7 +36,7 @@ inline std::string get_relation_label_binary(int index) return "MEM_TAG_REL"; case 3: - return "BIN_SEL_CTR_REL"; + return "SEL_BIN_CTR_REL"; case 7: return "ACC_REL_A"; @@ -69,7 +69,7 @@ template class binaryImpl { { Avm_DECLARE_VIEWS(0); - auto tmp = (binary_bin_sel * (-binary_bin_sel + FF(1))); + auto tmp = (binary_sel_bin * (-binary_sel_bin + FF(1))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } @@ -94,8 +94,8 @@ template class binaryImpl { Avm_DECLARE_VIEWS(3); auto tmp = ((binary_mem_tag_ctr * - (((-binary_bin_sel + FF(1)) * (-binary_mem_tag_ctr_inv + FF(1))) + binary_mem_tag_ctr_inv)) - - binary_bin_sel); + (((-binary_sel_bin + FF(1)) * (-binary_mem_tag_ctr_inv + FF(1))) + binary_mem_tag_ctr_inv)) - + binary_sel_bin); tmp *= scaling_factor; std::get<3>(evals) += tmp; } @@ -103,7 +103,7 @@ template class binaryImpl { { Avm_DECLARE_VIEWS(4); - auto tmp = ((-binary_bin_sel + FF(1)) * binary_acc_ia); + auto tmp = ((-binary_sel_bin + FF(1)) * binary_acc_ia); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -111,7 +111,7 @@ template class binaryImpl { { Avm_DECLARE_VIEWS(5); - auto tmp = ((-binary_bin_sel + FF(1)) * binary_acc_ib); + auto tmp = ((-binary_sel_bin + FF(1)) * binary_acc_ib); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -119,7 +119,7 @@ template class binaryImpl { { Avm_DECLARE_VIEWS(6); - auto tmp = ((-binary_bin_sel + FF(1)) * binary_acc_ic); + auto tmp = ((-binary_sel_bin + FF(1)) * binary_acc_ic); tmp *= scaling_factor; std::get<6>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/conversion.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/conversion.hpp index d0f8491e721..b83fb6bf7ac 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/conversion.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/conversion.hpp @@ -7,7 +7,7 @@ namespace bb::Avm_vm { template struct ConversionRow { - FF conversion_to_radix_le_sel{}; + FF conversion_sel_to_radix_le{}; [[maybe_unused]] static std::vector names(); }; @@ -37,7 +37,7 @@ template class conversionImpl { { Avm_DECLARE_VIEWS(0); - auto tmp = (conversion_to_radix_le_sel * (-conversion_to_radix_le_sel + FF(1))); + auto tmp = (conversion_sel_to_radix_le * (-conversion_sel_to_radix_le + FF(1))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } 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 46ddc52e6d9..ef1db050b75 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -3,18 +3,15 @@ using Accumulator = typename std::tuple_element::type; \ using View = typename Accumulator::View; \ [[maybe_unused]] auto main_clk = View(new_term.main_clk); \ - [[maybe_unused]] auto main_first = View(new_term.main_first); \ + [[maybe_unused]] auto main_sel_first = View(new_term.main_sel_first); \ [[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_alu_sel = View(new_term.alu_alu_sel); \ [[maybe_unused]] auto alu_b_hi = View(new_term.alu_b_hi); \ [[maybe_unused]] auto alu_b_lo = View(new_term.alu_b_lo); \ [[maybe_unused]] auto alu_borrow = View(new_term.alu_borrow); \ [[maybe_unused]] auto alu_cf = View(new_term.alu_cf); \ [[maybe_unused]] auto alu_clk = View(new_term.alu_clk); \ [[maybe_unused]] auto alu_cmp_rng_ctr = View(new_term.alu_cmp_rng_ctr); \ - [[maybe_unused]] auto alu_cmp_sel = View(new_term.alu_cmp_sel); \ - [[maybe_unused]] auto alu_div_rng_chk_selector = View(new_term.alu_div_rng_chk_selector); \ [[maybe_unused]] auto alu_div_u16_r0 = View(new_term.alu_div_u16_r0); \ [[maybe_unused]] auto alu_div_u16_r1 = View(new_term.alu_div_u16_r1); \ [[maybe_unused]] auto alu_div_u16_r2 = View(new_term.alu_div_u16_r2); \ @@ -58,10 +55,13 @@ [[maybe_unused]] auto alu_remainder = View(new_term.alu_remainder); \ [[maybe_unused]] auto alu_res_hi = View(new_term.alu_res_hi); \ [[maybe_unused]] auto alu_res_lo = View(new_term.alu_res_lo); \ - [[maybe_unused]] auto alu_rng_chk_lookup_selector = View(new_term.alu_rng_chk_lookup_selector); \ - [[maybe_unused]] auto alu_rng_chk_sel = View(new_term.alu_rng_chk_sel); \ + [[maybe_unused]] auto alu_sel_alu = View(new_term.alu_sel_alu); \ + [[maybe_unused]] auto alu_sel_cmp = View(new_term.alu_sel_cmp); \ + [[maybe_unused]] auto alu_sel_div_rng_chk = View(new_term.alu_sel_div_rng_chk); \ + [[maybe_unused]] auto alu_sel_rng_chk = View(new_term.alu_sel_rng_chk); \ + [[maybe_unused]] auto alu_sel_rng_chk_lookup = View(new_term.alu_sel_rng_chk_lookup); \ + [[maybe_unused]] auto alu_sel_shift_which = View(new_term.alu_sel_shift_which); \ [[maybe_unused]] auto alu_shift_lt_bit_len = View(new_term.alu_shift_lt_bit_len); \ - [[maybe_unused]] auto alu_shift_sel = View(new_term.alu_shift_sel); \ [[maybe_unused]] auto alu_t_sub_s_bits = View(new_term.alu_t_sub_s_bits); \ [[maybe_unused]] auto alu_two_pow_s = View(new_term.alu_two_pow_s); \ [[maybe_unused]] auto alu_two_pow_t_sub_s = View(new_term.alu_two_pow_t_sub_s); \ @@ -90,7 +90,6 @@ [[maybe_unused]] auto binary_acc_ia = View(new_term.binary_acc_ia); \ [[maybe_unused]] auto binary_acc_ib = View(new_term.binary_acc_ib); \ [[maybe_unused]] auto binary_acc_ic = View(new_term.binary_acc_ic); \ - [[maybe_unused]] auto binary_bin_sel = View(new_term.binary_bin_sel); \ [[maybe_unused]] auto binary_clk = View(new_term.binary_clk); \ [[maybe_unused]] auto binary_ia_bytes = View(new_term.binary_ia_bytes); \ [[maybe_unused]] auto binary_ib_bytes = View(new_term.binary_ib_bytes); \ @@ -99,8 +98,9 @@ [[maybe_unused]] auto binary_mem_tag_ctr = View(new_term.binary_mem_tag_ctr); \ [[maybe_unused]] auto binary_mem_tag_ctr_inv = View(new_term.binary_mem_tag_ctr_inv); \ [[maybe_unused]] auto binary_op_id = View(new_term.binary_op_id); \ + [[maybe_unused]] auto binary_sel_bin = View(new_term.binary_sel_bin); \ [[maybe_unused]] auto binary_start = View(new_term.binary_start); \ - [[maybe_unused]] auto byte_lookup_bin_sel = View(new_term.byte_lookup_bin_sel); \ + [[maybe_unused]] auto byte_lookup_sel_bin = View(new_term.byte_lookup_sel_bin); \ [[maybe_unused]] auto byte_lookup_table_byte_lengths = View(new_term.byte_lookup_table_byte_lengths); \ [[maybe_unused]] auto byte_lookup_table_in_tags = View(new_term.byte_lookup_table_in_tags); \ [[maybe_unused]] auto byte_lookup_table_input_a = View(new_term.byte_lookup_table_input_a); \ @@ -111,14 +111,14 @@ [[maybe_unused]] auto conversion_input = View(new_term.conversion_input); \ [[maybe_unused]] auto conversion_num_limbs = View(new_term.conversion_num_limbs); \ [[maybe_unused]] auto conversion_radix = View(new_term.conversion_radix); \ - [[maybe_unused]] auto conversion_to_radix_le_sel = View(new_term.conversion_to_radix_le_sel); \ + [[maybe_unused]] auto conversion_sel_to_radix_le = View(new_term.conversion_sel_to_radix_le); \ [[maybe_unused]] auto gas_da_gas_fixed_table = View(new_term.gas_da_gas_fixed_table); \ - [[maybe_unused]] auto gas_gas_cost_sel = View(new_term.gas_gas_cost_sel); \ [[maybe_unused]] auto gas_l2_gas_fixed_table = View(new_term.gas_l2_gas_fixed_table); \ + [[maybe_unused]] auto gas_sel_gas_cost = View(new_term.gas_sel_gas_cost); \ [[maybe_unused]] auto keccakf1600_clk = View(new_term.keccakf1600_clk); \ [[maybe_unused]] auto keccakf1600_input = View(new_term.keccakf1600_input); \ - [[maybe_unused]] auto keccakf1600_keccakf1600_sel = View(new_term.keccakf1600_keccakf1600_sel); \ [[maybe_unused]] auto keccakf1600_output = View(new_term.keccakf1600_output); \ + [[maybe_unused]] auto keccakf1600_sel_keccakf1600 = View(new_term.keccakf1600_sel_keccakf1600); \ [[maybe_unused]] auto kernel_emit_l2_to_l1_msg_write_offset = \ View(new_term.kernel_emit_l2_to_l1_msg_write_offset); \ [[maybe_unused]] auto kernel_emit_note_hash_write_offset = View(new_term.kernel_emit_note_hash_write_offset); \ @@ -149,68 +149,55 @@ [[maybe_unused]] auto main_abs_l2_rem_gas_hi = View(new_term.main_abs_l2_rem_gas_hi); \ [[maybe_unused]] auto main_abs_l2_rem_gas_lo = View(new_term.main_abs_l2_rem_gas_lo); \ [[maybe_unused]] auto main_alu_in_tag = View(new_term.main_alu_in_tag); \ - [[maybe_unused]] auto main_alu_sel = View(new_term.main_alu_sel); \ [[maybe_unused]] auto main_bin_op_id = View(new_term.main_bin_op_id); \ - [[maybe_unused]] auto main_bin_sel = View(new_term.main_bin_sel); \ [[maybe_unused]] auto main_call_ptr = View(new_term.main_call_ptr); \ - [[maybe_unused]] auto main_da_gas_op = View(new_term.main_da_gas_op); \ + [[maybe_unused]] auto main_da_gas_op_cost = View(new_term.main_da_gas_op_cost); \ [[maybe_unused]] auto main_da_gas_remaining = View(new_term.main_da_gas_remaining); \ [[maybe_unused]] auto main_da_out_of_gas = View(new_term.main_da_out_of_gas); \ - [[maybe_unused]] auto main_gas_cost_active = View(new_term.main_gas_cost_active); \ [[maybe_unused]] auto main_ia = View(new_term.main_ia); \ [[maybe_unused]] auto main_ib = View(new_term.main_ib); \ [[maybe_unused]] auto main_ic = View(new_term.main_ic); \ [[maybe_unused]] auto main_id = View(new_term.main_id); \ [[maybe_unused]] auto main_id_zero = View(new_term.main_id_zero); \ - [[maybe_unused]] auto main_ind_a = View(new_term.main_ind_a); \ - [[maybe_unused]] auto main_ind_b = View(new_term.main_ind_b); \ - [[maybe_unused]] auto main_ind_c = View(new_term.main_ind_c); \ - [[maybe_unused]] auto main_ind_d = View(new_term.main_ind_d); \ - [[maybe_unused]] auto main_ind_op_a = View(new_term.main_ind_op_a); \ - [[maybe_unused]] auto main_ind_op_b = View(new_term.main_ind_op_b); \ - [[maybe_unused]] auto main_ind_op_c = View(new_term.main_ind_op_c); \ - [[maybe_unused]] auto main_ind_op_d = View(new_term.main_ind_op_d); \ + [[maybe_unused]] auto main_ind_addr_a = View(new_term.main_ind_addr_a); \ + [[maybe_unused]] auto main_ind_addr_b = View(new_term.main_ind_addr_b); \ + [[maybe_unused]] auto main_ind_addr_c = View(new_term.main_ind_addr_c); \ + [[maybe_unused]] auto main_ind_addr_d = View(new_term.main_ind_addr_d); \ [[maybe_unused]] auto main_internal_return_ptr = View(new_term.main_internal_return_ptr); \ [[maybe_unused]] auto main_inv = View(new_term.main_inv); \ - [[maybe_unused]] auto main_l2_gas_op = View(new_term.main_l2_gas_op); \ + [[maybe_unused]] auto main_l2_gas_op_cost = View(new_term.main_l2_gas_op_cost); \ [[maybe_unused]] auto main_l2_gas_remaining = View(new_term.main_l2_gas_remaining); \ [[maybe_unused]] auto main_l2_out_of_gas = View(new_term.main_l2_out_of_gas); \ - [[maybe_unused]] auto main_last = View(new_term.main_last); \ - [[maybe_unused]] auto main_mem_idx_a = View(new_term.main_mem_idx_a); \ - [[maybe_unused]] auto main_mem_idx_b = View(new_term.main_mem_idx_b); \ - [[maybe_unused]] auto main_mem_idx_c = View(new_term.main_mem_idx_c); \ - [[maybe_unused]] auto main_mem_idx_d = View(new_term.main_mem_idx_d); \ - [[maybe_unused]] auto main_mem_op_a = View(new_term.main_mem_op_a); \ - [[maybe_unused]] auto main_mem_op_activate_gas = View(new_term.main_mem_op_activate_gas); \ - [[maybe_unused]] auto main_mem_op_b = View(new_term.main_mem_op_b); \ - [[maybe_unused]] auto main_mem_op_c = View(new_term.main_mem_op_c); \ - [[maybe_unused]] auto main_mem_op_d = View(new_term.main_mem_op_d); \ + [[maybe_unused]] auto main_mem_addr_a = View(new_term.main_mem_addr_a); \ + [[maybe_unused]] auto main_mem_addr_b = View(new_term.main_mem_addr_b); \ + [[maybe_unused]] auto main_mem_addr_c = View(new_term.main_mem_addr_c); \ + [[maybe_unused]] auto main_mem_addr_d = View(new_term.main_mem_addr_d); \ [[maybe_unused]] auto main_op_err = View(new_term.main_op_err); \ [[maybe_unused]] auto main_opcode_val = View(new_term.main_opcode_val); \ [[maybe_unused]] auto main_pc = View(new_term.main_pc); \ - [[maybe_unused]] auto main_q_kernel_lookup = View(new_term.main_q_kernel_lookup); \ - [[maybe_unused]] auto main_q_kernel_output_lookup = View(new_term.main_q_kernel_output_lookup); \ [[maybe_unused]] auto main_r_in_tag = View(new_term.main_r_in_tag); \ [[maybe_unused]] auto main_rwa = View(new_term.main_rwa); \ [[maybe_unused]] auto main_rwb = View(new_term.main_rwb); \ [[maybe_unused]] auto main_rwc = View(new_term.main_rwc); \ [[maybe_unused]] auto main_rwd = View(new_term.main_rwd); \ - [[maybe_unused]] auto main_sel_cmov = View(new_term.main_sel_cmov); \ - [[maybe_unused]] auto main_sel_external_call = View(new_term.main_sel_external_call); \ - [[maybe_unused]] auto main_sel_halt = View(new_term.main_sel_halt); \ - [[maybe_unused]] auto main_sel_internal_call = View(new_term.main_sel_internal_call); \ - [[maybe_unused]] auto main_sel_internal_return = View(new_term.main_sel_internal_return); \ - [[maybe_unused]] auto main_sel_jump = View(new_term.main_sel_jump); \ - [[maybe_unused]] auto main_sel_jumpi = View(new_term.main_sel_jumpi); \ - [[maybe_unused]] auto main_sel_mov = View(new_term.main_sel_mov); \ - [[maybe_unused]] auto main_sel_mov_a = View(new_term.main_sel_mov_a); \ - [[maybe_unused]] auto main_sel_mov_b = View(new_term.main_sel_mov_b); \ + [[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_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); \ + [[maybe_unused]] auto main_sel_mem_op_activate_gas = View(new_term.main_sel_mem_op_activate_gas); \ + [[maybe_unused]] auto main_sel_mem_op_b = View(new_term.main_sel_mem_op_b); \ + [[maybe_unused]] auto main_sel_mem_op_c = View(new_term.main_sel_mem_op_c); \ + [[maybe_unused]] auto main_sel_mem_op_d = View(new_term.main_sel_mem_op_d); \ + [[maybe_unused]] auto main_sel_mov_ia_to_ic = View(new_term.main_sel_mov_ia_to_ic); \ + [[maybe_unused]] auto main_sel_mov_ib_to_ic = View(new_term.main_sel_mov_ib_to_ic); \ [[maybe_unused]] auto main_sel_op_add = View(new_term.main_sel_op_add); \ [[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_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); \ [[maybe_unused]] auto main_sel_op_coinbase = View(new_term.main_sel_op_coinbase); \ [[maybe_unused]] auto main_sel_op_dagasleft = View(new_term.main_sel_op_dagasleft); \ [[maybe_unused]] auto main_sel_op_div = View(new_term.main_sel_op_div); \ @@ -219,15 +206,22 @@ [[maybe_unused]] auto main_sel_op_emit_nullifier = View(new_term.main_sel_op_emit_nullifier); \ [[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_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); \ [[maybe_unused]] auto main_sel_op_get_contract_instance = View(new_term.main_sel_op_get_contract_instance); \ + [[maybe_unused]] auto main_sel_op_halt = View(new_term.main_sel_op_halt); \ + [[maybe_unused]] auto main_sel_op_internal_call = View(new_term.main_sel_op_internal_call); \ + [[maybe_unused]] auto main_sel_op_internal_return = View(new_term.main_sel_op_internal_return); \ + [[maybe_unused]] auto main_sel_op_jump = View(new_term.main_sel_op_jump); \ + [[maybe_unused]] auto main_sel_op_jumpi = View(new_term.main_sel_op_jumpi); \ [[maybe_unused]] auto main_sel_op_keccak = View(new_term.main_sel_op_keccak); \ [[maybe_unused]] auto main_sel_op_l1_to_l2_msg_exists = View(new_term.main_sel_op_l1_to_l2_msg_exists); \ [[maybe_unused]] auto main_sel_op_l2gasleft = View(new_term.main_sel_op_l2gasleft); \ [[maybe_unused]] auto main_sel_op_lt = View(new_term.main_sel_op_lt); \ [[maybe_unused]] auto main_sel_op_lte = View(new_term.main_sel_op_lte); \ + [[maybe_unused]] auto main_sel_op_mov = View(new_term.main_sel_op_mov); \ [[maybe_unused]] auto main_sel_op_mul = View(new_term.main_sel_op_mul); \ [[maybe_unused]] auto main_sel_op_not = View(new_term.main_sel_op_not); \ [[maybe_unused]] auto main_sel_op_note_hash_exists = View(new_term.main_sel_op_note_hash_exists); \ @@ -248,6 +242,12 @@ [[maybe_unused]] auto main_sel_op_transaction_fee = View(new_term.main_sel_op_transaction_fee); \ [[maybe_unused]] auto main_sel_op_version = View(new_term.main_sel_op_version); \ [[maybe_unused]] auto main_sel_op_xor = View(new_term.main_sel_op_xor); \ + [[maybe_unused]] auto main_sel_q_kernel_lookup = View(new_term.main_sel_q_kernel_lookup); \ + [[maybe_unused]] auto main_sel_q_kernel_output_lookup = View(new_term.main_sel_q_kernel_output_lookup); \ + [[maybe_unused]] auto main_sel_resolve_ind_addr_a = View(new_term.main_sel_resolve_ind_addr_a); \ + [[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_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_space_id = View(new_term.main_space_id); \ @@ -260,24 +260,24 @@ [[maybe_unused]] auto mem_diff_lo = View(new_term.mem_diff_lo); \ [[maybe_unused]] auto mem_diff_mid = View(new_term.mem_diff_mid); \ [[maybe_unused]] auto mem_glob_addr = View(new_term.mem_glob_addr); \ - [[maybe_unused]] auto mem_ind_op_a = View(new_term.mem_ind_op_a); \ - [[maybe_unused]] auto mem_ind_op_b = View(new_term.mem_ind_op_b); \ - [[maybe_unused]] auto mem_ind_op_c = View(new_term.mem_ind_op_c); \ - [[maybe_unused]] auto mem_ind_op_d = View(new_term.mem_ind_op_d); \ [[maybe_unused]] auto mem_last = View(new_term.mem_last); \ [[maybe_unused]] auto mem_lastAccess = View(new_term.mem_lastAccess); \ - [[maybe_unused]] auto mem_mem_sel = View(new_term.mem_mem_sel); \ [[maybe_unused]] auto mem_one_min_inv = View(new_term.mem_one_min_inv); \ - [[maybe_unused]] auto mem_op_a = View(new_term.mem_op_a); \ - [[maybe_unused]] auto mem_op_b = View(new_term.mem_op_b); \ - [[maybe_unused]] auto mem_op_c = View(new_term.mem_op_c); \ - [[maybe_unused]] auto mem_op_d = View(new_term.mem_op_d); \ [[maybe_unused]] auto mem_r_in_tag = View(new_term.mem_r_in_tag); \ - [[maybe_unused]] auto mem_rng_chk_sel = View(new_term.mem_rng_chk_sel); \ [[maybe_unused]] auto mem_rw = View(new_term.mem_rw); \ - [[maybe_unused]] auto mem_sel_cmov = View(new_term.mem_sel_cmov); \ - [[maybe_unused]] auto mem_sel_mov_a = View(new_term.mem_sel_mov_a); \ - [[maybe_unused]] auto mem_sel_mov_b = View(new_term.mem_sel_mov_b); \ + [[maybe_unused]] auto mem_sel_mem = View(new_term.mem_sel_mem); \ + [[maybe_unused]] auto mem_sel_mov_ia_to_ic = View(new_term.mem_sel_mov_ia_to_ic); \ + [[maybe_unused]] auto mem_sel_mov_ib_to_ic = View(new_term.mem_sel_mov_ib_to_ic); \ + [[maybe_unused]] auto mem_sel_op_a = View(new_term.mem_sel_op_a); \ + [[maybe_unused]] auto mem_sel_op_b = View(new_term.mem_sel_op_b); \ + [[maybe_unused]] auto mem_sel_op_c = View(new_term.mem_sel_op_c); \ + [[maybe_unused]] auto mem_sel_op_cmov = View(new_term.mem_sel_op_cmov); \ + [[maybe_unused]] auto mem_sel_op_d = View(new_term.mem_sel_op_d); \ + [[maybe_unused]] auto mem_sel_resolve_ind_addr_a = View(new_term.mem_sel_resolve_ind_addr_a); \ + [[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); \ + [[maybe_unused]] auto mem_sel_resolve_ind_addr_d = View(new_term.mem_sel_resolve_ind_addr_d); \ + [[maybe_unused]] auto mem_sel_rng_chk = View(new_term.mem_sel_rng_chk); \ [[maybe_unused]] auto mem_skip_check_tag = View(new_term.mem_skip_check_tag); \ [[maybe_unused]] auto mem_space_id = View(new_term.mem_space_id); \ [[maybe_unused]] auto mem_tag = View(new_term.mem_tag); \ @@ -288,15 +288,15 @@ [[maybe_unused]] auto pedersen_clk = View(new_term.pedersen_clk); \ [[maybe_unused]] auto pedersen_input = View(new_term.pedersen_input); \ [[maybe_unused]] auto pedersen_output = View(new_term.pedersen_output); \ - [[maybe_unused]] auto pedersen_pedersen_sel = View(new_term.pedersen_pedersen_sel); \ + [[maybe_unused]] auto pedersen_sel_pedersen = View(new_term.pedersen_sel_pedersen); \ [[maybe_unused]] auto poseidon2_clk = View(new_term.poseidon2_clk); \ [[maybe_unused]] auto poseidon2_input = View(new_term.poseidon2_input); \ [[maybe_unused]] auto poseidon2_output = View(new_term.poseidon2_output); \ - [[maybe_unused]] auto poseidon2_poseidon_perm_sel = View(new_term.poseidon2_poseidon_perm_sel); \ + [[maybe_unused]] auto poseidon2_sel_poseidon_perm = View(new_term.poseidon2_sel_poseidon_perm); \ [[maybe_unused]] auto sha256_clk = View(new_term.sha256_clk); \ [[maybe_unused]] auto sha256_input = View(new_term.sha256_input); \ [[maybe_unused]] auto sha256_output = View(new_term.sha256_output); \ - [[maybe_unused]] auto sha256_sha256_compression_sel = View(new_term.sha256_sha256_compression_sel); \ + [[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 perm_main_alu = View(new_term.perm_main_alu); \ [[maybe_unused]] auto perm_main_bin = View(new_term.perm_main_bin); \ @@ -307,10 +307,10 @@ [[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); \ [[maybe_unused]] auto perm_main_mem_d = View(new_term.perm_main_mem_d); \ - [[maybe_unused]] auto perm_main_mem_ind_a = View(new_term.perm_main_mem_ind_a); \ - [[maybe_unused]] auto perm_main_mem_ind_b = View(new_term.perm_main_mem_ind_b); \ - [[maybe_unused]] auto perm_main_mem_ind_c = View(new_term.perm_main_mem_ind_c); \ - [[maybe_unused]] auto perm_main_mem_ind_d = View(new_term.perm_main_mem_ind_d); \ + [[maybe_unused]] auto perm_main_mem_ind_addr_a = View(new_term.perm_main_mem_ind_addr_a); \ + [[maybe_unused]] auto perm_main_mem_ind_addr_b = View(new_term.perm_main_mem_ind_addr_b); \ + [[maybe_unused]] auto perm_main_mem_ind_addr_c = View(new_term.perm_main_mem_ind_addr_c); \ + [[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_opcode_gas = View(new_term.lookup_opcode_gas); \ @@ -395,12 +395,9 @@ [[maybe_unused]] auto lookup_div_u16_7_counts = View(new_term.lookup_div_u16_7_counts); \ [[maybe_unused]] auto alu_a_hi_shift = View(new_term.alu_a_hi_shift); \ [[maybe_unused]] auto alu_a_lo_shift = View(new_term.alu_a_lo_shift); \ - [[maybe_unused]] auto alu_alu_sel_shift = View(new_term.alu_alu_sel_shift); \ [[maybe_unused]] auto alu_b_hi_shift = View(new_term.alu_b_hi_shift); \ [[maybe_unused]] auto alu_b_lo_shift = View(new_term.alu_b_lo_shift); \ [[maybe_unused]] auto alu_cmp_rng_ctr_shift = View(new_term.alu_cmp_rng_ctr_shift); \ - [[maybe_unused]] auto alu_cmp_sel_shift = View(new_term.alu_cmp_sel_shift); \ - [[maybe_unused]] auto alu_div_rng_chk_selector_shift = View(new_term.alu_div_rng_chk_selector_shift); \ [[maybe_unused]] auto alu_div_u16_r0_shift = View(new_term.alu_div_u16_r0_shift); \ [[maybe_unused]] auto alu_div_u16_r1_shift = View(new_term.alu_div_u16_r1_shift); \ [[maybe_unused]] auto alu_div_u16_r2_shift = View(new_term.alu_div_u16_r2_shift); \ @@ -421,8 +418,11 @@ [[maybe_unused]] auto alu_p_sub_a_lo_shift = View(new_term.alu_p_sub_a_lo_shift); \ [[maybe_unused]] auto alu_p_sub_b_hi_shift = View(new_term.alu_p_sub_b_hi_shift); \ [[maybe_unused]] auto alu_p_sub_b_lo_shift = View(new_term.alu_p_sub_b_lo_shift); \ - [[maybe_unused]] auto alu_rng_chk_lookup_selector_shift = View(new_term.alu_rng_chk_lookup_selector_shift); \ - [[maybe_unused]] auto alu_rng_chk_sel_shift = View(new_term.alu_rng_chk_sel_shift); \ + [[maybe_unused]] auto alu_sel_alu_shift = View(new_term.alu_sel_alu_shift); \ + [[maybe_unused]] auto alu_sel_cmp_shift = View(new_term.alu_sel_cmp_shift); \ + [[maybe_unused]] auto alu_sel_div_rng_chk_shift = View(new_term.alu_sel_div_rng_chk_shift); \ + [[maybe_unused]] auto alu_sel_rng_chk_lookup_shift = View(new_term.alu_sel_rng_chk_lookup_shift); \ + [[maybe_unused]] auto alu_sel_rng_chk_shift = View(new_term.alu_sel_rng_chk_shift); \ [[maybe_unused]] auto alu_u16_r0_shift = View(new_term.alu_u16_r0_shift); \ [[maybe_unused]] auto alu_u16_r1_shift = View(new_term.alu_u16_r1_shift); \ [[maybe_unused]] auto alu_u16_r2_shift = View(new_term.alu_u16_r2_shift); \ @@ -461,8 +461,8 @@ [[maybe_unused]] auto main_l2_gas_remaining_shift = View(new_term.main_l2_gas_remaining_shift); \ [[maybe_unused]] auto main_pc_shift = View(new_term.main_pc_shift); \ [[maybe_unused]] auto mem_glob_addr_shift = View(new_term.mem_glob_addr_shift); \ - [[maybe_unused]] auto mem_mem_sel_shift = View(new_term.mem_mem_sel_shift); \ [[maybe_unused]] auto mem_rw_shift = View(new_term.mem_rw_shift); \ + [[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); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/keccakf1600.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/keccakf1600.hpp index 4606c2d308d..56e0a9e6a5d 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/keccakf1600.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/keccakf1600.hpp @@ -7,7 +7,7 @@ namespace bb::Avm_vm { template struct Keccakf1600Row { - FF keccakf1600_keccakf1600_sel{}; + FF keccakf1600_sel_keccakf1600{}; [[maybe_unused]] static std::vector names(); }; @@ -37,7 +37,7 @@ template class keccakf1600Impl { { Avm_DECLARE_VIEWS(0); - auto tmp = (keccakf1600_keccakf1600_sel * (-keccakf1600_keccakf1600_sel + FF(1))); + auto tmp = (keccakf1600_sel_keccakf1600 * (-keccakf1600_sel_keccakf1600 + FF(1))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel.hpp index 8042d717539..a53770f6481 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel.hpp @@ -28,7 +28,7 @@ template struct KernelRow { FF kernel_sstore_write_offset{}; FF kernel_sstore_write_offset_shift{}; FF main_ib{}; - FF main_last{}; + FF main_sel_last{}; FF main_sel_op_emit_l2_to_l1_msg{}; FF main_sel_op_emit_note_hash{}; FF main_sel_op_emit_nullifier{}; @@ -97,8 +97,9 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(0); - auto tmp = ((-main_last + FF(1)) * (kernel_note_hash_exist_write_offset_shift - - (kernel_note_hash_exist_write_offset + main_sel_op_note_hash_exists))); + auto tmp = + ((-main_sel_last + FF(1)) * (kernel_note_hash_exist_write_offset_shift - + (kernel_note_hash_exist_write_offset + main_sel_op_note_hash_exists))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } @@ -106,8 +107,8 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(1); - auto tmp = ((-main_last + FF(1)) * (kernel_emit_note_hash_write_offset_shift - - (kernel_emit_note_hash_write_offset + main_sel_op_emit_note_hash))); + auto tmp = ((-main_sel_last + FF(1)) * (kernel_emit_note_hash_write_offset_shift - + (kernel_emit_note_hash_write_offset + main_sel_op_emit_note_hash))); tmp *= scaling_factor; std::get<1>(evals) += tmp; } @@ -115,7 +116,7 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(2); - auto tmp = ((-main_last + FF(1)) * + auto tmp = ((-main_sel_last + FF(1)) * (kernel_nullifier_exists_write_offset_shift - (kernel_nullifier_exists_write_offset + (main_sel_op_nullifier_exists * main_ib)))); tmp *= scaling_factor; @@ -126,7 +127,7 @@ template class kernelImpl { Avm_DECLARE_VIEWS(3); auto tmp = - ((-main_last + FF(1)) * + ((-main_sel_last + FF(1)) * (kernel_nullifier_non_exists_write_offset_shift - (kernel_nullifier_non_exists_write_offset + (main_sel_op_nullifier_exists * (-main_ib + FF(1)))))); tmp *= scaling_factor; @@ -136,8 +137,8 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(4); - auto tmp = ((-main_last + FF(1)) * (kernel_emit_nullifier_write_offset_shift - - (kernel_emit_nullifier_write_offset + main_sel_op_emit_nullifier))); + auto tmp = ((-main_sel_last + FF(1)) * (kernel_emit_nullifier_write_offset_shift - + (kernel_emit_nullifier_write_offset + main_sel_op_emit_nullifier))); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -145,9 +146,9 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(5); - auto tmp = - ((-main_last + FF(1)) * (kernel_l1_to_l2_msg_exists_write_offset_shift - - (kernel_l1_to_l2_msg_exists_write_offset + main_sel_op_l1_to_l2_msg_exists))); + auto tmp = ((-main_sel_last + FF(1)) * + (kernel_l1_to_l2_msg_exists_write_offset_shift - + (kernel_l1_to_l2_msg_exists_write_offset + main_sel_op_l1_to_l2_msg_exists))); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -155,7 +156,7 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(6); - auto tmp = ((-main_last + FF(1)) * + auto tmp = ((-main_sel_last + FF(1)) * (kernel_emit_unencrypted_log_write_offset_shift - (kernel_emit_unencrypted_log_write_offset + main_sel_op_emit_unencrypted_log))); tmp *= scaling_factor; @@ -166,8 +167,8 @@ template class kernelImpl { Avm_DECLARE_VIEWS(7); auto tmp = - ((-main_last + FF(1)) * (kernel_emit_l2_to_l1_msg_write_offset_shift - - (kernel_emit_l2_to_l1_msg_write_offset + main_sel_op_emit_l2_to_l1_msg))); + ((-main_sel_last + FF(1)) * (kernel_emit_l2_to_l1_msg_write_offset_shift - + (kernel_emit_l2_to_l1_msg_write_offset + main_sel_op_emit_l2_to_l1_msg))); tmp *= scaling_factor; std::get<7>(evals) += tmp; } @@ -175,7 +176,7 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(8); - auto tmp = ((-main_last + FF(1)) * + auto tmp = ((-main_sel_last + FF(1)) * (kernel_sload_write_offset_shift - (kernel_sload_write_offset + main_sel_op_sload))); tmp *= scaling_factor; std::get<8>(evals) += tmp; @@ -184,7 +185,7 @@ template class kernelImpl { { Avm_DECLARE_VIEWS(9); - auto tmp = ((-main_last + FF(1)) * + auto tmp = ((-main_sel_last + FF(1)) * (kernel_sstore_write_offset_shift - (kernel_sstore_write_offset + main_sel_op_sstore))); tmp *= scaling_factor; std::get<9>(evals) += tmp; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel_output_lookup.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel_output_lookup.hpp index b2cd49e9424..d2eda9e27dd 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel_output_lookup.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/kernel_output_lookup.hpp @@ -87,7 +87,7 @@ class kernel_output_lookup_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_q_kernel_output_lookup == 1 || in.kernel_q_public_input_kernel_out_add_to_table == 1); + return (in.main_sel_q_kernel_output_lookup == 1 || in.kernel_q_public_input_kernel_out_add_to_table == 1); } /** @@ -104,7 +104,7 @@ class kernel_output_lookup_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.main_q_kernel_output_lookup); + const auto is_operation = View(in.main_sel_q_kernel_output_lookup); const auto is_table_entry = View(in.kernel_q_public_input_kernel_out_add_to_table); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class kernel_output_lookup_lookup_settings { return std::forward_as_tuple(in.kernel_output_lookup, in.kernel_output_lookup_counts, - in.main_q_kernel_output_lookup, + in.main_sel_q_kernel_output_lookup, in.kernel_q_public_input_kernel_out_add_to_table, in.kernel_kernel_out_offset, in.main_ia, @@ -159,7 +159,7 @@ class kernel_output_lookup_lookup_settings { return std::forward_as_tuple(in.kernel_output_lookup, in.kernel_output_lookup_counts, - in.main_q_kernel_output_lookup, + in.main_sel_q_kernel_output_lookup, in.kernel_q_public_input_kernel_out_add_to_table, in.kernel_kernel_out_offset, in.main_ia, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp index 1c93a11b75a..bf8caeffe83 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp @@ -87,7 +87,7 @@ class lookup_byte_lengths_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.binary_start == 1 || in.byte_lookup_bin_sel == 1); + return (in.binary_start == 1 || in.byte_lookup_sel_bin == 1); } /** @@ -105,7 +105,7 @@ class lookup_byte_lengths_lookup_settings { { using View = typename Accumulator::View; const auto is_operation = View(in.binary_start); - const auto is_table_entry = View(in.byte_lookup_bin_sel); + const auto is_table_entry = View(in.byte_lookup_sel_bin); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -136,7 +136,7 @@ class lookup_byte_lengths_lookup_settings { return std::forward_as_tuple(in.lookup_byte_lengths, in.lookup_byte_lengths_counts, in.binary_start, - in.byte_lookup_bin_sel, + in.byte_lookup_sel_bin, in.binary_in_tag, in.binary_mem_tag_ctr, in.byte_lookup_table_in_tags, @@ -156,7 +156,7 @@ class lookup_byte_lengths_lookup_settings { return std::forward_as_tuple(in.lookup_byte_lengths, in.lookup_byte_lengths_counts, in.binary_start, - in.byte_lookup_bin_sel, + in.byte_lookup_sel_bin, in.binary_in_tag, in.binary_mem_tag_ctr, in.byte_lookup_table_in_tags, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp index a91aa2dcb65..94b514151e5 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp @@ -87,7 +87,7 @@ class lookup_byte_operations_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.binary_bin_sel == 1 || in.byte_lookup_bin_sel == 1); + return (in.binary_sel_bin == 1 || in.byte_lookup_sel_bin == 1); } /** @@ -104,8 +104,8 @@ class lookup_byte_operations_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.binary_bin_sel); - const auto is_table_entry = View(in.byte_lookup_bin_sel); + const auto is_operation = View(in.binary_sel_bin); + const auto is_table_entry = View(in.byte_lookup_sel_bin); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,8 +135,8 @@ class lookup_byte_operations_lookup_settings { return std::forward_as_tuple(in.lookup_byte_operations, in.lookup_byte_operations_counts, - in.binary_bin_sel, - in.byte_lookup_bin_sel, + in.binary_sel_bin, + in.byte_lookup_sel_bin, in.binary_op_id, in.binary_ia_bytes, in.binary_ib_bytes, @@ -159,8 +159,8 @@ class lookup_byte_operations_lookup_settings { return std::forward_as_tuple(in.lookup_byte_operations, in.lookup_byte_operations_counts, - in.binary_bin_sel, - in.byte_lookup_bin_sel, + in.binary_sel_bin, + in.byte_lookup_sel_bin, in.binary_op_id, in.binary_ia_bytes, in.binary_ib_bytes, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_0.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_0.hpp index efe5f4c138e..405c7068df5 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_0.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_0.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_0_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_0_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_0_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_0, in.lookup_div_u16_0_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r0, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_0_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_0, in.lookup_div_u16_0_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r0, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_1.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_1.hpp index 5f460892442..2a66fac3525 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_1.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_1.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_1_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_1_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_1_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_1, in.lookup_div_u16_1_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r1, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_1_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_1, in.lookup_div_u16_1_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r1, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_2.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_2.hpp index 85af9347a6d..02d12a78597 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_2.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_2.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_2_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_2_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_2_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_2, in.lookup_div_u16_2_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r2, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_2_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_2, in.lookup_div_u16_2_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r2, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_3.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_3.hpp index dd9c4f6b95c..438d59d1d4a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_3.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_3.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_3_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_3_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_3_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_3, in.lookup_div_u16_3_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r3, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_3_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_3, in.lookup_div_u16_3_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r3, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_4.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_4.hpp index 5b50c3a08db..7dd1c7cac4f 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_4.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_4.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_4_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_4_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_4_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_4, in.lookup_div_u16_4_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r4, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_4_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_4, in.lookup_div_u16_4_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r4, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_5.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_5.hpp index 7b1a4bf30ec..cf3b6d8c71f 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_5.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_5.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_5_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_5_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_5_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_5, in.lookup_div_u16_5_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r5, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_5_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_5, in.lookup_div_u16_5_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r5, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_6.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_6.hpp index fa2c31c2dee..d78115f533c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_6.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_6.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_6_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_6_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_6_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_6, in.lookup_div_u16_6_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r6, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_6_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_6, in.lookup_div_u16_6_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r6, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_7.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_7.hpp index 37b5c6ca133..3ddb1cc484d 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_7.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_div_u16_7.hpp @@ -87,7 +87,7 @@ class lookup_div_u16_7_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_div_rng_chk_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_div_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_div_u16_7_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_div_rng_chk_selector); + const auto is_operation = View(in.alu_sel_div_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_div_u16_7_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_7, in.lookup_div_u16_7_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r7, in.main_clk); @@ -153,7 +153,7 @@ class lookup_div_u16_7_lookup_settings { return std::forward_as_tuple(in.lookup_div_u16_7, in.lookup_div_u16_7_counts, - in.alu_div_rng_chk_selector, + in.alu_sel_div_rng_chk, in.main_sel_rng_16, in.alu_div_u16_r7, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_kernel.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_kernel.hpp index bf3f81dbe7b..0dc497d421a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_kernel.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_kernel.hpp @@ -87,7 +87,7 @@ class lookup_into_kernel_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_q_kernel_lookup == 1 || in.kernel_q_public_input_kernel_add_to_table == 1); + return (in.main_sel_q_kernel_lookup == 1 || in.kernel_q_public_input_kernel_add_to_table == 1); } /** @@ -104,7 +104,7 @@ class lookup_into_kernel_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.main_q_kernel_lookup); + const auto is_operation = View(in.main_sel_q_kernel_lookup); const auto is_table_entry = View(in.kernel_q_public_input_kernel_add_to_table); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_into_kernel_lookup_settings { return std::forward_as_tuple(in.lookup_into_kernel, in.lookup_into_kernel_counts, - in.main_q_kernel_lookup, + in.main_sel_q_kernel_lookup, in.kernel_q_public_input_kernel_add_to_table, in.main_ia, in.kernel_kernel_in_offset, @@ -155,7 +155,7 @@ class lookup_into_kernel_lookup_settings { return std::forward_as_tuple(in.lookup_into_kernel, in.lookup_into_kernel_counts, - in.main_q_kernel_lookup, + in.main_sel_q_kernel_lookup, in.kernel_q_public_input_kernel_add_to_table, in.main_ia, in.kernel_kernel_in_offset, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_hi.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_hi.hpp index 2ddc7981d4b..7557705c592 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_hi.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_hi.hpp @@ -87,7 +87,7 @@ class lookup_mem_rng_chk_hi_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.mem_rng_chk_sel == 1 || in.main_sel_rng_8 == 1); + return (in.mem_sel_rng_chk == 1 || in.main_sel_rng_8 == 1); } /** @@ -104,7 +104,7 @@ class lookup_mem_rng_chk_hi_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.mem_rng_chk_sel); + const auto is_operation = View(in.mem_sel_rng_chk); const auto is_table_entry = View(in.main_sel_rng_8); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_mem_rng_chk_hi_lookup_settings { return std::forward_as_tuple(in.lookup_mem_rng_chk_hi, in.lookup_mem_rng_chk_hi_counts, - in.mem_rng_chk_sel, + in.mem_sel_rng_chk, in.main_sel_rng_8, in.mem_diff_hi, in.main_clk); @@ -153,7 +153,7 @@ class lookup_mem_rng_chk_hi_lookup_settings { return std::forward_as_tuple(in.lookup_mem_rng_chk_hi, in.lookup_mem_rng_chk_hi_counts, - in.mem_rng_chk_sel, + in.mem_sel_rng_chk, in.main_sel_rng_8, in.mem_diff_hi, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_lo.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_lo.hpp index dcfbcad3fea..ebe9884b863 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_lo.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_lo.hpp @@ -87,7 +87,7 @@ class lookup_mem_rng_chk_lo_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.mem_rng_chk_sel == 1 || in.main_sel_rng_16 == 1); + return (in.mem_sel_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_mem_rng_chk_lo_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.mem_rng_chk_sel); + const auto is_operation = View(in.mem_sel_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_mem_rng_chk_lo_lookup_settings { return std::forward_as_tuple(in.lookup_mem_rng_chk_lo, in.lookup_mem_rng_chk_lo_counts, - in.mem_rng_chk_sel, + in.mem_sel_rng_chk, in.main_sel_rng_16, in.mem_diff_lo, in.main_clk); @@ -153,7 +153,7 @@ class lookup_mem_rng_chk_lo_lookup_settings { return std::forward_as_tuple(in.lookup_mem_rng_chk_lo, in.lookup_mem_rng_chk_lo_counts, - in.mem_rng_chk_sel, + in.mem_sel_rng_chk, in.main_sel_rng_16, in.mem_diff_lo, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_mid.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_mid.hpp index b739f3e0736..45b8a5f03ff 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_mid.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_mem_rng_chk_mid.hpp @@ -87,7 +87,7 @@ class lookup_mem_rng_chk_mid_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.mem_rng_chk_sel == 1 || in.main_sel_rng_16 == 1); + return (in.mem_sel_rng_chk == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_mem_rng_chk_mid_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.mem_rng_chk_sel); + const auto is_operation = View(in.mem_sel_rng_chk); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_mem_rng_chk_mid_lookup_settings { return std::forward_as_tuple(in.lookup_mem_rng_chk_mid, in.lookup_mem_rng_chk_mid_counts, - in.mem_rng_chk_sel, + in.mem_sel_rng_chk, in.main_sel_rng_16, in.mem_diff_mid, in.main_clk); @@ -153,7 +153,7 @@ class lookup_mem_rng_chk_mid_lookup_settings { return std::forward_as_tuple(in.lookup_mem_rng_chk_mid, in.lookup_mem_rng_chk_mid_counts, - in.mem_rng_chk_sel, + in.mem_sel_rng_chk, in.main_sel_rng_16, in.mem_diff_mid, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_opcode_gas.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_opcode_gas.hpp index b6514706cf7..1a164fc171a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_opcode_gas.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_opcode_gas.hpp @@ -87,7 +87,7 @@ class lookup_opcode_gas_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_gas_cost_active == 1 || in.gas_gas_cost_sel == 1); + return (in.main_sel_gas_accounting_active == 1 || in.gas_sel_gas_cost == 1); } /** @@ -104,8 +104,8 @@ class lookup_opcode_gas_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.main_gas_cost_active); - const auto is_table_entry = View(in.gas_gas_cost_sel); + const auto is_operation = View(in.main_sel_gas_accounting_active); + const auto is_table_entry = View(in.gas_sel_gas_cost); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,11 +135,11 @@ class lookup_opcode_gas_lookup_settings { return std::forward_as_tuple(in.lookup_opcode_gas, in.lookup_opcode_gas_counts, - in.main_gas_cost_active, - in.gas_gas_cost_sel, + in.main_sel_gas_accounting_active, + in.gas_sel_gas_cost, in.main_opcode_val, - in.main_l2_gas_op, - in.main_da_gas_op, + in.main_l2_gas_op_cost, + in.main_da_gas_op_cost, in.main_clk, in.gas_l2_gas_fixed_table, in.gas_da_gas_fixed_table); @@ -157,11 +157,11 @@ class lookup_opcode_gas_lookup_settings { return std::forward_as_tuple(in.lookup_opcode_gas, in.lookup_opcode_gas_counts, - in.main_gas_cost_active, - in.gas_gas_cost_sel, + in.main_sel_gas_accounting_active, + in.gas_sel_gas_cost, in.main_opcode_val, - in.main_l2_gas_op, - in.main_da_gas_op, + in.main_l2_gas_op_cost, + in.main_da_gas_op_cost, in.main_clk, in.gas_l2_gas_fixed_table, in.gas_da_gas_fixed_table); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_0.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_0.hpp index 4fd7de1b9e9..b042e72cf58 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_0.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_0.hpp @@ -87,7 +87,7 @@ class lookup_pow_2_0_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_shift_sel == 1 || in.main_sel_rng_8 == 1); + return (in.alu_sel_shift_which == 1 || in.main_sel_rng_8 == 1); } /** @@ -104,7 +104,7 @@ class lookup_pow_2_0_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_shift_sel); + const auto is_operation = View(in.alu_sel_shift_which); const auto is_table_entry = View(in.main_sel_rng_8); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_pow_2_0_lookup_settings { return std::forward_as_tuple(in.lookup_pow_2_0, in.lookup_pow_2_0_counts, - in.alu_shift_sel, + in.alu_sel_shift_which, in.main_sel_rng_8, in.alu_ib, in.alu_two_pow_s, @@ -155,7 +155,7 @@ class lookup_pow_2_0_lookup_settings { return std::forward_as_tuple(in.lookup_pow_2_0, in.lookup_pow_2_0_counts, - in.alu_shift_sel, + in.alu_sel_shift_which, in.main_sel_rng_8, in.alu_ib, in.alu_two_pow_s, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_1.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_1.hpp index 5b92f3143ca..0e3a413289c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_1.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_pow_2_1.hpp @@ -87,7 +87,7 @@ class lookup_pow_2_1_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_shift_sel == 1 || in.main_sel_rng_8 == 1); + return (in.alu_sel_shift_which == 1 || in.main_sel_rng_8 == 1); } /** @@ -104,7 +104,7 @@ class lookup_pow_2_1_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_shift_sel); + const auto is_operation = View(in.alu_sel_shift_which); const auto is_table_entry = View(in.main_sel_rng_8); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_pow_2_1_lookup_settings { return std::forward_as_tuple(in.lookup_pow_2_1, in.lookup_pow_2_1_counts, - in.alu_shift_sel, + in.alu_sel_shift_which, in.main_sel_rng_8, in.alu_t_sub_s_bits, in.alu_two_pow_t_sub_s, @@ -155,7 +155,7 @@ class lookup_pow_2_1_lookup_settings { return std::forward_as_tuple(in.lookup_pow_2_1, in.lookup_pow_2_1_counts, - in.alu_shift_sel, + in.alu_sel_shift_which, in.main_sel_rng_8, in.alu_t_sub_s_bits, in.alu_two_pow_t_sub_s, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_0.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_0.hpp index 26580888db1..9fd20ef02fe 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_0.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_0.hpp @@ -87,7 +87,7 @@ class lookup_u16_0_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_0_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_0_lookup_settings { return std::forward_as_tuple(in.lookup_u16_0, in.lookup_u16_0_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r0, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_0_lookup_settings { return std::forward_as_tuple(in.lookup_u16_0, in.lookup_u16_0_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r0, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_1.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_1.hpp index 3094cc38164..5ba1b374b8d 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_1.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_1.hpp @@ -87,7 +87,7 @@ class lookup_u16_1_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_1_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_1_lookup_settings { return std::forward_as_tuple(in.lookup_u16_1, in.lookup_u16_1_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r1, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_1_lookup_settings { return std::forward_as_tuple(in.lookup_u16_1, in.lookup_u16_1_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r1, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_10.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_10.hpp index 17c36672aa0..44de0ae6aa2 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_10.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_10.hpp @@ -87,7 +87,7 @@ class lookup_u16_10_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_10_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_10_lookup_settings { return std::forward_as_tuple(in.lookup_u16_10, in.lookup_u16_10_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r10, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_10_lookup_settings { return std::forward_as_tuple(in.lookup_u16_10, in.lookup_u16_10_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r10, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_11.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_11.hpp index 60019c4ee62..d415ae20406 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_11.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_11.hpp @@ -87,7 +87,7 @@ class lookup_u16_11_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_11_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_11_lookup_settings { return std::forward_as_tuple(in.lookup_u16_11, in.lookup_u16_11_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r11, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_11_lookup_settings { return std::forward_as_tuple(in.lookup_u16_11, in.lookup_u16_11_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r11, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_12.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_12.hpp index f50760643e1..2fc33c33fed 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_12.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_12.hpp @@ -87,7 +87,7 @@ class lookup_u16_12_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_12_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_12_lookup_settings { return std::forward_as_tuple(in.lookup_u16_12, in.lookup_u16_12_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r12, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_12_lookup_settings { return std::forward_as_tuple(in.lookup_u16_12, in.lookup_u16_12_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r12, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_13.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_13.hpp index d942cd0dd5e..1c9f92c36a8 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_13.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_13.hpp @@ -87,7 +87,7 @@ class lookup_u16_13_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_13_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_13_lookup_settings { return std::forward_as_tuple(in.lookup_u16_13, in.lookup_u16_13_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r13, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_13_lookup_settings { return std::forward_as_tuple(in.lookup_u16_13, in.lookup_u16_13_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r13, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_14.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_14.hpp index bd4e9434213..3907fb353c0 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_14.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_14.hpp @@ -87,7 +87,7 @@ class lookup_u16_14_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_14_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_14_lookup_settings { return std::forward_as_tuple(in.lookup_u16_14, in.lookup_u16_14_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r14, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_14_lookup_settings { return std::forward_as_tuple(in.lookup_u16_14, in.lookup_u16_14_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r14, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_2.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_2.hpp index e794ef64b8b..7301b0fac92 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_2.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_2.hpp @@ -87,7 +87,7 @@ class lookup_u16_2_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_2_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_2_lookup_settings { return std::forward_as_tuple(in.lookup_u16_2, in.lookup_u16_2_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r2, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_2_lookup_settings { return std::forward_as_tuple(in.lookup_u16_2, in.lookup_u16_2_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r2, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_3.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_3.hpp index aa25461f347..86170a20a61 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_3.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_3.hpp @@ -87,7 +87,7 @@ class lookup_u16_3_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_3_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_3_lookup_settings { return std::forward_as_tuple(in.lookup_u16_3, in.lookup_u16_3_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r3, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_3_lookup_settings { return std::forward_as_tuple(in.lookup_u16_3, in.lookup_u16_3_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r3, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_4.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_4.hpp index 0f010b1eea5..877440f08f0 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_4.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_4.hpp @@ -87,7 +87,7 @@ class lookup_u16_4_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_4_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_4_lookup_settings { return std::forward_as_tuple(in.lookup_u16_4, in.lookup_u16_4_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r4, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_4_lookup_settings { return std::forward_as_tuple(in.lookup_u16_4, in.lookup_u16_4_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r4, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_5.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_5.hpp index a2028aa5a50..07bac6f53b7 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_5.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_5.hpp @@ -87,7 +87,7 @@ class lookup_u16_5_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_5_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_5_lookup_settings { return std::forward_as_tuple(in.lookup_u16_5, in.lookup_u16_5_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r5, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_5_lookup_settings { return std::forward_as_tuple(in.lookup_u16_5, in.lookup_u16_5_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r5, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_6.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_6.hpp index 9c5a186ced0..a3db62cea1c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_6.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_6.hpp @@ -87,7 +87,7 @@ class lookup_u16_6_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_6_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_6_lookup_settings { return std::forward_as_tuple(in.lookup_u16_6, in.lookup_u16_6_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r6, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_6_lookup_settings { return std::forward_as_tuple(in.lookup_u16_6, in.lookup_u16_6_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r6, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_7.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_7.hpp index 3aa955f0de1..5630605508c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_7.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_7.hpp @@ -87,7 +87,7 @@ class lookup_u16_7_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_7_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_7_lookup_settings { return std::forward_as_tuple(in.lookup_u16_7, in.lookup_u16_7_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r7, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_7_lookup_settings { return std::forward_as_tuple(in.lookup_u16_7, in.lookup_u16_7_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r7, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_8.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_8.hpp index 09b10c634ef..f5191fcd342 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_8.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_8.hpp @@ -87,7 +87,7 @@ class lookup_u16_8_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_8_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_8_lookup_settings { return std::forward_as_tuple(in.lookup_u16_8, in.lookup_u16_8_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r8, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_8_lookup_settings { return std::forward_as_tuple(in.lookup_u16_8, in.lookup_u16_8_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r8, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_9.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_9.hpp index 30cebbf66dc..d1337b15fd8 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_9.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u16_9.hpp @@ -87,7 +87,7 @@ class lookup_u16_9_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_16 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u16_9_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u16_9_lookup_settings { return std::forward_as_tuple(in.lookup_u16_9, in.lookup_u16_9_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r9, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u16_9_lookup_settings { return std::forward_as_tuple(in.lookup_u16_9, in.lookup_u16_9_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_16, in.alu_u16_r9, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_0.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_0.hpp index d4fcf43ca73..c3548716078 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_0.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_0.hpp @@ -87,7 +87,7 @@ class lookup_u8_0_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_8 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_8 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u8_0_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_8); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u8_0_lookup_settings { return std::forward_as_tuple(in.lookup_u8_0, in.lookup_u8_0_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_8, in.alu_u8_r0, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u8_0_lookup_settings { return std::forward_as_tuple(in.lookup_u8_0, in.lookup_u8_0_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_8, in.alu_u8_r0, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_1.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_1.hpp index 5b30cce8eb5..41cf78b9945 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_1.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_u8_1.hpp @@ -87,7 +87,7 @@ class lookup_u8_1_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.alu_rng_chk_lookup_selector == 1 || in.main_sel_rng_8 == 1); + return (in.alu_sel_rng_chk_lookup == 1 || in.main_sel_rng_8 == 1); } /** @@ -104,7 +104,7 @@ class lookup_u8_1_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.alu_rng_chk_lookup_selector); + const auto is_operation = View(in.alu_sel_rng_chk_lookup); const auto is_table_entry = View(in.main_sel_rng_8); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class lookup_u8_1_lookup_settings { return std::forward_as_tuple(in.lookup_u8_1, in.lookup_u8_1_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_8, in.alu_u8_r1, in.main_clk); @@ -153,7 +153,7 @@ class lookup_u8_1_lookup_settings { return std::forward_as_tuple(in.lookup_u8_1, in.lookup_u8_1_counts, - in.alu_rng_chk_lookup_selector, + in.alu_sel_rng_chk_lookup, in.main_sel_rng_8, in.alu_u8_r1, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp index 1adc1a1bd2b..38835bdab22 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/main.hpp @@ -26,65 +26,52 @@ template struct MainRow { FF main_abs_l2_rem_gas_hi{}; FF main_abs_l2_rem_gas_lo{}; FF main_alu_in_tag{}; - FF main_alu_sel{}; FF main_bin_op_id{}; - FF main_bin_sel{}; FF main_call_ptr{}; - FF main_da_gas_op{}; + FF main_da_gas_op_cost{}; FF main_da_gas_remaining{}; FF main_da_gas_remaining_shift{}; FF main_da_out_of_gas{}; - FF main_first{}; - FF main_gas_cost_active{}; FF main_ia{}; FF main_ib{}; FF main_ic{}; FF main_id{}; FF main_id_zero{}; - FF main_ind_op_a{}; - FF main_ind_op_b{}; - FF main_ind_op_c{}; - FF main_ind_op_d{}; FF main_internal_return_ptr{}; FF main_internal_return_ptr_shift{}; FF main_inv{}; - FF main_l2_gas_op{}; + FF main_l2_gas_op_cost{}; FF main_l2_gas_remaining{}; FF main_l2_gas_remaining_shift{}; FF main_l2_out_of_gas{}; - FF main_mem_idx_a{}; - FF main_mem_idx_b{}; - FF main_mem_op_a{}; - FF main_mem_op_activate_gas{}; - FF main_mem_op_b{}; - FF main_mem_op_c{}; - FF main_mem_op_d{}; + FF main_mem_addr_a{}; + FF main_mem_addr_b{}; FF main_op_err{}; FF main_pc{}; FF main_pc_shift{}; - FF main_q_kernel_lookup{}; - FF main_q_kernel_output_lookup{}; FF main_r_in_tag{}; FF main_rwa{}; FF main_rwb{}; FF main_rwc{}; FF main_rwd{}; - FF main_sel_cmov{}; - FF main_sel_external_call{}; - FF main_sel_halt{}; - FF main_sel_internal_call{}; - FF main_sel_internal_return{}; - FF main_sel_jump{}; - FF main_sel_jumpi{}; - FF main_sel_mov{}; - FF main_sel_mov_a{}; - FF main_sel_mov_b{}; + FF main_sel_alu{}; + FF main_sel_bin{}; + FF main_sel_first{}; + FF main_sel_gas_accounting_active{}; + FF main_sel_mem_op_a{}; + FF main_sel_mem_op_activate_gas{}; + FF main_sel_mem_op_b{}; + FF main_sel_mem_op_c{}; + FF main_sel_mem_op_d{}; + FF main_sel_mov_ia_to_ic{}; + FF main_sel_mov_ib_to_ic{}; FF main_sel_op_add{}; FF main_sel_op_address{}; FF main_sel_op_and{}; FF main_sel_op_block_number{}; FF main_sel_op_cast{}; FF main_sel_op_chain_id{}; + FF main_sel_op_cmov{}; FF main_sel_op_coinbase{}; FF main_sel_op_dagasleft{}; FF main_sel_op_div{}; @@ -93,15 +80,22 @@ template struct MainRow { FF main_sel_op_emit_nullifier{}; FF main_sel_op_emit_unencrypted_log{}; FF main_sel_op_eq{}; + FF main_sel_op_external_call{}; FF main_sel_op_fdiv{}; FF main_sel_op_fee_per_da_gas{}; FF main_sel_op_fee_per_l2_gas{}; FF main_sel_op_get_contract_instance{}; + FF main_sel_op_halt{}; + FF main_sel_op_internal_call{}; + FF main_sel_op_internal_return{}; + FF main_sel_op_jump{}; + FF main_sel_op_jumpi{}; FF main_sel_op_keccak{}; FF main_sel_op_l1_to_l2_msg_exists{}; FF main_sel_op_l2gasleft{}; FF main_sel_op_lt{}; FF main_sel_op_lte{}; + FF main_sel_op_mov{}; FF main_sel_op_mul{}; FF main_sel_op_not{}; FF main_sel_op_note_hash_exists{}; @@ -122,6 +116,12 @@ template struct MainRow { FF main_sel_op_transaction_fee{}; FF main_sel_op_version{}; FF main_sel_op_xor{}; + FF main_sel_q_kernel_lookup{}; + FF main_sel_q_kernel_output_lookup{}; + FF main_sel_resolve_ind_addr_a{}; + FF main_sel_resolve_ind_addr_b{}; + FF main_sel_resolve_ind_addr_c{}; + FF main_sel_resolve_ind_addr_d{}; FF main_space_id{}; FF main_tag_err{}; FF main_w_in_tag{}; @@ -323,8 +323,8 @@ template class mainImpl { { Avm_DECLARE_VIEWS(2); - auto tmp = - (main_gas_cost_active * ((main_l2_gas_remaining_shift - main_l2_gas_remaining) + main_l2_gas_op)); + auto tmp = (main_sel_gas_accounting_active * + ((main_l2_gas_remaining_shift - main_l2_gas_remaining) + main_l2_gas_op_cost)); tmp *= scaling_factor; std::get<2>(evals) += tmp; } @@ -332,8 +332,8 @@ template class mainImpl { { Avm_DECLARE_VIEWS(3); - auto tmp = - (main_gas_cost_active * ((main_da_gas_remaining_shift - main_da_gas_remaining) + main_da_gas_op)); + auto tmp = (main_sel_gas_accounting_active * + ((main_da_gas_remaining_shift - main_da_gas_remaining) + main_da_gas_op_cost)); tmp *= scaling_factor; std::get<3>(evals) += tmp; } @@ -341,7 +341,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(4); - auto tmp = ((-main_gas_cost_active + FF(1)) * main_l2_gas_op); + auto tmp = ((-main_sel_gas_accounting_active + FF(1)) * main_l2_gas_op_cost); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -349,7 +349,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(5); - auto tmp = ((-main_gas_cost_active + FF(1)) * main_da_gas_op); + auto tmp = ((-main_sel_gas_accounting_active + FF(1)) * main_da_gas_op_cost); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -357,10 +357,10 @@ template class mainImpl { { Avm_DECLARE_VIEWS(6); - auto tmp = - (main_gas_cost_active * ((((-(main_l2_out_of_gas * FF(2)) + FF(1)) * main_l2_gas_remaining_shift) - - (main_abs_l2_rem_gas_hi * FF(65536))) - - main_abs_l2_rem_gas_lo)); + auto tmp = (main_sel_gas_accounting_active * + ((((-(main_l2_out_of_gas * FF(2)) + FF(1)) * main_l2_gas_remaining_shift) - + (main_abs_l2_rem_gas_hi * FF(65536))) - + main_abs_l2_rem_gas_lo)); tmp *= scaling_factor; std::get<6>(evals) += tmp; } @@ -368,10 +368,10 @@ template class mainImpl { { Avm_DECLARE_VIEWS(7); - auto tmp = - (main_gas_cost_active * ((((-(main_da_out_of_gas * FF(2)) + FF(1)) * main_da_gas_remaining_shift) - - (main_abs_da_rem_gas_hi * FF(65536))) - - main_abs_da_rem_gas_lo)); + auto tmp = (main_sel_gas_accounting_active * + ((((-(main_da_out_of_gas * FF(2)) + FF(1)) * main_da_gas_remaining_shift) - + (main_abs_da_rem_gas_hi * FF(65536))) - + main_abs_da_rem_gas_lo)); tmp *= scaling_factor; std::get<7>(evals) += tmp; } @@ -723,7 +723,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(51); - auto tmp = (main_sel_internal_call * (-main_sel_internal_call + FF(1))); + auto tmp = (main_sel_op_internal_call * (-main_sel_op_internal_call + FF(1))); tmp *= scaling_factor; std::get<51>(evals) += tmp; } @@ -731,7 +731,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(52); - auto tmp = (main_sel_internal_return * (-main_sel_internal_return + FF(1))); + auto tmp = (main_sel_op_internal_return * (-main_sel_op_internal_return + FF(1))); tmp *= scaling_factor; std::get<52>(evals) += tmp; } @@ -739,7 +739,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(53); - auto tmp = (main_sel_jump * (-main_sel_jump + FF(1))); + auto tmp = (main_sel_op_jump * (-main_sel_op_jump + FF(1))); tmp *= scaling_factor; std::get<53>(evals) += tmp; } @@ -747,7 +747,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(54); - auto tmp = (main_sel_jumpi * (-main_sel_jumpi + FF(1))); + auto tmp = (main_sel_op_jumpi * (-main_sel_op_jumpi + FF(1))); tmp *= scaling_factor; std::get<54>(evals) += tmp; } @@ -755,7 +755,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(55); - auto tmp = (main_sel_halt * (-main_sel_halt + FF(1))); + auto tmp = (main_sel_op_halt * (-main_sel_op_halt + FF(1))); tmp *= scaling_factor; std::get<55>(evals) += tmp; } @@ -763,7 +763,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(56); - auto tmp = (main_sel_external_call * (-main_sel_external_call + FF(1))); + auto tmp = (main_sel_op_external_call * (-main_sel_op_external_call + FF(1))); tmp *= scaling_factor; std::get<56>(evals) += tmp; } @@ -771,7 +771,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(57); - auto tmp = (main_sel_mov * (-main_sel_mov + FF(1))); + auto tmp = (main_sel_op_mov * (-main_sel_op_mov + FF(1))); tmp *= scaling_factor; std::get<57>(evals) += tmp; } @@ -779,7 +779,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(58); - auto tmp = (main_sel_cmov * (-main_sel_cmov + FF(1))); + auto tmp = (main_sel_op_cmov * (-main_sel_op_cmov + FF(1))); tmp *= scaling_factor; std::get<58>(evals) += tmp; } @@ -811,7 +811,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(62); - auto tmp = (main_mem_op_a * (-main_mem_op_a + FF(1))); + auto tmp = (main_sel_mem_op_a * (-main_sel_mem_op_a + FF(1))); tmp *= scaling_factor; std::get<62>(evals) += tmp; } @@ -819,7 +819,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(63); - auto tmp = (main_mem_op_b * (-main_mem_op_b + FF(1))); + auto tmp = (main_sel_mem_op_b * (-main_sel_mem_op_b + FF(1))); tmp *= scaling_factor; std::get<63>(evals) += tmp; } @@ -827,7 +827,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(64); - auto tmp = (main_mem_op_c * (-main_mem_op_c + FF(1))); + auto tmp = (main_sel_mem_op_c * (-main_sel_mem_op_c + FF(1))); tmp *= scaling_factor; std::get<64>(evals) += tmp; } @@ -835,7 +835,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(65); - auto tmp = (main_mem_op_d * (-main_mem_op_d + FF(1))); + auto tmp = (main_sel_mem_op_d * (-main_sel_mem_op_d + FF(1))); tmp *= scaling_factor; std::get<65>(evals) += tmp; } @@ -875,7 +875,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(70); - auto tmp = (main_ind_op_a * (-main_ind_op_a + FF(1))); + auto tmp = (main_sel_resolve_ind_addr_a * (-main_sel_resolve_ind_addr_a + FF(1))); tmp *= scaling_factor; std::get<70>(evals) += tmp; } @@ -883,7 +883,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(71); - auto tmp = (main_ind_op_b * (-main_ind_op_b + FF(1))); + auto tmp = (main_sel_resolve_ind_addr_b * (-main_sel_resolve_ind_addr_b + FF(1))); tmp *= scaling_factor; std::get<71>(evals) += tmp; } @@ -891,7 +891,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(72); - auto tmp = (main_ind_op_c * (-main_ind_op_c + FF(1))); + auto tmp = (main_sel_resolve_ind_addr_c * (-main_sel_resolve_ind_addr_c + FF(1))); tmp *= scaling_factor; std::get<72>(evals) += tmp; } @@ -899,7 +899,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(73); - auto tmp = (main_ind_op_d * (-main_ind_op_d + FF(1))); + auto tmp = (main_sel_resolve_ind_addr_d * (-main_sel_resolve_ind_addr_d + FF(1))); tmp *= scaling_factor; std::get<73>(evals) += tmp; } @@ -972,7 +972,7 @@ template class mainImpl { main_sel_op_fee_per_l2_gas) + main_sel_op_fee_per_da_gas) + main_sel_op_transaction_fee) * - (-main_q_kernel_lookup + FF(1))); + (-main_sel_q_kernel_lookup + FF(1))); tmp *= scaling_factor; std::get<81>(evals) += tmp; } @@ -986,7 +986,7 @@ template class mainImpl { main_sel_op_l1_to_l2_msg_exists) + main_sel_op_emit_unencrypted_log) + main_sel_op_emit_l2_to_l1_msg) * - (-main_q_kernel_output_lookup + FF(1))); + (-main_sel_q_kernel_output_lookup + FF(1))); tmp *= scaling_factor; std::get<82>(evals) += tmp; } @@ -994,7 +994,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(83); - auto tmp = (main_sel_jump * (main_pc_shift - main_ia)); + auto tmp = (main_sel_op_jump * (main_pc_shift - main_ia)); tmp *= scaling_factor; std::get<83>(evals) += tmp; } @@ -1002,8 +1002,8 @@ template class mainImpl { { Avm_DECLARE_VIEWS(84); - auto tmp = (main_sel_jumpi * (((-main_id_zero + FF(1)) * (main_pc_shift - main_ia)) + - (main_id_zero * ((main_pc_shift - main_pc) - FF(1))))); + auto tmp = (main_sel_op_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<84>(evals) += tmp; } @@ -1011,7 +1011,8 @@ template class mainImpl { { Avm_DECLARE_VIEWS(85); - auto tmp = (main_sel_internal_call * (main_internal_return_ptr_shift - (main_internal_return_ptr + FF(1)))); + auto tmp = + (main_sel_op_internal_call * (main_internal_return_ptr_shift - (main_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<85>(evals) += tmp; } @@ -1019,7 +1020,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(86); - auto tmp = (main_sel_internal_call * (main_internal_return_ptr - main_mem_idx_b)); + auto tmp = (main_sel_op_internal_call * (main_internal_return_ptr - main_mem_addr_b)); tmp *= scaling_factor; std::get<86>(evals) += tmp; } @@ -1027,7 +1028,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(87); - auto tmp = (main_sel_internal_call * (main_pc_shift - main_ia)); + auto tmp = (main_sel_op_internal_call * (main_pc_shift - main_ia)); tmp *= scaling_factor; std::get<87>(evals) += tmp; } @@ -1035,7 +1036,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(88); - auto tmp = (main_sel_internal_call * ((main_pc + FF(1)) - main_ib)); + auto tmp = (main_sel_op_internal_call * ((main_pc + FF(1)) - main_ib)); tmp *= scaling_factor; std::get<88>(evals) += tmp; } @@ -1043,7 +1044,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(89); - auto tmp = (main_sel_internal_call * (main_rwb - FF(1))); + auto tmp = (main_sel_op_internal_call * (main_rwb - FF(1))); tmp *= scaling_factor; std::get<89>(evals) += tmp; } @@ -1051,7 +1052,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(90); - auto tmp = (main_sel_internal_call * (main_mem_op_b - FF(1))); + auto tmp = (main_sel_op_internal_call * (main_sel_mem_op_b - FF(1))); tmp *= scaling_factor; std::get<90>(evals) += tmp; } @@ -1060,7 +1061,7 @@ template class mainImpl { Avm_DECLARE_VIEWS(91); auto tmp = - (main_sel_internal_return * (main_internal_return_ptr_shift - (main_internal_return_ptr - FF(1)))); + (main_sel_op_internal_return * (main_internal_return_ptr_shift - (main_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<91>(evals) += tmp; } @@ -1068,7 +1069,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(92); - auto tmp = (main_sel_internal_return * ((main_internal_return_ptr - FF(1)) - main_mem_idx_a)); + auto tmp = (main_sel_op_internal_return * ((main_internal_return_ptr - FF(1)) - main_mem_addr_a)); tmp *= scaling_factor; std::get<92>(evals) += tmp; } @@ -1076,7 +1077,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(93); - auto tmp = (main_sel_internal_return * (main_pc_shift - main_ia)); + auto tmp = (main_sel_op_internal_return * (main_pc_shift - main_ia)); tmp *= scaling_factor; std::get<93>(evals) += tmp; } @@ -1084,7 +1085,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(94); - auto tmp = (main_sel_internal_return * main_rwa); + auto tmp = (main_sel_op_internal_return * main_rwa); tmp *= scaling_factor; std::get<94>(evals) += tmp; } @@ -1092,7 +1093,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(95); - auto tmp = (main_sel_internal_return * (main_mem_op_a - FF(1))); + auto tmp = (main_sel_op_internal_return * (main_sel_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<95>(evals) += tmp; } @@ -1101,7 +1102,7 @@ template class mainImpl { Avm_DECLARE_VIEWS(96); auto tmp = - (((((main_gas_cost_active - + (((((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) + @@ -1112,7 +1113,7 @@ template class mainImpl { main_sel_op_shl) + main_sel_op_cast)) + ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)) + - (main_sel_cmov + main_sel_mov)) + + (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_sender + main_sel_op_address) + main_sel_op_storage_address) + @@ -1131,10 +1132,11 @@ template class mainImpl { main_sel_op_emit_unencrypted_log) + main_sel_op_emit_l2_to_l1_msg)) + (main_sel_op_dagasleft + main_sel_op_l2gasleft))) - - (((main_sel_jump + main_sel_jumpi) + main_sel_internal_call) + main_sel_internal_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_mem_op_activate_gas); + main_sel_mem_op_activate_gas); tmp *= scaling_factor; std::get<96>(evals) += tmp; } @@ -1143,7 +1145,7 @@ template class mainImpl { Avm_DECLARE_VIEWS(97); auto tmp = - ((((-main_first + FF(1)) * (-main_sel_halt + FF(1))) * + ((((-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) + @@ -1154,7 +1156,7 @@ template class mainImpl { main_sel_op_shl) + main_sel_op_cast)) + ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)) + - (main_sel_cmov + main_sel_mov)) + + (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_sender + main_sel_op_address) + main_sel_op_storage_address) + @@ -1181,7 +1183,8 @@ template class mainImpl { Avm_DECLARE_VIEWS(98); auto tmp = - ((-(((main_first + main_sel_internal_call) + main_sel_internal_return) + main_sel_halt) + FF(1)) * + ((-(((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<98>(evals) += tmp; @@ -1190,7 +1193,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(99); - auto tmp = ((main_sel_internal_call + main_sel_internal_return) * (main_space_id - FF(255))); + auto tmp = ((main_sel_op_internal_call + main_sel_op_internal_return) * (main_space_id - FF(255))); tmp *= scaling_factor; std::get<99>(evals) += tmp; } @@ -1209,7 +1212,7 @@ template class mainImpl { main_sel_op_shl) + main_sel_op_cast)) + ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)) + - (main_sel_cmov + main_sel_mov)) + + (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_sender + main_sel_op_address) + main_sel_op_storage_address) + @@ -1235,7 +1238,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(101); - auto tmp = ((main_sel_cmov + main_sel_jumpi) * (((main_id * main_inv) - FF(1)) + main_id_zero)); + auto tmp = ((main_sel_op_cmov + main_sel_op_jumpi) * (((main_id * main_inv) - FF(1)) + main_id_zero)); tmp *= scaling_factor; std::get<101>(evals) += tmp; } @@ -1243,7 +1246,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(102); - auto tmp = (((main_sel_cmov + main_sel_jumpi) * main_id_zero) * (-main_inv + FF(1))); + auto tmp = (((main_sel_op_cmov + main_sel_op_jumpi) * main_id_zero) * (-main_inv + FF(1))); tmp *= scaling_factor; std::get<102>(evals) += tmp; } @@ -1251,7 +1254,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(103); - auto tmp = (main_sel_mov_a - (main_sel_mov + (main_sel_cmov * (-main_id_zero + FF(1))))); + 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<103>(evals) += tmp; } @@ -1259,7 +1262,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(104); - auto tmp = (main_sel_mov_b - (main_sel_cmov * main_id_zero)); + auto tmp = (main_sel_mov_ib_to_ic - (main_sel_op_cmov * main_id_zero)); tmp *= scaling_factor; std::get<104>(evals) += tmp; } @@ -1267,7 +1270,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(105); - auto tmp = (main_sel_mov_a * (main_ia - main_ic)); + auto tmp = (main_sel_mov_ia_to_ic * (main_ia - main_ic)); tmp *= scaling_factor; std::get<105>(evals) += tmp; } @@ -1275,7 +1278,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(106); - auto tmp = (main_sel_mov_b * (main_ib - main_ic)); + auto tmp = (main_sel_mov_ib_to_ic * (main_ib - main_ic)); tmp *= scaling_factor; std::get<106>(evals) += tmp; } @@ -1283,7 +1286,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(107); - auto tmp = ((main_sel_mov + main_sel_cmov) * (main_r_in_tag - main_w_in_tag)); + auto tmp = ((main_sel_op_mov + main_sel_op_cmov) * (main_r_in_tag - main_w_in_tag)); tmp *= scaling_factor; std::get<107>(evals) += tmp; } @@ -1292,7 +1295,7 @@ template class mainImpl { Avm_DECLARE_VIEWS(108); auto tmp = - (main_alu_sel - ((((((((((((main_sel_op_add + main_sel_op_sub) + main_sel_op_mul) + main_sel_op_div) + + (main_sel_alu - ((((((((((((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) + @@ -1445,7 +1448,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(125); - auto tmp = (main_first * kernel_note_hash_exist_write_offset); + auto tmp = (main_sel_first * kernel_note_hash_exist_write_offset); tmp *= scaling_factor; std::get<125>(evals) += tmp; } @@ -1462,7 +1465,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(127); - auto tmp = (main_first * kernel_emit_note_hash_write_offset); + auto tmp = (main_sel_first * kernel_emit_note_hash_write_offset); tmp *= scaling_factor; std::get<127>(evals) += tmp; } @@ -1481,7 +1484,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(129); - auto tmp = (main_first * kernel_nullifier_exists_write_offset); + auto tmp = (main_sel_first * kernel_nullifier_exists_write_offset); tmp *= scaling_factor; std::get<129>(evals) += tmp; } @@ -1489,7 +1492,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(130); - auto tmp = (main_first * kernel_nullifier_non_exists_write_offset); + auto tmp = (main_sel_first * kernel_nullifier_non_exists_write_offset); tmp *= scaling_factor; std::get<130>(evals) += tmp; } @@ -1506,7 +1509,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(132); - auto tmp = (main_first * kernel_emit_nullifier_write_offset); + auto tmp = (main_sel_first * kernel_emit_nullifier_write_offset); tmp *= scaling_factor; std::get<132>(evals) += tmp; } @@ -1523,7 +1526,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(134); - auto tmp = (main_first * kernel_l1_to_l2_msg_exists_write_offset); + auto tmp = (main_sel_first * kernel_l1_to_l2_msg_exists_write_offset); tmp *= scaling_factor; std::get<134>(evals) += tmp; } @@ -1540,7 +1543,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(136); - auto tmp = (main_first * kernel_emit_unencrypted_log_write_offset); + auto tmp = (main_sel_first * kernel_emit_unencrypted_log_write_offset); tmp *= scaling_factor; std::get<136>(evals) += tmp; } @@ -1557,7 +1560,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(138); - auto tmp = (main_first * kernel_emit_l2_to_l1_msg_write_offset); + auto tmp = (main_sel_first * kernel_emit_l2_to_l1_msg_write_offset); tmp *= scaling_factor; std::get<138>(evals) += tmp; } @@ -1573,7 +1576,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(140); - auto tmp = (main_first * kernel_sload_write_offset); + auto tmp = (main_sel_first * kernel_sload_write_offset); tmp *= scaling_factor; std::get<140>(evals) += tmp; } @@ -1589,7 +1592,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(142); - auto tmp = (main_first * kernel_sstore_write_offset); + auto tmp = (main_sel_first * kernel_sstore_write_offset); tmp *= scaling_factor; std::get<142>(evals) += tmp; } @@ -1619,7 +1622,7 @@ template class mainImpl { { Avm_DECLARE_VIEWS(145); - auto tmp = (main_bin_sel - ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)); + auto tmp = (main_sel_bin - ((main_sel_op_and + main_sel_op_or) + main_sel_op_xor)); tmp *= scaling_factor; std::get<145>(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 c3a5a9805e1..8b1c6dcfe57 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/mem.hpp @@ -7,7 +7,7 @@ namespace bb::Avm_vm { template struct MemRow { - FF main_first{}; + FF main_sel_first{}; FF mem_addr{}; FF mem_clk{}; FF mem_diff_hi{}; @@ -15,26 +15,26 @@ template struct MemRow { FF mem_diff_mid{}; FF mem_glob_addr{}; FF mem_glob_addr_shift{}; - FF mem_ind_op_a{}; - FF mem_ind_op_b{}; - FF mem_ind_op_c{}; - FF mem_ind_op_d{}; FF mem_last{}; FF mem_lastAccess{}; - FF mem_mem_sel{}; - FF mem_mem_sel_shift{}; FF mem_one_min_inv{}; - FF mem_op_a{}; - FF mem_op_b{}; - FF mem_op_c{}; - FF mem_op_d{}; FF mem_r_in_tag{}; - FF mem_rng_chk_sel{}; FF mem_rw{}; FF mem_rw_shift{}; - FF mem_sel_cmov{}; - FF mem_sel_mov_a{}; - FF mem_sel_mov_b{}; + FF mem_sel_mem{}; + FF mem_sel_mem_shift{}; + FF mem_sel_mov_ia_to_ic{}; + FF mem_sel_mov_ib_to_ic{}; + FF mem_sel_op_a{}; + FF mem_sel_op_b{}; + FF mem_sel_op_c{}; + FF mem_sel_op_cmov{}; + FF mem_sel_op_d{}; + FF mem_sel_resolve_ind_addr_a{}; + FF mem_sel_resolve_ind_addr_b{}; + FF mem_sel_resolve_ind_addr_c{}; + FF mem_sel_resolve_ind_addr_d{}; + FF mem_sel_rng_chk{}; FF mem_skip_check_tag{}; FF mem_space_id{}; FF mem_tag{}; @@ -158,7 +158,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(4); - auto tmp = (mem_op_a * (-mem_op_a + FF(1))); + auto tmp = (mem_sel_op_a * (-mem_sel_op_a + FF(1))); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -166,7 +166,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(5); - auto tmp = (mem_op_b * (-mem_op_b + FF(1))); + auto tmp = (mem_sel_op_b * (-mem_sel_op_b + FF(1))); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -174,7 +174,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(6); - auto tmp = (mem_op_c * (-mem_op_c + FF(1))); + auto tmp = (mem_sel_op_c * (-mem_sel_op_c + FF(1))); tmp *= scaling_factor; std::get<6>(evals) += tmp; } @@ -182,7 +182,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(7); - auto tmp = (mem_op_d * (-mem_op_d + FF(1))); + auto tmp = (mem_sel_op_d * (-mem_sel_op_d + FF(1))); tmp *= scaling_factor; std::get<7>(evals) += tmp; } @@ -190,7 +190,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(8); - auto tmp = (mem_ind_op_a * (-mem_ind_op_a + FF(1))); + auto tmp = (mem_sel_resolve_ind_addr_a * (-mem_sel_resolve_ind_addr_a + FF(1))); tmp *= scaling_factor; std::get<8>(evals) += tmp; } @@ -198,7 +198,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(9); - auto tmp = (mem_ind_op_b * (-mem_ind_op_b + FF(1))); + auto tmp = (mem_sel_resolve_ind_addr_b * (-mem_sel_resolve_ind_addr_b + FF(1))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } @@ -206,7 +206,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(10); - auto tmp = (mem_ind_op_c * (-mem_ind_op_c + FF(1))); + auto tmp = (mem_sel_resolve_ind_addr_c * (-mem_sel_resolve_ind_addr_c + FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; } @@ -214,7 +214,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(11); - auto tmp = (mem_ind_op_d * (-mem_ind_op_d + FF(1))); + auto tmp = (mem_sel_resolve_ind_addr_d * (-mem_sel_resolve_ind_addr_d + FF(1))); tmp *= scaling_factor; std::get<11>(evals) += tmp; } @@ -223,9 +223,11 @@ template class memImpl { Avm_DECLARE_VIEWS(12); auto tmp = - (mem_mem_sel - - (((((((mem_op_a + mem_op_b) + mem_op_c) + mem_op_d) + mem_ind_op_a) + mem_ind_op_b) + mem_ind_op_c) + - mem_ind_op_d)); + (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)); tmp *= scaling_factor; std::get<12>(evals) += tmp; } @@ -233,7 +235,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(13); - auto tmp = (mem_mem_sel * (mem_mem_sel - FF(1))); + auto tmp = (mem_sel_mem * (mem_sel_mem - FF(1))); tmp *= scaling_factor; std::get<13>(evals) += tmp; } @@ -241,7 +243,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(14); - auto tmp = (((-main_first + FF(1)) * mem_mem_sel_shift) * (-mem_mem_sel + FF(1))); + auto tmp = (((-main_sel_first + FF(1)) * mem_sel_mem_shift) * (-mem_sel_mem + FF(1))); tmp *= scaling_factor; std::get<14>(evals) += tmp; } @@ -249,7 +251,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(15); - auto tmp = (main_first * mem_mem_sel); + auto tmp = (main_sel_first * mem_sel_mem); tmp *= scaling_factor; std::get<15>(evals) += tmp; } @@ -257,7 +259,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(16); - auto tmp = (((-mem_last + FF(1)) * mem_mem_sel) * (-mem_mem_sel_shift + FF(1))); + auto tmp = (((-mem_last + FF(1)) * mem_sel_mem) * (-mem_sel_mem_shift + FF(1))); tmp *= scaling_factor; std::get<16>(evals) += tmp; } @@ -265,7 +267,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(17); - auto tmp = (mem_rng_chk_sel - (mem_mem_sel * (-mem_last + FF(1)))); + auto tmp = (mem_sel_rng_chk - (mem_sel_mem * (-mem_last + FF(1)))); tmp *= scaling_factor; std::get<17>(evals) += tmp; } @@ -276,10 +278,15 @@ template class memImpl { auto tmp = (mem_tsp - ((mem_clk * FF(12)) + - (mem_mem_sel * - ((((mem_ind_op_b + mem_op_b) + ((mem_ind_op_c + mem_op_c) * FF(2))) + - ((mem_ind_op_d + mem_op_d) * FF(3))) + - (((-(((mem_ind_op_a + mem_ind_op_b) + mem_ind_op_c) + mem_ind_op_d) + FF(1)) + mem_rw) * FF(4)))))); + (mem_sel_mem * + ((((mem_sel_resolve_ind_addr_b + mem_sel_op_b) + + ((mem_sel_resolve_ind_addr_c + mem_sel_op_c) * FF(2))) + + ((mem_sel_resolve_ind_addr_d + mem_sel_op_d) * FF(3))) + + (((-(((mem_sel_resolve_ind_addr_a + mem_sel_resolve_ind_addr_b) + mem_sel_resolve_ind_addr_c) + + mem_sel_resolve_ind_addr_d) + + FF(1)) + + mem_rw) * + FF(4)))))); tmp *= scaling_factor; std::get<18>(evals) += tmp; } @@ -295,7 +302,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(20); - auto tmp = (main_first * (-mem_lastAccess + FF(1))); + auto tmp = (main_sel_first * (-mem_lastAccess + FF(1))); tmp *= scaling_factor; std::get<20>(evals) += tmp; } @@ -311,7 +318,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(22); - auto tmp = (mem_rng_chk_sel * (((((mem_lastAccess * (mem_glob_addr_shift - mem_glob_addr)) + + 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))) - @@ -347,8 +354,9 @@ template class memImpl { { Avm_DECLARE_VIEWS(26); - auto tmp = (mem_skip_check_tag - (mem_sel_cmov * ((mem_op_d + (mem_op_a * (-mem_sel_mov_a + FF(1)))) + - (mem_op_b * (-mem_sel_mov_b + FF(1)))))); + auto tmp = (mem_skip_check_tag - + (mem_sel_op_cmov * ((mem_sel_op_d + (mem_sel_op_a * (-mem_sel_mov_ia_to_ic + FF(1)))) + + (mem_sel_op_b * (-mem_sel_mov_ib_to_ic + FF(1)))))); tmp *= scaling_factor; std::get<26>(evals) += tmp; } @@ -397,7 +405,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(32); - auto tmp = (mem_ind_op_a * (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<32>(evals) += tmp; } @@ -405,7 +413,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(33); - auto tmp = (mem_ind_op_b * (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<33>(evals) += tmp; } @@ -413,7 +421,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(34); - auto tmp = (mem_ind_op_c * (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<34>(evals) += tmp; } @@ -421,7 +429,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(35); - auto tmp = (mem_ind_op_d * (mem_r_in_tag - FF(3))); + auto tmp = (mem_sel_resolve_ind_addr_d * (mem_r_in_tag - FF(3))); tmp *= scaling_factor; std::get<35>(evals) += tmp; } @@ -429,7 +437,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(36); - auto tmp = (mem_ind_op_a * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_a * mem_rw); tmp *= scaling_factor; std::get<36>(evals) += tmp; } @@ -437,7 +445,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(37); - auto tmp = (mem_ind_op_b * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_b * mem_rw); tmp *= scaling_factor; std::get<37>(evals) += tmp; } @@ -445,7 +453,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(38); - auto tmp = (mem_ind_op_c * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_c * mem_rw); tmp *= scaling_factor; std::get<38>(evals) += tmp; } @@ -453,7 +461,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(39); - auto tmp = (mem_ind_op_d * mem_rw); + auto tmp = (mem_sel_resolve_ind_addr_d * mem_rw); tmp *= scaling_factor; std::get<39>(evals) += tmp; } @@ -461,7 +469,7 @@ template class memImpl { { Avm_DECLARE_VIEWS(40); - auto tmp = ((mem_sel_mov_a + mem_sel_mov_b) * mem_tag_err); + auto tmp = ((mem_sel_mov_ia_to_ic + mem_sel_mov_ib_to_ic) * mem_tag_err); tmp *= scaling_factor; std::get<40>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/pedersen.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/pedersen.hpp index e50a9f0a87f..d09722720e9 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/pedersen.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/pedersen.hpp @@ -7,7 +7,7 @@ namespace bb::Avm_vm { template struct PedersenRow { - FF pedersen_pedersen_sel{}; + FF pedersen_sel_pedersen{}; [[maybe_unused]] static std::vector names(); }; @@ -37,7 +37,7 @@ template class pedersenImpl { { Avm_DECLARE_VIEWS(0); - auto tmp = (pedersen_pedersen_sel * (-pedersen_pedersen_sel + FF(1))); + auto tmp = (pedersen_sel_pedersen * (-pedersen_sel_pedersen + FF(1))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_alu.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_alu.hpp index 56eea2340b2..1b1a70a81c5 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_alu.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_alu.hpp @@ -23,7 +23,7 @@ class perm_main_alu_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_alu_sel == 1 || in.alu_alu_sel == 1); + return (in.main_sel_alu == 1 || in.alu_sel_alu == 1); } /** @@ -47,9 +47,9 @@ class perm_main_alu_permutation_settings { { return std::forward_as_tuple(in.perm_main_alu, - in.main_alu_sel, - in.main_alu_sel, - in.alu_alu_sel, + in.main_sel_alu, + in.main_sel_alu, + in.alu_sel_alu, in.main_clk, in.main_ia, in.main_ib, @@ -105,9 +105,9 @@ class perm_main_alu_permutation_settings { { return std::forward_as_tuple(in.perm_main_alu, - in.main_alu_sel, - in.main_alu_sel, - in.alu_alu_sel, + in.main_sel_alu, + in.main_sel_alu, + in.alu_sel_alu, in.main_clk, in.main_ia, in.main_ib, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp index 55974efbadf..ebcd77a04ab 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp @@ -23,7 +23,7 @@ class perm_main_bin_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_bin_sel == 1 || in.binary_start == 1); + return (in.main_sel_bin == 1 || in.binary_start == 1); } /** @@ -47,8 +47,8 @@ class perm_main_bin_permutation_settings { { return std::forward_as_tuple(in.perm_main_bin, - in.main_bin_sel, - in.main_bin_sel, + in.main_sel_bin, + in.main_sel_bin, in.binary_start, in.main_clk, in.main_ia, @@ -85,8 +85,8 @@ class perm_main_bin_permutation_settings { { return std::forward_as_tuple(in.perm_main_bin, - in.main_bin_sel, - in.main_bin_sel, + in.main_sel_bin, + in.main_sel_bin, in.binary_start, in.main_clk, in.main_ia, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cmp.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cmp.hpp deleted file mode 100644 index 362f4321566..00000000000 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_cmp.hpp +++ /dev/null @@ -1,102 +0,0 @@ - - -#pragma once - -#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" - -#include -#include - -namespace bb { - -class perm_main_cmp_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.avm_main_cmp_sel == 1 || in.avm_alu_cmp_sel == 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_cmp, - in.avm_main_cmp_sel, - in.avm_main_cmp_sel, - in.avm_alu_cmp_sel, - in.avm_main_clk, - in.avm_main_ia, - in.avm_main_ib, - in.avm_main_ic, - in.avm_alu_clk, - in.avm_alu_ia, - in.avm_alu_ib, - in.avm_alu_ic); - } - - /** - * @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_cmp, - in.avm_main_cmp_sel, - in.avm_main_cmp_sel, - in.avm_alu_cmp_sel, - in.avm_main_clk, - in.avm_main_ia, - in.avm_main_ib, - in.avm_main_ic, - in.avm_alu_clk, - in.avm_alu_ia, - in.avm_alu_ib, - in.avm_alu_ic); - } -}; - -template -using perm_main_cmp_relation = GenericPermutationRelation; -template using perm_main_cmp = GenericPermutation; - -} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_conv.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_conv.hpp index fd66c691f4a..3890911bd5b 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_conv.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_conv.hpp @@ -23,7 +23,7 @@ class perm_main_conv_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_sel_op_radix_le == 1 || in.conversion_to_radix_le_sel == 1); + return (in.main_sel_op_radix_le == 1 || in.conversion_sel_to_radix_le == 1); } /** @@ -49,7 +49,7 @@ class perm_main_conv_permutation_settings { return std::forward_as_tuple(in.perm_main_conv, in.main_sel_op_radix_le, in.main_sel_op_radix_le, - in.conversion_to_radix_le_sel, + in.conversion_sel_to_radix_le, in.main_clk, in.main_ia, in.main_ic, @@ -83,7 +83,7 @@ class perm_main_conv_permutation_settings { return std::forward_as_tuple(in.perm_main_conv, in.main_sel_op_radix_le, in.main_sel_op_radix_le, - in.conversion_to_radix_le_sel, + in.conversion_sel_to_radix_le, in.main_clk, in.main_ia, in.main_ic, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_a.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_a.hpp index 5d5d3b423ec..867dd008f0a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_a.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_a.hpp @@ -23,7 +23,7 @@ class perm_main_mem_a_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_mem_op_a == 1 || in.mem_op_a == 1); + return (in.main_sel_mem_op_a == 1 || in.mem_sel_op_a == 1); } /** @@ -47,18 +47,18 @@ class perm_main_mem_a_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_a, - in.main_mem_op_a, - in.main_mem_op_a, - in.mem_op_a, + in.main_sel_mem_op_a, + in.main_sel_mem_op_a, + in.mem_sel_op_a, in.main_clk, in.main_space_id, - in.main_mem_idx_a, + in.main_mem_addr_a, in.main_ia, in.main_rwa, in.main_r_in_tag, in.main_w_in_tag, - in.main_sel_mov_a, - in.main_sel_cmov, + in.main_sel_mov_ia_to_ic, + in.main_sel_op_cmov, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -66,8 +66,8 @@ class perm_main_mem_a_permutation_settings { in.mem_rw, in.mem_r_in_tag, in.mem_w_in_tag, - in.mem_sel_mov_a, - in.mem_sel_cmov); + in.mem_sel_mov_ia_to_ic, + in.mem_sel_op_cmov); } /** @@ -91,18 +91,18 @@ class perm_main_mem_a_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_a, - in.main_mem_op_a, - in.main_mem_op_a, - in.mem_op_a, + in.main_sel_mem_op_a, + in.main_sel_mem_op_a, + in.mem_sel_op_a, in.main_clk, in.main_space_id, - in.main_mem_idx_a, + in.main_mem_addr_a, in.main_ia, in.main_rwa, in.main_r_in_tag, in.main_w_in_tag, - in.main_sel_mov_a, - in.main_sel_cmov, + in.main_sel_mov_ia_to_ic, + in.main_sel_op_cmov, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -110,8 +110,8 @@ class perm_main_mem_a_permutation_settings { in.mem_rw, in.mem_r_in_tag, in.mem_w_in_tag, - in.mem_sel_mov_a, - in.mem_sel_cmov); + in.mem_sel_mov_ia_to_ic, + in.mem_sel_op_cmov); } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_b.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_b.hpp index da9f4ac02a9..c724cbebb28 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_b.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_b.hpp @@ -23,7 +23,7 @@ class perm_main_mem_b_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_mem_op_b == 1 || in.mem_op_b == 1); + return (in.main_sel_mem_op_b == 1 || in.mem_sel_op_b == 1); } /** @@ -47,18 +47,18 @@ class perm_main_mem_b_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_b, - in.main_mem_op_b, - in.main_mem_op_b, - in.mem_op_b, + in.main_sel_mem_op_b, + in.main_sel_mem_op_b, + in.mem_sel_op_b, in.main_clk, in.main_space_id, - in.main_mem_idx_b, + in.main_mem_addr_b, in.main_ib, in.main_rwb, in.main_r_in_tag, in.main_w_in_tag, - in.main_sel_mov_b, - in.main_sel_cmov, + in.main_sel_mov_ib_to_ic, + in.main_sel_op_cmov, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -66,8 +66,8 @@ class perm_main_mem_b_permutation_settings { in.mem_rw, in.mem_r_in_tag, in.mem_w_in_tag, - in.mem_sel_mov_b, - in.mem_sel_cmov); + in.mem_sel_mov_ib_to_ic, + in.mem_sel_op_cmov); } /** @@ -91,18 +91,18 @@ class perm_main_mem_b_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_b, - in.main_mem_op_b, - in.main_mem_op_b, - in.mem_op_b, + in.main_sel_mem_op_b, + in.main_sel_mem_op_b, + in.mem_sel_op_b, in.main_clk, in.main_space_id, - in.main_mem_idx_b, + in.main_mem_addr_b, in.main_ib, in.main_rwb, in.main_r_in_tag, in.main_w_in_tag, - in.main_sel_mov_b, - in.main_sel_cmov, + in.main_sel_mov_ib_to_ic, + in.main_sel_op_cmov, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -110,8 +110,8 @@ class perm_main_mem_b_permutation_settings { in.mem_rw, in.mem_r_in_tag, in.mem_w_in_tag, - in.mem_sel_mov_b, - in.mem_sel_cmov); + in.mem_sel_mov_ib_to_ic, + in.mem_sel_op_cmov); } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_c.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_c.hpp index 814dae9a4f2..532d2fbdd9e 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_c.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_c.hpp @@ -23,7 +23,7 @@ class perm_main_mem_c_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_mem_op_c == 1 || in.mem_op_c == 1); + return (in.main_sel_mem_op_c == 1 || in.mem_sel_op_c == 1); } /** @@ -47,12 +47,12 @@ class perm_main_mem_c_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_c, - in.main_mem_op_c, - in.main_mem_op_c, - in.mem_op_c, + in.main_sel_mem_op_c, + in.main_sel_mem_op_c, + in.mem_sel_op_c, in.main_clk, in.main_space_id, - in.main_mem_idx_c, + in.main_mem_addr_c, in.main_ic, in.main_rwc, in.main_r_in_tag, @@ -87,12 +87,12 @@ class perm_main_mem_c_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_c, - in.main_mem_op_c, - in.main_mem_op_c, - in.mem_op_c, + in.main_sel_mem_op_c, + in.main_sel_mem_op_c, + in.mem_sel_op_c, in.main_clk, in.main_space_id, - in.main_mem_idx_c, + in.main_mem_addr_c, in.main_ic, in.main_rwc, in.main_r_in_tag, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_d.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_d.hpp index 308d47089e9..3112f97cd87 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_d.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_d.hpp @@ -23,7 +23,7 @@ class perm_main_mem_d_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_mem_op_d == 1 || in.mem_op_d == 1); + return (in.main_sel_mem_op_d == 1 || in.mem_sel_op_d == 1); } /** @@ -47,17 +47,17 @@ class perm_main_mem_d_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_d, - in.main_mem_op_d, - in.main_mem_op_d, - in.mem_op_d, + in.main_sel_mem_op_d, + in.main_sel_mem_op_d, + in.mem_sel_op_d, in.main_clk, in.main_space_id, - in.main_mem_idx_d, + in.main_mem_addr_d, in.main_id, in.main_rwd, in.main_r_in_tag, in.main_w_in_tag, - in.main_sel_cmov, + in.main_sel_op_cmov, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -65,7 +65,7 @@ class perm_main_mem_d_permutation_settings { in.mem_rw, in.mem_r_in_tag, in.mem_w_in_tag, - in.mem_sel_cmov); + in.mem_sel_op_cmov); } /** @@ -89,17 +89,17 @@ class perm_main_mem_d_permutation_settings { { return std::forward_as_tuple(in.perm_main_mem_d, - in.main_mem_op_d, - in.main_mem_op_d, - in.mem_op_d, + in.main_sel_mem_op_d, + in.main_sel_mem_op_d, + in.mem_sel_op_d, in.main_clk, in.main_space_id, - in.main_mem_idx_d, + in.main_mem_addr_d, in.main_id, in.main_rwd, in.main_r_in_tag, in.main_w_in_tag, - in.main_sel_cmov, + in.main_sel_op_cmov, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -107,7 +107,7 @@ class perm_main_mem_d_permutation_settings { in.mem_rw, in.mem_r_in_tag, in.mem_w_in_tag, - in.mem_sel_cmov); + in.mem_sel_op_cmov); } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_d.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_a.hpp similarity index 75% rename from barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_d.hpp rename to barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_a.hpp index 75e73cf25fd..3d0de9cf392 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_d.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_a.hpp @@ -9,7 +9,7 @@ namespace bb { -class perm_main_mem_ind_d_permutation_settings { +class perm_main_mem_ind_addr_a_permutation_settings { public: // This constant defines how many columns are bundled together to form each set. constexpr static size_t COLUMNS_PER_SET = 4; @@ -23,7 +23,7 @@ class perm_main_mem_ind_d_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_ind_op_d == 1 || in.mem_ind_op_d == 1); + return (in.main_sel_resolve_ind_addr_a == 1 || in.mem_sel_resolve_ind_addr_a == 1); } /** @@ -46,14 +46,14 @@ class perm_main_mem_ind_d_permutation_settings { template static inline auto get_const_entities(const AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_d, - in.main_ind_op_d, - in.main_ind_op_d, - in.mem_ind_op_d, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_a, + in.main_sel_resolve_ind_addr_a, + in.main_sel_resolve_ind_addr_a, + in.mem_sel_resolve_ind_addr_a, in.main_clk, in.main_space_id, - in.main_ind_d, - in.main_mem_idx_d, + in.main_ind_addr_a, + in.main_mem_addr_a, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -80,14 +80,14 @@ class perm_main_mem_ind_d_permutation_settings { template static inline auto get_nonconst_entities(AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_d, - in.main_ind_op_d, - in.main_ind_op_d, - in.mem_ind_op_d, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_a, + in.main_sel_resolve_ind_addr_a, + in.main_sel_resolve_ind_addr_a, + in.mem_sel_resolve_ind_addr_a, in.main_clk, in.main_space_id, - in.main_ind_d, - in.main_mem_idx_d, + in.main_ind_addr_a, + in.main_mem_addr_a, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -96,7 +96,9 @@ class perm_main_mem_ind_d_permutation_settings { }; template -using perm_main_mem_ind_d_relation = GenericPermutationRelation; -template using perm_main_mem_ind_d = GenericPermutation; +using perm_main_mem_ind_addr_a_relation = + GenericPermutationRelation; +template +using perm_main_mem_ind_addr_a = GenericPermutation; } // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_a.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_b.hpp similarity index 75% rename from barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_a.hpp rename to barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_b.hpp index 9b6a52ff11f..eec199f39f7 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_a.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_b.hpp @@ -9,7 +9,7 @@ namespace bb { -class perm_main_mem_ind_a_permutation_settings { +class perm_main_mem_ind_addr_b_permutation_settings { public: // This constant defines how many columns are bundled together to form each set. constexpr static size_t COLUMNS_PER_SET = 4; @@ -23,7 +23,7 @@ class perm_main_mem_ind_a_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_ind_op_a == 1 || in.mem_ind_op_a == 1); + return (in.main_sel_resolve_ind_addr_b == 1 || in.mem_sel_resolve_ind_addr_b == 1); } /** @@ -46,14 +46,14 @@ class perm_main_mem_ind_a_permutation_settings { template static inline auto get_const_entities(const AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_a, - in.main_ind_op_a, - in.main_ind_op_a, - in.mem_ind_op_a, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_b, + in.main_sel_resolve_ind_addr_b, + in.main_sel_resolve_ind_addr_b, + in.mem_sel_resolve_ind_addr_b, in.main_clk, in.main_space_id, - in.main_ind_a, - in.main_mem_idx_a, + in.main_ind_addr_b, + in.main_mem_addr_b, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -80,14 +80,14 @@ class perm_main_mem_ind_a_permutation_settings { template static inline auto get_nonconst_entities(AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_a, - in.main_ind_op_a, - in.main_ind_op_a, - in.mem_ind_op_a, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_b, + in.main_sel_resolve_ind_addr_b, + in.main_sel_resolve_ind_addr_b, + in.mem_sel_resolve_ind_addr_b, in.main_clk, in.main_space_id, - in.main_ind_a, - in.main_mem_idx_a, + in.main_ind_addr_b, + in.main_mem_addr_b, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -96,7 +96,9 @@ class perm_main_mem_ind_a_permutation_settings { }; template -using perm_main_mem_ind_a_relation = GenericPermutationRelation; -template using perm_main_mem_ind_a = GenericPermutation; +using perm_main_mem_ind_addr_b_relation = + GenericPermutationRelation; +template +using perm_main_mem_ind_addr_b = GenericPermutation; } // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_b.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_c.hpp similarity index 75% rename from barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_b.hpp rename to barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_c.hpp index 72ab0700455..7367fc905f8 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_b.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_c.hpp @@ -9,7 +9,7 @@ namespace bb { -class perm_main_mem_ind_b_permutation_settings { +class perm_main_mem_ind_addr_c_permutation_settings { public: // This constant defines how many columns are bundled together to form each set. constexpr static size_t COLUMNS_PER_SET = 4; @@ -23,7 +23,7 @@ class perm_main_mem_ind_b_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_ind_op_b == 1 || in.mem_ind_op_b == 1); + return (in.main_sel_resolve_ind_addr_c == 1 || in.mem_sel_resolve_ind_addr_c == 1); } /** @@ -46,14 +46,14 @@ class perm_main_mem_ind_b_permutation_settings { template static inline auto get_const_entities(const AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_b, - in.main_ind_op_b, - in.main_ind_op_b, - in.mem_ind_op_b, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_c, + in.main_sel_resolve_ind_addr_c, + in.main_sel_resolve_ind_addr_c, + in.mem_sel_resolve_ind_addr_c, in.main_clk, in.main_space_id, - in.main_ind_b, - in.main_mem_idx_b, + in.main_ind_addr_c, + in.main_mem_addr_c, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -80,14 +80,14 @@ class perm_main_mem_ind_b_permutation_settings { template static inline auto get_nonconst_entities(AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_b, - in.main_ind_op_b, - in.main_ind_op_b, - in.mem_ind_op_b, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_c, + in.main_sel_resolve_ind_addr_c, + in.main_sel_resolve_ind_addr_c, + in.mem_sel_resolve_ind_addr_c, in.main_clk, in.main_space_id, - in.main_ind_b, - in.main_mem_idx_b, + in.main_ind_addr_c, + in.main_mem_addr_c, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -96,7 +96,9 @@ class perm_main_mem_ind_b_permutation_settings { }; template -using perm_main_mem_ind_b_relation = GenericPermutationRelation; -template using perm_main_mem_ind_b = GenericPermutation; +using perm_main_mem_ind_addr_c_relation = + GenericPermutationRelation; +template +using perm_main_mem_ind_addr_c = GenericPermutation; } // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_c.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_d.hpp similarity index 75% rename from barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_c.hpp rename to barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_d.hpp index b9ecdd5c592..6515b55c4bd 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_c.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_mem_ind_addr_d.hpp @@ -9,7 +9,7 @@ namespace bb { -class perm_main_mem_ind_c_permutation_settings { +class perm_main_mem_ind_addr_d_permutation_settings { public: // This constant defines how many columns are bundled together to form each set. constexpr static size_t COLUMNS_PER_SET = 4; @@ -23,7 +23,7 @@ class perm_main_mem_ind_c_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_ind_op_c == 1 || in.mem_ind_op_c == 1); + return (in.main_sel_resolve_ind_addr_d == 1 || in.mem_sel_resolve_ind_addr_d == 1); } /** @@ -46,14 +46,14 @@ class perm_main_mem_ind_c_permutation_settings { template static inline auto get_const_entities(const AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_c, - in.main_ind_op_c, - in.main_ind_op_c, - in.mem_ind_op_c, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_d, + in.main_sel_resolve_ind_addr_d, + in.main_sel_resolve_ind_addr_d, + in.mem_sel_resolve_ind_addr_d, in.main_clk, in.main_space_id, - in.main_ind_c, - in.main_mem_idx_c, + in.main_ind_addr_d, + in.main_mem_addr_d, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -80,14 +80,14 @@ class perm_main_mem_ind_c_permutation_settings { template static inline auto get_nonconst_entities(AllEntities& in) { - return std::forward_as_tuple(in.perm_main_mem_ind_c, - in.main_ind_op_c, - in.main_ind_op_c, - in.mem_ind_op_c, + return std::forward_as_tuple(in.perm_main_mem_ind_addr_d, + in.main_sel_resolve_ind_addr_d, + in.main_sel_resolve_ind_addr_d, + in.mem_sel_resolve_ind_addr_d, in.main_clk, in.main_space_id, - in.main_ind_c, - in.main_mem_idx_c, + in.main_ind_addr_d, + in.main_mem_addr_d, in.mem_clk, in.mem_space_id, in.mem_addr, @@ -96,7 +96,9 @@ class perm_main_mem_ind_c_permutation_settings { }; template -using perm_main_mem_ind_c_relation = GenericPermutationRelation; -template using perm_main_mem_ind_c = GenericPermutation; +using perm_main_mem_ind_addr_d_relation = + GenericPermutationRelation; +template +using perm_main_mem_ind_addr_d = GenericPermutation; } // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pedersen.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pedersen.hpp index 0370064020b..f59fdd920fa 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pedersen.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pedersen.hpp @@ -23,7 +23,7 @@ class perm_main_pedersen_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_sel_op_pedersen == 1 || in.pedersen_pedersen_sel == 1); + return (in.main_sel_op_pedersen == 1 || in.pedersen_sel_pedersen == 1); } /** @@ -49,7 +49,7 @@ class perm_main_pedersen_permutation_settings { return std::forward_as_tuple(in.perm_main_pedersen, in.main_sel_op_pedersen, in.main_sel_op_pedersen, - in.pedersen_pedersen_sel, + in.pedersen_sel_pedersen, in.main_clk, in.main_ia, in.pedersen_clk, @@ -79,7 +79,7 @@ class perm_main_pedersen_permutation_settings { return std::forward_as_tuple(in.perm_main_pedersen, in.main_sel_op_pedersen, in.main_sel_op_pedersen, - in.pedersen_pedersen_sel, + in.pedersen_sel_pedersen, in.main_clk, in.main_ia, in.pedersen_clk, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pos2_perm.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pos2_perm.hpp index 3ff0cf467e2..dab9abe744f 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pos2_perm.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_pos2_perm.hpp @@ -23,7 +23,7 @@ class perm_main_pos2_perm_permutation_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_sel_op_poseidon2 == 1 || in.poseidon2_poseidon_perm_sel == 1); + return (in.main_sel_op_poseidon2 == 1 || in.poseidon2_sel_poseidon_perm == 1); } /** @@ -49,7 +49,7 @@ class perm_main_pos2_perm_permutation_settings { return std::forward_as_tuple(in.perm_main_pos2_perm, in.main_sel_op_poseidon2, in.main_sel_op_poseidon2, - in.poseidon2_poseidon_perm_sel, + in.poseidon2_sel_poseidon_perm, in.main_clk, in.main_ia, in.main_ib, @@ -81,7 +81,7 @@ class perm_main_pos2_perm_permutation_settings { return std::forward_as_tuple(in.perm_main_pos2_perm, in.main_sel_op_poseidon2, in.main_sel_op_poseidon2, - in.poseidon2_poseidon_perm_sel, + in.poseidon2_sel_poseidon_perm, in.main_clk, in.main_ia, in.main_ib, diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_sha256.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_sha256.hpp deleted file mode 100644 index d7943e2d5a3..00000000000 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_sha256.hpp +++ /dev/null @@ -1,102 +0,0 @@ - - -#pragma once - -#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" - -#include -#include - -namespace bb { - -class perm_main_sha256_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.avm_main_sel_op_sha256 == 1 || in.avm_sha256_sha256_compression_sel == 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_sha256, - in.avm_main_sel_op_sha256, - in.avm_main_sel_op_sha256, - in.avm_sha256_sha256_compression_sel, - in.avm_main_clk, - in.avm_main_ia, - in.avm_main_ib, - in.avm_main_ic, - in.avm_sha256_clk, - in.avm_sha256_state, - in.avm_sha256_input, - in.avm_sha256_output); - } - - /** - * @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_sha256, - in.avm_main_sel_op_sha256, - in.avm_main_sel_op_sha256, - in.avm_sha256_sha256_compression_sel, - in.avm_main_clk, - in.avm_main_ia, - in.avm_main_ib, - in.avm_main_ic, - in.avm_sha256_clk, - in.avm_sha256_state, - in.avm_sha256_input, - in.avm_sha256_output); - } -}; - -template -using perm_main_sha256_relation = GenericPermutationRelation; -template using perm_main_sha256 = GenericPermutation; - -} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/poseidon2.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/poseidon2.hpp index 53acb113223..a758f8333b2 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/poseidon2.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/poseidon2.hpp @@ -7,7 +7,7 @@ namespace bb::Avm_vm { template struct Poseidon2Row { - FF poseidon2_poseidon_perm_sel{}; + FF poseidon2_sel_poseidon_perm{}; [[maybe_unused]] static std::vector names(); }; @@ -37,7 +37,7 @@ template class poseidon2Impl { { Avm_DECLARE_VIEWS(0); - auto tmp = (poseidon2_poseidon_perm_sel * (-poseidon2_poseidon_perm_sel + FF(1))); + auto tmp = (poseidon2_sel_poseidon_perm * (-poseidon2_sel_poseidon_perm + FF(1))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/pow_2_lookups.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/pow_2_lookups.hpp deleted file mode 100644 index b66844e7d06..00000000000 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/pow_2_lookups.hpp +++ /dev/null @@ -1,170 +0,0 @@ - - -#pragma once - -#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" - -#include -#include - -namespace bb { - -/** - * @brief This class contains an example of how to set LookupSettings classes used by the - * GenericLookupRelationImpl class to specify a scaled lookup - * - * @details To create your own lookup: - * 1) Create a copy of this class and rename it - * 2) Update all the values with the ones needed for your lookup - * 3) Update "DECLARE_LOOKUP_IMPLEMENTATIONS_FOR_ALL_SETTINGS" and "DEFINE_LOOKUP_IMPLEMENTATIONS_FOR_ALL_SETTINGS" to - * include the new settings - * 4) Add the relation with the chosen settings to Relations in the flavor (for example,"` - * using Relations = std::tuple>;)` - * - */ -class pow_2_lookups_lookup_settings { - public: - /** - * @brief The number of read terms (how many lookups we perform) in each row - * - */ - static constexpr size_t READ_TERMS = 1; - /** - * @brief The number of write terms (how many additions to the lookup table we make) in each row - * - */ - static constexpr size_t WRITE_TERMS = 1; - - /** - * @brief The type of READ_TERM used for each read index (basic and scaled) - * - */ - static constexpr size_t READ_TERM_TYPES[READ_TERMS] = { 0 }; - - /** - * @brief They type of WRITE_TERM used for each write index - * - */ - static constexpr size_t WRITE_TERM_TYPES[WRITE_TERMS] = { 0 }; - - /** - * @brief How many values represent a single lookup object. This value is used by the automatic read term - * implementation in the relation in case the lookup is a basic or scaled tuple and in the write term if it's a - * basic tuple - * - */ - static constexpr size_t LOOKUP_TUPLE_SIZE = 2; - - /** - * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed - * - */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; - - /** - * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read - * terms, but will cause compilation error if not defined - * - */ - static constexpr size_t READ_TERM_DEGREE = 0; - - /** - * @brief The degree of the write term if implemented arbitrarily. This value is not used by the basic write - * term, but will cause compilation error if not defined - * - */ - - static constexpr size_t WRITE_TERM_DEGREE = 0; - - /** - * @brief If this method returns true on a row of values, then the inverse polynomial exists at this index. - * Otherwise the value needs to be set to zero. - * - * @details If this is true then the lookup takes place in this row - * - */ - - template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) - { - return (in.avm_alu_pow_2_sel == 1 || in.avm_main_sel_rng_8 == 1); - } - - /** - * @brief Subprocedure for computing the value deciding if the inverse polynomial value needs to be checked in this - * row - * - * @tparam Accumulator Type specified by the lookup relation - * @tparam AllEntities Values/Univariates of all entities row - * @param in Value/Univariate of all entities at row/edge - * @return Accumulator - */ - - template - static inline auto compute_inverse_exists(const AllEntities& in) - { - using View = typename Accumulator::View; - const auto is_operation = View(in.avm_alu_pow_2_sel); - const auto is_table_entry = View(in.avm_main_sel_rng_8); - return (is_operation + is_table_entry - is_operation * is_table_entry); - } - - /** - * @brief Get all the entities for the lookup when need to update them - * - * @details The generic structure of this tuple is described in ./generic_lookup_relation.hpp . The following is - description for the current case: - The entities are returned as a tuple of references in the following order (this is for ): - * - The entity/polynomial used to store the product of the inverse values - * - The entity/polynomial that specifies how many times the lookup table entry at this row has been looked up - * - READ_TERMS entities/polynomials that enable individual lookup operations - * - The entity/polynomial that enables adding an entry to the lookup table in this row - * - LOOKUP_TUPLE_SIZE entities/polynomials representing the basic tuple being looked up as the first read term - * - LOOKUP_TUPLE_SIZE entities/polynomials representing the previous accumulators in the second read term - (scaled tuple) - * - LOOKUP_TUPLE_SIZE entities/polynomials representing the shifts in the second read term (scaled tuple) - * - LOOKUP_TUPLE_SIZE entities/polynomials representing the current accumulators in the second read term - (scaled tuple) - * - LOOKUP_TUPLE_SIZE entities/polynomials representing basic tuples added to the table - * - * @return All the entities needed for the lookup - */ - - template static inline auto get_const_entities(const AllEntities& in) - { - - return std::forward_as_tuple(in.pow_2_lookups, - in.pow_2_lookups_counts, - in.avm_alu_pow_2_sel, - in.avm_main_sel_rng_8, - in.avm_alu_ib, - in.avm_alu_two_pow_b, - in.avm_main_clk, - in.avm_main_table_pow_2); - } - - /** - * @brief Get all the entities for the lookup when we only need to read them - * @details Same as in get_const_entities, but nonconst - * - * @return All the entities needed for the lookup - */ - - template static inline auto get_nonconst_entities(AllEntities& in) - { - - return std::forward_as_tuple(in.pow_2_lookups, - in.pow_2_lookups_counts, - in.avm_alu_pow_2_sel, - in.avm_main_sel_rng_8, - in.avm_alu_ib, - in.avm_alu_two_pow_b, - in.avm_main_clk, - in.avm_main_table_pow_2); - } -}; - -template using pow_2_lookups_relation = GenericLookupRelation; -template using pow_2_lookups = GenericLookup; - -} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_hi.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_hi.hpp index 8b888f37c33..b3c732c4e59 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_hi.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_hi.hpp @@ -87,7 +87,7 @@ class range_check_da_gas_hi_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_gas_cost_active == 1 || in.main_sel_rng_16 == 1); + return (in.main_sel_gas_accounting_active == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class range_check_da_gas_hi_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.main_gas_cost_active); + const auto is_operation = View(in.main_sel_gas_accounting_active); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class range_check_da_gas_hi_lookup_settings { return std::forward_as_tuple(in.range_check_da_gas_hi, in.range_check_da_gas_hi_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_da_rem_gas_hi, in.main_clk); @@ -153,7 +153,7 @@ class range_check_da_gas_hi_lookup_settings { return std::forward_as_tuple(in.range_check_da_gas_hi, in.range_check_da_gas_hi_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_da_rem_gas_hi, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_lo.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_lo.hpp index 6629b297c6b..0167a2e4ee3 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_lo.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_da_gas_lo.hpp @@ -87,7 +87,7 @@ class range_check_da_gas_lo_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_gas_cost_active == 1 || in.main_sel_rng_16 == 1); + return (in.main_sel_gas_accounting_active == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class range_check_da_gas_lo_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.main_gas_cost_active); + const auto is_operation = View(in.main_sel_gas_accounting_active); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class range_check_da_gas_lo_lookup_settings { return std::forward_as_tuple(in.range_check_da_gas_lo, in.range_check_da_gas_lo_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_da_rem_gas_lo, in.main_clk); @@ -153,7 +153,7 @@ class range_check_da_gas_lo_lookup_settings { return std::forward_as_tuple(in.range_check_da_gas_lo, in.range_check_da_gas_lo_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_da_rem_gas_lo, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_hi.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_hi.hpp index 6bc44b44371..81a3f1e0b97 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_hi.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_hi.hpp @@ -87,7 +87,7 @@ class range_check_l2_gas_hi_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_gas_cost_active == 1 || in.main_sel_rng_16 == 1); + return (in.main_sel_gas_accounting_active == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class range_check_l2_gas_hi_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.main_gas_cost_active); + const auto is_operation = View(in.main_sel_gas_accounting_active); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class range_check_l2_gas_hi_lookup_settings { return std::forward_as_tuple(in.range_check_l2_gas_hi, in.range_check_l2_gas_hi_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_l2_rem_gas_hi, in.main_clk); @@ -153,7 +153,7 @@ class range_check_l2_gas_hi_lookup_settings { return std::forward_as_tuple(in.range_check_l2_gas_hi, in.range_check_l2_gas_hi_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_l2_rem_gas_hi, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_lo.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_lo.hpp index 79eb843b6b4..ca2165657a2 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_lo.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/range_check_l2_gas_lo.hpp @@ -87,7 +87,7 @@ class range_check_l2_gas_lo_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.main_gas_cost_active == 1 || in.main_sel_rng_16 == 1); + return (in.main_sel_gas_accounting_active == 1 || in.main_sel_rng_16 == 1); } /** @@ -104,7 +104,7 @@ class range_check_l2_gas_lo_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.main_gas_cost_active); + const auto is_operation = View(in.main_sel_gas_accounting_active); const auto is_table_entry = View(in.main_sel_rng_16); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,7 +135,7 @@ class range_check_l2_gas_lo_lookup_settings { return std::forward_as_tuple(in.range_check_l2_gas_lo, in.range_check_l2_gas_lo_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_l2_rem_gas_lo, in.main_clk); @@ -153,7 +153,7 @@ class range_check_l2_gas_lo_lookup_settings { return std::forward_as_tuple(in.range_check_l2_gas_lo, in.range_check_l2_gas_lo_counts, - in.main_gas_cost_active, + in.main_sel_gas_accounting_active, in.main_sel_rng_16, in.main_abs_l2_rem_gas_lo, in.main_clk); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/sha256.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/sha256.hpp index 63a81bceb92..189cbb7c699 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/sha256.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/sha256.hpp @@ -7,7 +7,7 @@ namespace bb::Avm_vm { template struct Sha256Row { - FF sha256_sha256_compression_sel{}; + FF sha256_sel_sha256_compression{}; [[maybe_unused]] static std::vector names(); }; @@ -37,7 +37,7 @@ template class sha256Impl { { Avm_DECLARE_VIEWS(0); - auto tmp = (sha256_sha256_compression_sel * (-sha256_sha256_compression_sel + FF(1))); + auto tmp = (sha256_sel_sha256_compression * (-sha256_sel_sha256_compression + FF(1))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.cpp index 36fcd78744d..5a81dc569c3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.cpp @@ -2,15 +2,6 @@ namespace bb::avm_trace { -/** - * @brief Constructor of Alu trace builder of AVM. Only serves to set the capacity of the - * underlying trace. - */ -AvmAluTraceBuilder::AvmAluTraceBuilder() -{ - alu_trace.reserve(AVM_TRACE_SIZE); -} - /** * @brief Resetting the internal state so that a new Alu trace can be rebuilt using the same object. * diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.hpp index a5445e1861c..fdd751b0cf8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_alu_trace.hpp @@ -81,7 +81,7 @@ class AvmAluTraceBuilder { std::array, 15> u16_range_chk_counters; std::array, 8> div_u64_range_chk_counters; - AvmAluTraceBuilder(); + AvmAluTraceBuilder() = default; void reset(); std::vector finalize(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.cpp index 15384be9804..c87b4924fd3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.cpp @@ -10,11 +10,6 @@ namespace bb::avm_trace { -AvmBinaryTraceBuilder::AvmBinaryTraceBuilder() -{ - binary_trace.reserve(AVM_TRACE_SIZE); -} - std::vector AvmBinaryTraceBuilder::finalize() { return std::move(binary_trace); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.hpp index 29a88f5f9d5..9aa6cab9220 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_binary_trace.hpp @@ -31,7 +31,7 @@ class AvmBinaryTraceBuilder { std::unordered_map byte_operation_counter; std::unordered_map byte_length_counter; - AvmBinaryTraceBuilder(); + AvmBinaryTraceBuilder() = default; void reset(); // Finalize the trace std::vector finalize(); 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 305e0d0d15f..4c8bb0f9872 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 @@ -3,8 +3,6 @@ namespace bb::avm_trace { -AvmGasTraceBuilder::AvmGasTraceBuilder() = default; - void AvmGasTraceBuilder::reset() { gas_trace.clear(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.hpp index 9934164ad23..8085321586b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_gas_trace.hpp @@ -109,6 +109,7 @@ static const inline std::unordered_map GAS_COST_TABLE = { // Sentinel // LAST_OPCODE_SENTINEL, }; + class AvmGasTraceBuilder { public: struct GasTraceEntry { @@ -124,8 +125,7 @@ class AvmGasTraceBuilder { // opcode -> count std::unordered_map gas_opcode_lookup_counter; - // Constructor receives copy of kernel_inputs from the main trace builder - AvmGasTraceBuilder(); + AvmGasTraceBuilder() = default; void reset(); std::vector finalize(); 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 21f9a569172..8a508442aa5 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_helper.cpp @@ -14,99 +14,102 @@ namespace bb::avm_trace { * @param beg The index of the beginning of the slice. (included) * @param end The index of the end of the slice (not included). */ -void log_avm_trace(std::vector const& trace, size_t beg, size_t end, bool enable_selectors) +void log_avm_trace([[maybe_unused]] std::vector const& trace, + [[maybe_unused]] size_t beg, + [[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++) { - info("====================================================================================="); - info("== ROW ", i); - info("====================================================================================="); - - info("=======MEMORY TRACE=================================================================="); - info("m_addr: ", trace.at(i).mem_addr); - info("m_clk: ", trace.at(i).mem_clk); - info("m_tsp: ", trace.at(i).mem_tsp); - info("m_sub_clk: ", uint32_t(trace.at(i).mem_tsp) % AvmMemTraceBuilder::NUM_SUB_CLK); - info("m_val: ", trace.at(i).mem_val); - info("m_rw: ", trace.at(i).mem_rw); - info("m_tag: ", trace.at(i).mem_tag); - info("r_in_tag: ", trace.at(i).mem_r_in_tag); - info("w_in_tag: ", trace.at(i).mem_w_in_tag); - info("m_tag_err: ", trace.at(i).mem_tag_err); - info("m_one_min_inv: ", trace.at(i).mem_one_min_inv); - - 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); - info("internal_call: ", trace.at(i).main_sel_internal_call); - info("internal_return: ", trace.at(i).main_sel_internal_return); - info("internal_return_ptr:", trace.at(i).main_internal_return_ptr); - - info("=======ALU TRACE====================================================================="); - info("alu_clk ", trace.at(i).alu_clk); - info("alu_ia ", trace.at(i).alu_ia); - info("alu_ib ", trace.at(i).alu_ib); - info("alu_ic ", trace.at(i).alu_ic); - - info("=======MAIN TRACE===================================================================="); - info("clk: ", trace.at(i).main_clk); - info("ia: ", trace.at(i).main_ia); - info("ib: ", trace.at(i).main_ib); - info("ic: ", trace.at(i).main_ic); - info("r_in_tag ", trace.at(i).main_r_in_tag); - info("w_in_tag ", trace.at(i).main_w_in_tag); - info("tag_err ", trace.at(i).main_tag_err); - info("first: ", trace.at(i).main_first); - info("last: ", trace.at(i).main_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("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("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("rwc: ", trace.at(i).main_rwc); - 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("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_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); - info("abs_l2_lo_rem_gas: ", trace.at(i).main_abs_l2_rem_gas_lo); - info("abs_da_hi_rem_gas: ", trace.at(i).main_abs_da_rem_gas_hi); - info("abs_da_lo_rem_gas: ", trace.at(i).main_abs_da_rem_gas_lo); - - if (enable_selectors) { - info("=======SELECTORS======================================================================"); - info("sel_op_add: ", trace.at(i).main_sel_op_add); - info("sel_op_sub: ", trace.at(i).main_sel_op_sub); - 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("\n"); + /* + info("Built circuit with ", trace.size(), " rows"); + + for (size_t i = beg; i < end; i++) { + info("====================================================================================="); + info("== ROW ", i); + info("====================================================================================="); + + info("=======MEMORY TRACE=================================================================="); + info("m_addr: ", trace.at(i).mem_addr); + info("m_clk: ", trace.at(i).mem_clk); + info("m_tsp: ", trace.at(i).mem_tsp); + info("m_sub_clk: ", uint32_t(trace.at(i).mem_tsp) % AvmMemTraceBuilder::NUM_SUB_CLK); + info("m_val: ", trace.at(i).mem_val); + info("m_rw: ", trace.at(i).mem_rw); + info("m_tag: ", trace.at(i).mem_tag); + info("r_in_tag: ", trace.at(i).mem_r_in_tag); + info("w_in_tag: ", trace.at(i).mem_w_in_tag); + info("m_tag_err: ", trace.at(i).mem_tag_err); + info("m_one_min_inv: ", trace.at(i).mem_one_min_inv); + + 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); + info("internal_call: ", trace.at(i).main_sel_op_internal_call); + info("internal_return: ", trace.at(i).main_sel_op_internal_return); + info("internal_return_ptr:", trace.at(i).main_internal_return_ptr); + + info("=======ALU TRACE====================================================================="); + info("alu_clk ", trace.at(i).alu_clk); + info("alu_ia ", trace.at(i).alu_ia); + info("alu_ib ", trace.at(i).alu_ib); + info("alu_ic ", trace.at(i).alu_ic); + + info("=======MAIN TRACE===================================================================="); + info("clk: ", trace.at(i).main_clk); + info("ia: ", trace.at(i).main_ia); + info("ib: ", trace.at(i).main_ib); + info("ic: ", trace.at(i).main_ic); + info("r_in_tag ", trace.at(i).main_r_in_tag); + info("w_in_tag ", trace.at(i).main_w_in_tag); + info("tag_err ", trace.at(i).main_tag_err); + info("first: ", trace.at(i).main_sel_first); + 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("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("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("rwc: ", trace.at(i).main_rwc); + 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("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_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); + info("abs_l2_lo_rem_gas: ", trace.at(i).main_abs_l2_rem_gas_lo); + info("abs_da_hi_rem_gas: ", trace.at(i).main_abs_da_rem_gas_hi); + info("abs_da_lo_rem_gas: ", trace.at(i).main_abs_da_rem_gas_lo); + + if (enable_selectors) { + info("=======SELECTORS======================================================================"); + info("sel_op_add: ", trace.at(i).main_sel_op_add); + info("sel_op_sub: ", trace.at(i).main_sel_op_sub); + 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("\n"); } + */ } void dump_trace_as_csv(std::vector const& trace, std::filesystem::path const& filename) 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 d3c38f0665d..8ee4f02595f 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 @@ -228,7 +228,7 @@ AvmMemTraceBuilder::MemEntry AvmMemTraceBuilder::read_and_load_mov_opcode(uint8_ .m_tag = mem_entry.tag, .r_in_tag = mem_entry.tag, .w_in_tag = mem_entry.tag, - .m_sel_mov_a = true, + .m_sel_mov_ia_to_ic = true, }); return mem_entry; @@ -271,7 +271,7 @@ std::array AvmMemTraceBuilder::read_and_load_cm .m_tag = a_mem_entry.tag, .r_in_tag = r_w_in_tag, .w_in_tag = r_w_in_tag, - .m_sel_mov_a = !mov_b, + .m_sel_mov_ia_to_ic = !mov_b, .m_sel_cmov = true, }); @@ -284,7 +284,7 @@ std::array AvmMemTraceBuilder::read_and_load_cm .m_tag = b_mem_entry.tag, .r_in_tag = r_w_in_tag, .w_in_tag = r_w_in_tag, - .m_sel_mov_b = mov_b, + .m_sel_mov_ib_to_ic = mov_b, .m_sel_cmov = true, }); @@ -483,4 +483,35 @@ void AvmMemTraceBuilder::write_into_memory(uint8_t space_id, store_in_mem_trace(space_id, clk, interm_reg, addr, val, r_in_tag, w_in_tag); } +bool AvmMemTraceBuilder::MemoryTraceEntry::operator<(const AvmMemTraceBuilder::MemoryTraceEntry& other) const +{ + if (m_space_id < other.m_space_id) { + return true; + } + + if (m_space_id > other.m_space_id) { + return false; + } + + if (m_addr < other.m_addr) { + return true; + } + + if (m_addr > other.m_addr) { + return false; + } + + if (m_clk < other.m_clk) { + return true; + } + + if (m_clk > other.m_clk) { + return false; + } + + // No safeguard in case they are equal. The caller should ensure this property. + // Otherwise, relation will not be satisfied. + return m_sub_clk < other.m_sub_clk; +} + } // 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 4efaf4f58fc..bd8e4b121e9 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 @@ -28,19 +28,19 @@ class AvmMemTraceBuilder { std::map m_tag_err_lookup_counts; struct MemoryTraceEntry { - uint8_t m_space_id{}; - uint32_t m_clk{}; - uint32_t m_sub_clk{}; - uint32_t m_addr{}; + uint8_t m_space_id = 0; + uint32_t m_clk = 0; + uint32_t m_sub_clk = 0; + uint32_t m_addr = 0; FF m_val{}; - AvmMemoryTag m_tag{}; - AvmMemoryTag r_in_tag{}; - AvmMemoryTag w_in_tag{}; + AvmMemoryTag m_tag; + AvmMemoryTag r_in_tag; + AvmMemoryTag w_in_tag; bool m_rw = false; bool m_tag_err = false; FF m_one_min_inv{}; - bool m_sel_mov_a = false; - bool m_sel_mov_b = false; + bool m_sel_mov_ia_to_ic = false; + bool m_sel_mov_ib_to_ic = false; bool m_sel_cmov = false; bool m_tag_err_count_relevant = false; @@ -48,36 +48,7 @@ class AvmMemTraceBuilder { * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. We sort first by * ascending address (m_addr), then by clock (m_clk) and finally sub-clock (m_sub_clk). */ - bool operator<(const MemoryTraceEntry& other) const - { - if (m_space_id < other.m_space_id) { - return true; - } - - if (m_space_id > other.m_space_id) { - return false; - } - - if (m_addr < other.m_addr) { - return true; - } - - if (m_addr > other.m_addr) { - return false; - } - - if (m_clk < other.m_clk) { - return true; - } - - if (m_clk > other.m_clk) { - return false; - } - - // No safeguard in case they are equal. The caller should ensure this property. - // Otherwise, relation will not be satisfied. - return m_sub_clk < other.m_sub_clk; - } + bool operator<(MemoryTraceEntry const& other) const; }; // Structure representing an entry for the memory used in the simulation (not the 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 07a218358c5..c97c71eccb2 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -158,23 +158,23 @@ void AvmTraceBuilder::op_add( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_add = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -226,23 +226,23 @@ void AvmTraceBuilder::op_sub( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_sub = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -294,23 +294,23 @@ void AvmTraceBuilder::op_mul( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_mul = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -370,25 +370,25 @@ void AvmTraceBuilder::op_fdiv(uint8_t indirect, uint32_t a_offset, uint32_t b_of .main_ia = tag_match ? a : FF(0), .main_ib = tag_match ? b : FF(0), .main_ic = tag_match ? c : FF(0), - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), .main_inv = tag_match ? inv : FF(1), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_op_err = tag_match ? error : FF(1), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_fdiv = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), }); @@ -450,19 +450,19 @@ void AvmTraceBuilder::op_not(uint8_t indirect, uint32_t a_offset, uint32_t dst_o .main_call_ptr = call_ptr, .main_ia = a, .main_ic = c, - .main_ind_a = indirect_a_flag ? FF(a_offset) : FF(0), - .main_ind_c = indirect_c_flag ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_a_flag)), - .main_ind_op_c = FF(static_cast(indirect_c_flag)), + .main_ind_addr_a = indirect_a_flag ? FF(a_offset) : FF(0), + .main_ind_addr_c = indirect_c_flag ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_a_offset), - .main_mem_idx_c = FF(direct_dst_offset), - .main_mem_op_a = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(direct_a_offset), + .main_mem_addr_c = FF(direct_dst_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_not = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_a_flag)), + .main_sel_resolve_ind_addr_c = FF(static_cast(indirect_c_flag)), .main_tag_err = FF(static_cast(!read_a.tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -514,23 +514,23 @@ void AvmTraceBuilder::op_eq( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_eq = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U8)), }); @@ -565,28 +565,28 @@ void AvmTraceBuilder::op_and( main_trace.push_back(Row{ .main_clk = clk, .main_bin_op_id = FF(0), - .main_bin_sel = FF(1), .main_call_ptr = call_ptr, .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_bin = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_and = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -621,28 +621,28 @@ void AvmTraceBuilder::op_or( main_trace.push_back(Row{ .main_clk = clk, .main_bin_op_id = FF(1), - .main_bin_sel = FF(1), .main_call_ptr = call_ptr, .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_bin = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_or = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -677,28 +677,28 @@ void AvmTraceBuilder::op_xor( main_trace.push_back(Row{ .main_clk = clk, .main_bin_op_id = FF(2), - .main_bin_sel = FF(1), .main_call_ptr = call_ptr, .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_bin = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_xor = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -738,23 +738,23 @@ void AvmTraceBuilder::op_lt( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_lt = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U8)), }); @@ -794,23 +794,23 @@ void AvmTraceBuilder::op_lte( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_lte = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U8)), }); @@ -850,23 +850,23 @@ void AvmTraceBuilder::op_shr( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_shr = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -905,23 +905,23 @@ void AvmTraceBuilder::op_shl( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_shl = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -966,14 +966,14 @@ void AvmTraceBuilder::op_set(uint8_t indirect, uint128_t val, uint32_t dst_offse .main_clk = clk, .main_call_ptr = call_ptr, .main_ic = val_ff, - .main_ind_c = indirect_dst_flag ? dst_offset : 0, - .main_ind_op_c = static_cast(indirect_dst_flag), + .main_ind_addr_c = indirect_dst_flag ? dst_offset : 0, .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_c = direct_dst_offset, - .main_mem_op_activate_gas = 1, // TODO: remove in the long term - .main_mem_op_c = 1, + .main_mem_addr_c = direct_dst_offset, .main_pc = pc++, .main_rwc = 1, + .main_sel_mem_op_activate_gas = 1, // TODO: remove in the long term + .main_sel_mem_op_c = 1, + .main_sel_resolve_ind_addr_c = static_cast(indirect_dst_flag), .main_tag_err = static_cast(!tag_match), .main_w_in_tag = static_cast(in_tag), }); @@ -1025,20 +1025,20 @@ void AvmTraceBuilder::op_mov(uint8_t indirect, uint32_t src_offset, uint32_t dst .main_call_ptr = call_ptr, .main_ia = val, .main_ic = val, - .main_ind_a = indirect_src_flag ? src_offset : 0, - .main_ind_c = indirect_dst_flag ? dst_offset : 0, - .main_ind_op_a = static_cast(indirect_src_flag), - .main_ind_op_c = static_cast(indirect_dst_flag), + .main_ind_addr_a = indirect_src_flag ? src_offset : 0, + .main_ind_addr_c = indirect_dst_flag ? dst_offset : 0, .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_src_offset, - .main_mem_idx_c = direct_dst_offset, - .main_mem_op_a = 1, - .main_mem_op_c = 1, + .main_mem_addr_a = direct_src_offset, + .main_mem_addr_c = direct_dst_offset, .main_pc = pc++, .main_r_in_tag = static_cast(tag), .main_rwc = 1, - .main_sel_mov = 1, - .main_sel_mov_a = 1, + .main_sel_mem_op_a = 1, + .main_sel_mem_op_c = 1, + .main_sel_mov_ia_to_ic = 1, + .main_sel_op_mov = 1, + .main_sel_resolve_ind_addr_a = static_cast(indirect_src_flag), + .main_sel_resolve_ind_addr_c = static_cast(indirect_dst_flag), .main_tag_err = static_cast(!tag_match), .main_w_in_tag = static_cast(tag), }); @@ -1128,30 +1128,30 @@ void AvmTraceBuilder::op_cmov( .main_ic = val, .main_id = cond_mem_entry.val, .main_id_zero = static_cast(id_zero), - .main_ind_a = indirect_a_flag ? a_offset : 0, - .main_ind_b = indirect_b_flag ? b_offset : 0, - .main_ind_c = indirect_dst_flag ? dst_offset : 0, - .main_ind_d = indirect_cond_flag ? cond_offset : 0, - .main_ind_op_a = static_cast(indirect_a_flag), - .main_ind_op_b = static_cast(indirect_b_flag), - .main_ind_op_c = static_cast(indirect_dst_flag), - .main_ind_op_d = static_cast(indirect_cond_flag), + .main_ind_addr_a = indirect_a_flag ? a_offset : 0, + .main_ind_addr_b = indirect_b_flag ? b_offset : 0, + .main_ind_addr_c = indirect_dst_flag ? dst_offset : 0, + .main_ind_addr_d = indirect_cond_flag ? cond_offset : 0, .main_internal_return_ptr = internal_return_ptr, .main_inv = inv, - .main_mem_idx_a = direct_a_offset, - .main_mem_idx_b = direct_b_offset, - .main_mem_idx_c = direct_dst_offset, - .main_mem_idx_d = direct_cond_offset, - .main_mem_op_a = 1, - .main_mem_op_b = 1, - .main_mem_op_c = 1, - .main_mem_op_d = 1, + .main_mem_addr_a = direct_a_offset, + .main_mem_addr_b = direct_b_offset, + .main_mem_addr_c = direct_dst_offset, + .main_mem_addr_d = direct_cond_offset, .main_pc = pc++, .main_r_in_tag = static_cast(tag), .main_rwc = 1, - .main_sel_cmov = 1, - .main_sel_mov_a = static_cast(!id_zero), - .main_sel_mov_b = static_cast(id_zero), + .main_sel_mem_op_a = 1, + .main_sel_mem_op_b = 1, + .main_sel_mem_op_c = 1, + .main_sel_mem_op_d = 1, + .main_sel_mov_ia_to_ic = static_cast(!id_zero), + .main_sel_mov_ib_to_ic = static_cast(id_zero), + .main_sel_op_cmov = 1, + .main_sel_resolve_ind_addr_a = static_cast(indirect_a_flag), + .main_sel_resolve_ind_addr_b = static_cast(indirect_b_flag), + .main_sel_resolve_ind_addr_c = static_cast(indirect_dst_flag), + .main_sel_resolve_ind_addr_d = static_cast(indirect_cond_flag), .main_tag_err = static_cast(!tag_match), .main_w_in_tag = static_cast(tag), }); @@ -1181,14 +1181,14 @@ Row AvmTraceBuilder::create_kernel_lookup_opcode( .kernel_kernel_in_offset = selector, .main_call_ptr = call_ptr, .main_ia = value, - .main_ind_a = indirect ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect)), + .main_ind_addr_a = indirect ? FF(dst_offset) : FF(0), .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_dst_offset, - .main_mem_op_a = 1, + .main_mem_addr_a = direct_dst_offset, .main_pc = pc++, - .main_q_kernel_lookup = 1, .main_rwa = 1, + .main_sel_mem_op_a = 1, + .main_sel_q_kernel_lookup = 1, + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect)), .main_w_in_tag = static_cast(w_tag), }; } @@ -1373,15 +1373,15 @@ Row AvmTraceBuilder::create_kernel_output_opcode(uint8_t indirect, uint32_t clk, return Row{ .main_clk = clk, .main_ia = read_a.val, - .main_ind_a = indirect_data_flag ? FF(data_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect)), + .main_ind_addr_a = indirect_data_flag ? FF(data_offset) : FF(0), .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_data_offset, - .main_mem_op_a = 1, + .main_mem_addr_a = direct_data_offset, .main_pc = pc++, - .main_q_kernel_output_lookup = 1, .main_r_in_tag = static_cast(AvmMemoryTag::FF), .main_rwa = 0, + .main_sel_mem_op_a = 1, + .main_sel_q_kernel_output_lookup = 1, + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect)), }; } @@ -1424,20 +1424,20 @@ Row AvmTraceBuilder::create_kernel_output_opcode_with_metadata(uint8_t indirect, .main_clk = clk, .main_ia = read_a.val, .main_ib = read_b.val, - .main_ind_a = indirect_a_flag ? data_offset : FF(0), - .main_ind_b = indirect_b_flag ? metadata_offset : FF(0), - .main_ind_op_a = FF(static_cast(indirect_a_flag)), - .main_ind_op_b = FF(static_cast(indirect_b_flag)), + .main_ind_addr_a = indirect_a_flag ? data_offset : FF(0), + .main_ind_addr_b = indirect_b_flag ? metadata_offset : FF(0), .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_data_offset, - .main_mem_idx_b = direct_metadata_offset, - .main_mem_op_a = 1, - .main_mem_op_b = 1, + .main_mem_addr_a = direct_data_offset, + .main_mem_addr_b = direct_metadata_offset, .main_pc = pc++, - .main_q_kernel_output_lookup = 1, .main_r_in_tag = static_cast(data_r_tag), .main_rwa = 0, .main_rwb = 0, + .main_sel_mem_op_a = 1, + .main_sel_mem_op_b = 1, + .main_sel_q_kernel_output_lookup = 1, + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_a_flag)), + .main_sel_resolve_ind_addr_b = FF(static_cast(indirect_b_flag)), }; } @@ -1482,20 +1482,20 @@ Row AvmTraceBuilder::create_kernel_output_opcode_with_set_metadata_output_from_h .main_clk = clk, .main_ia = read_a.val, .main_ib = exists, - .main_ind_a = indirect_a_flag ? data_offset : FF(0), - .main_ind_b = indirect_b_flag ? metadata_offset : FF(0), - .main_ind_op_a = FF(static_cast(indirect_a_flag)), - .main_ind_op_b = FF(static_cast(indirect_b_flag)), + .main_ind_addr_a = indirect_a_flag ? data_offset : FF(0), + .main_ind_addr_b = indirect_b_flag ? metadata_offset : FF(0), .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_data_offset, - .main_mem_idx_b = direct_metadata_offset, - .main_mem_op_a = 1, - .main_mem_op_b = 1, + .main_mem_addr_a = direct_data_offset, + .main_mem_addr_b = direct_metadata_offset, .main_pc = pc++, - .main_q_kernel_output_lookup = 1, .main_r_in_tag = static_cast(AvmMemoryTag::FF), .main_rwa = 0, .main_rwb = 1, + .main_sel_mem_op_a = 1, + .main_sel_mem_op_b = 1, + .main_sel_q_kernel_output_lookup = 1, + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_a_flag)), + .main_sel_resolve_ind_addr_b = FF(static_cast(indirect_b_flag)), .main_w_in_tag = static_cast(AvmMemoryTag::U8), }; } @@ -1536,20 +1536,20 @@ Row AvmTraceBuilder::create_kernel_output_opcode_with_set_value_from_hint(uint8_ .main_clk = clk, .main_ia = value, .main_ib = read_b.val, - .main_ind_a = indirect_a_flag ? data_offset : FF(0), - .main_ind_b = indirect_b_flag ? metadata_offset : FF(0), - .main_ind_op_a = FF(static_cast(indirect_a_flag)), - .main_ind_op_b = FF(static_cast(indirect_b_flag)), + .main_ind_addr_a = indirect_a_flag ? data_offset : FF(0), + .main_ind_addr_b = indirect_b_flag ? metadata_offset : FF(0), .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_data_offset, - .main_mem_idx_b = direct_metadata_offset, - .main_mem_op_a = 1, - .main_mem_op_b = 1, + .main_mem_addr_a = direct_data_offset, + .main_mem_addr_b = direct_metadata_offset, .main_pc = pc, // No PC increment here since we do it in the specific ops - .main_q_kernel_output_lookup = 1, .main_r_in_tag = static_cast(AvmMemoryTag::FF), .main_rwa = 1, .main_rwb = 0, + .main_sel_mem_op_a = 1, + .main_sel_mem_op_b = 1, + .main_sel_q_kernel_output_lookup = 1, + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_a_flag)), + .main_sel_resolve_ind_addr_b = FF(static_cast(indirect_b_flag)), .main_w_in_tag = static_cast(AvmMemoryTag::FF), }; } @@ -1690,15 +1690,15 @@ void AvmTraceBuilder::op_sload(uint8_t indirect, uint32_t slot_offset, uint32_t .main_clk = clk, .main_ia = read_dest_value.val, .main_ib = read_slot.val, - .main_ind_a = dest_offset_is_indirect ? dest_offset : 0, - .main_ind_op_a = FF(static_cast(dest_offset_is_indirect)), + .main_ind_addr_a = dest_offset_is_indirect ? dest_offset : 0, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_dest_offset), - .main_mem_idx_b = FF(slot_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_dest_offset), + .main_mem_addr_b = FF(slot_offset), .main_pc = pc, // No PC increment here since this is the same opcode as the rows created below .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(dest_offset_is_indirect)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), }); clk++; @@ -1714,13 +1714,13 @@ void AvmTraceBuilder::op_sload(uint8_t indirect, uint32_t slot_offset, uint32_t .main_ia = value, .main_ib = read_slot.val + i, // slot increments each time .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_dest_offset + i, - .main_mem_op_a = 1, + .main_mem_addr_a = direct_dest_offset + i, .main_pc = pc, // No PC increment here since this is the same opcode for all loop iterations - .main_q_kernel_output_lookup = 1, .main_r_in_tag = static_cast(AvmMemoryTag::FF), .main_rwa = 1, + .main_sel_mem_op_a = 1, .main_sel_op_sload = FF(1), + .main_sel_q_kernel_output_lookup = 1, .main_w_in_tag = static_cast(AvmMemoryTag::FF), }; @@ -1762,15 +1762,15 @@ void AvmTraceBuilder::op_sstore(uint8_t indirect, uint32_t src_offset, uint32_t .main_clk = clk, .main_ia = read_src_value.val, .main_ib = read_slot.val, - .main_ind_a = src_offset_is_indirect ? src_offset : 0, - .main_ind_op_a = FF(static_cast(src_offset_is_indirect)), + .main_ind_addr_a = src_offset_is_indirect ? src_offset : 0, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_src_offset), - .main_mem_idx_b = FF(slot_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_src_offset), + .main_mem_addr_b = FF(slot_offset), .main_pc = pc, // No PC increment here since this is the same opcode as the rows created below .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(src_offset_is_indirect)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), }); clk++; @@ -1784,11 +1784,11 @@ void AvmTraceBuilder::op_sstore(uint8_t indirect, uint32_t src_offset, uint32_t .main_ia = read_a.val, .main_ib = read_slot.val + i, // slot increments each time .main_internal_return_ptr = internal_return_ptr, - .main_mem_idx_a = direct_src_offset + i, - .main_mem_op_a = 1, + .main_mem_addr_a = direct_src_offset + i, .main_pc = pc, - .main_q_kernel_output_lookup = 1, .main_r_in_tag = static_cast(AvmMemoryTag::FF), + .main_sel_mem_op_a = 1, + .main_sel_q_kernel_output_lookup = 1, }; row.main_sel_op_sstore = FF(1); kernel_trace_builder.op_sstore(clk, side_effect_counter, row.main_ib, row.main_ia); @@ -1857,19 +1857,19 @@ void AvmTraceBuilder::op_cast(uint8_t indirect, uint32_t a_offset, uint32_t dst_ .main_call_ptr = call_ptr, .main_ia = a, .main_ic = c, - .main_ind_a = indirect_a_flag ? FF(a_offset) : FF(0), - .main_ind_c = indirect_dst_flag ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_a_flag)), - .main_ind_op_c = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_a_flag ? FF(a_offset) : FF(0), + .main_ind_addr_c = indirect_dst_flag ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_a_offset), - .main_mem_idx_c = FF(direct_dst_offset), - .main_mem_op_a = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(direct_a_offset), + .main_mem_addr_c = FF(direct_dst_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(memEntry.tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_cast = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_a_flag)), + .main_sel_resolve_ind_addr_c = FF(static_cast(indirect_dst_flag)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(dst_tag)), }); @@ -1933,25 +1933,25 @@ void AvmTraceBuilder::op_div( .main_ia = a, .main_ib = b, .main_ic = c, - .main_ind_a = res.indirect_flag_a ? FF(a_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(b_offset) : FF(0), - .main_ind_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(a_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(b_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_c ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), .main_inv = tag_match ? inv : FF(1), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_op_err = tag_match ? error : FF(1), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(in_tag)), .main_rwc = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_div = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(in_tag)), }); @@ -1994,8 +1994,8 @@ void AvmTraceBuilder::calldata_copy( FF ic(0); uint32_t mem_op_b(0); uint32_t mem_op_c(0); - uint32_t mem_idx_b(0); - uint32_t mem_idx_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; @@ -2015,32 +2015,32 @@ void AvmTraceBuilder::calldata_copy( tag_match = ind_read.tag_match; } - uint32_t mem_idx_a = direct_dst_offset + pos; + uint32_t mem_addr_a = direct_dst_offset + pos; // Storing from Ia mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IA, mem_idx_a, ia, AvmMemoryTag::U0, AvmMemoryTag::FF); + call_ptr, clk, IntermRegister::IA, mem_addr_a, ia, AvmMemoryTag::U0, AvmMemoryTag::FF); if (copy_size - pos > 1) { ib = call_data_mem.at(cd_offset + pos + 1); mem_op_b = 1; - mem_idx_b = direct_dst_offset + pos + 1; + mem_addr_b = direct_dst_offset + pos + 1; rwb = 1; // Storing from Ib mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IB, mem_idx_b, ib, AvmMemoryTag::U0, AvmMemoryTag::FF); + call_ptr, clk, IntermRegister::IB, mem_addr_b, ib, AvmMemoryTag::U0, AvmMemoryTag::FF); } if (copy_size - pos > 2) { ic = call_data_mem.at(cd_offset + pos + 2); mem_op_c = 1; - mem_idx_c = direct_dst_offset + pos + 2; + mem_addr_c = direct_dst_offset + pos + 2; rwc = 1; // Storing from Ic mem_trace_builder.write_into_memory( - call_ptr, clk, IntermRegister::IC, mem_idx_c, ic, AvmMemoryTag::U0, AvmMemoryTag::FF); + call_ptr, clk, IntermRegister::IC, mem_addr_c, ic, AvmMemoryTag::U0, AvmMemoryTag::FF); } // Constrain gas cost on the first row @@ -2054,21 +2054,21 @@ void AvmTraceBuilder::calldata_copy( .main_ia = ia, .main_ib = ib, .main_ic = ic, - .main_ind_a = indirect_flag ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_flag)), + .main_ind_addr_a = indirect_flag ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(mem_idx_a), - .main_mem_idx_b = FF(mem_idx_b), - .main_mem_idx_c = FF(mem_idx_c), - .main_mem_op_a = FF(mem_op_a), - .main_mem_op_activate_gas = FF(static_cast( - pos == 0)), // TODO: remove in the long term. This activate gas only for the first row. - .main_mem_op_b = FF(mem_op_b), - .main_mem_op_c = FF(mem_op_c), + .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)), }); @@ -2128,8 +2128,8 @@ std::vector AvmTraceBuilder::return_op(uint8_t indirect, uint32_t ret_offset FF ic(0); uint32_t mem_op_b(0); uint32_t mem_op_c(0); - uint32_t mem_idx_b(0); - uint32_t mem_idx_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); @@ -2144,11 +2144,11 @@ std::vector AvmTraceBuilder::return_op(uint8_t indirect, uint32_t ret_offset tag_match = ind_read.tag_match; } - uint32_t mem_idx_a = direct_ret_offset + pos; + 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_idx_a, AvmMemoryTag::FF, AvmMemoryTag::FF); + 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; @@ -2156,11 +2156,11 @@ std::vector AvmTraceBuilder::return_op(uint8_t indirect, uint32_t ret_offset if (ret_size - pos > 1) { mem_op_b = 1; - mem_idx_b = direct_ret_offset + pos + 1; + mem_addr_b = direct_ret_offset + pos + 1; // Reading and loading to Ib auto read_b = mem_trace_builder.read_and_load_from_memory( - call_ptr, clk, IntermRegister::IB, mem_idx_b, AvmMemoryTag::FF, AvmMemoryTag::FF); + 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); @@ -2168,11 +2168,11 @@ std::vector AvmTraceBuilder::return_op(uint8_t indirect, uint32_t ret_offset if (ret_size - pos > 2) { mem_op_c = 1; - mem_idx_c = direct_ret_offset + pos + 2; + mem_addr_c = direct_ret_offset + pos + 2; // Reading and loading to Ic auto read_c = mem_trace_builder.read_and_load_from_memory( - call_ptr, clk, IntermRegister::IC, mem_idx_c, AvmMemoryTag::FF, AvmMemoryTag::FF); + 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); @@ -2189,20 +2189,20 @@ std::vector AvmTraceBuilder::return_op(uint8_t indirect, uint32_t ret_offset .main_ia = ia, .main_ib = ib, .main_ic = ic, - .main_ind_a = indirect_flag ? FF(ret_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_flag)), + .main_ind_addr_a = indirect_flag ? FF(ret_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(mem_idx_a), - .main_mem_idx_b = FF(mem_idx_b), - .main_mem_idx_c = FF(mem_idx_c), - .main_mem_op_a = FF(mem_op_a), - .main_mem_op_activate_gas = FF(static_cast( - pos == 0)), // TODO: remove in the long term. This activate gas only for the first row. - .main_mem_op_b = FF(mem_op_b), - .main_mem_op_c = FF(mem_op_c), + .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_halt = FF(1), + .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)), }); @@ -2232,7 +2232,7 @@ void AvmTraceBuilder::halt() .main_call_ptr = call_ptr, .main_internal_return_ptr = FF(internal_return_ptr), .main_pc = FF(pc), - .main_sel_halt = FF(1), + .main_sel_op_halt = FF(1), }); pc = UINT32_MAX; // This ensures that no subsequent opcode will be executed. @@ -2280,16 +2280,16 @@ void AvmTraceBuilder::execute_gasleft(OpCode opcode, uint8_t indirect, uint32_t .main_clk = clk, .main_call_ptr = call_ptr, .main_ia = gas_remaining, - .main_ind_a = indirect_dst_flag ? FF(dst_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_dst_flag ? FF(dst_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_dst_offset), - .main_mem_op_a = FF(1), + .main_mem_addr_a = FF(direct_dst_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U0)), .main_rwa = FF(1), + .main_sel_mem_op_a = FF(1), .main_sel_op_dagasleft = (opcode == OpCode::DAGASLEFT) ? FF(1) : FF(0), .main_sel_op_l2gasleft = (opcode == OpCode::L2GASLEFT) ? FF(1) : FF(0), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_dst_flag)), .main_tag_err = FF(static_cast(!tag_match)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), // TODO: probably will be U32 in final version // Should the circuit (pil) constrain U32? @@ -2327,7 +2327,7 @@ void AvmTraceBuilder::jump(uint32_t jmp_dest) .main_ia = FF(jmp_dest), .main_internal_return_ptr = FF(internal_return_ptr), .main_pc = FF(pc), - .main_sel_jump = FF(1), + .main_sel_op_jump = FF(1), }); // Adjust parameters for the next row @@ -2376,15 +2376,15 @@ void AvmTraceBuilder::jumpi(uint8_t indirect, uint32_t jmp_dest, uint32_t cond_o .main_ia = FF(next_pc), .main_id = read_d.val, .main_id_zero = static_cast(id_zero), - .main_ind_d = indirect_cond_flag ? cond_offset : 0, - .main_ind_op_d = static_cast(indirect_cond_flag), + .main_ind_addr_d = indirect_cond_flag ? cond_offset : 0, .main_internal_return_ptr = FF(internal_return_ptr), .main_inv = inv, - .main_mem_idx_d = direct_cond_offset, - .main_mem_op_d = 1, + .main_mem_addr_d = direct_cond_offset, .main_pc = FF(pc), .main_r_in_tag = static_cast(read_d.tag), - .main_sel_jumpi = FF(1), + .main_sel_mem_op_d = 1, + .main_sel_op_jumpi = FF(1), + .main_sel_resolve_ind_addr_d = static_cast(indirect_cond_flag), .main_tag_err = static_cast(!tag_match), .main_w_in_tag = static_cast(read_d.tag), }); @@ -2428,11 +2428,11 @@ void AvmTraceBuilder::internal_call(uint32_t jmp_dest) .main_ia = FF(jmp_dest), .main_ib = FF(pc + 1), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_b = FF(internal_return_ptr), - .main_mem_op_b = FF(1), + .main_mem_addr_b = FF(internal_return_ptr), .main_pc = FF(pc), .main_rwb = FF(1), - .main_sel_internal_call = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_op_internal_call = FF(1), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U32)), }); @@ -2469,12 +2469,12 @@ void AvmTraceBuilder::internal_return() .main_call_ptr = call_ptr, .main_ia = read_a.val, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(internal_return_ptr - 1), - .main_mem_op_a = FF(1), + .main_mem_addr_a = FF(internal_return_ptr - 1), .main_pc = pc, .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), .main_rwa = FF(0), - .main_sel_internal_return = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_op_internal_return = FF(1), .main_tag_err = FF(static_cast(!read_a.tag_match)), }); @@ -2516,23 +2516,23 @@ void AvmTraceBuilder::write_slice_to_memory(uint8_t space_id, // This looks a bit gross, but it is fine for now. if (j == 0) { main_row.main_ia = slice.at(offset); - main_row.main_mem_idx_a = FF(dst_offset + offset); - main_row.main_mem_op_a = FF(1); + main_row.main_mem_addr_a = FF(dst_offset + offset); + main_row.main_sel_mem_op_a = FF(1); main_row.main_rwa = FF(1); } else if (j == 1) { main_row.main_ib = slice.at(offset); - main_row.main_mem_idx_b = FF(dst_offset + offset); - main_row.main_mem_op_b = FF(1); + main_row.main_mem_addr_b = FF(dst_offset + offset); + main_row.main_sel_mem_op_b = FF(1); main_row.main_rwb = FF(1); } else if (j == 2) { main_row.main_ic = slice.at(offset); - main_row.main_mem_idx_c = FF(dst_offset + offset); - main_row.main_mem_op_c = FF(1); + main_row.main_mem_addr_c = FF(dst_offset + offset); + main_row.main_sel_mem_op_c = FF(1); main_row.main_rwc = FF(1); } else { main_row.main_id = slice.at(offset); - main_row.main_mem_idx_d = FF(dst_offset + offset); - main_row.main_mem_op_d = FF(1); + main_row.main_mem_addr_d = FF(dst_offset + offset); + main_row.main_sel_mem_op_d = FF(1); main_row.main_rwd = FF(1); } } @@ -2585,23 +2585,23 @@ uint32_t AvmTraceBuilder::read_slice_to_memory(uint8_t space_id, // This looks a bit gross, but it is fine for now. if (j == 0) { main_row.main_ia = slice.at(offset); - main_row.main_mem_idx_a = FF(src_offset + offset); - main_row.main_mem_op_a = FF(1); + main_row.main_mem_addr_a = FF(src_offset + offset); + main_row.main_sel_mem_op_a = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } else if (j == 1) { main_row.main_ib = slice.at(offset); - main_row.main_mem_idx_b = FF(src_offset + offset); - main_row.main_mem_op_b = FF(1); + main_row.main_mem_addr_b = FF(src_offset + offset); + main_row.main_sel_mem_op_b = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } else if (j == 2) { main_row.main_ic = slice.at(offset); - main_row.main_mem_idx_c = FF(src_offset + offset); - main_row.main_mem_op_c = FF(1); + main_row.main_mem_addr_c = FF(src_offset + offset); + main_row.main_sel_mem_op_c = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } else { main_row.main_id = slice.at(offset); - main_row.main_mem_idx_d = FF(src_offset + offset); - main_row.main_mem_op_d = FF(1); + main_row.main_mem_addr_d = FF(src_offset + offset); + main_row.main_sel_mem_op_d = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } } @@ -2672,20 +2672,20 @@ void AvmTraceBuilder::op_call([[maybe_unused]] uint8_t indirect, .main_ia = first_row_values[0], /* gas_offset */ .main_ib = first_row_values[1], /* addr_offset */ .main_ic = first_row_values[2], /* args_offset */ - .main_ind_a = gas_offset, - .main_ind_c = args_offset, - .main_ind_op_a = FF(1), - .main_ind_op_c = FF(1), + .main_ind_addr_a = gas_offset, + .main_ind_addr_c = args_offset, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = read_ind_gas_offset.val, - .main_mem_idx_b = addr_offset, - .main_mem_idx_c = read_ind_args_offset.val, - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = read_ind_gas_offset.val, + .main_mem_addr_b = addr_offset, + .main_mem_addr_c = read_ind_args_offset.val, .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), - .main_sel_external_call = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), + .main_sel_op_external_call = FF(1), + .main_sel_resolve_ind_addr_a = FF(1), + .main_sel_resolve_ind_addr_c = FF(1), }); clk++; // Read the rest on a separate line, remember that the 4th operand is indirect @@ -2697,13 +2697,13 @@ void AvmTraceBuilder::op_call([[maybe_unused]] uint8_t indirect, main_trace.push_back(Row{ .main_clk = clk, .main_ia = mem_read_ret.val, /* ret_offset */ - .main_ind_a = ret_offset, - .main_ind_op_a = FF(1), + .main_ind_addr_a = ret_offset, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = read_ind_ret_offset.val, - .main_mem_op_a = FF(1), + .main_mem_addr_a = read_ind_ret_offset.val, .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_resolve_ind_addr_a = FF(1), }); clk++; auto mem_read_success = mem_trace_builder.read_and_load_from_memory( @@ -2712,10 +2712,10 @@ void AvmTraceBuilder::op_call([[maybe_unused]] uint8_t indirect, .main_clk = clk, .main_ia = mem_read_success.val, /* success_offset */ .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(success_offset), - .main_mem_op_a = FF(1), + .main_mem_addr_a = FF(success_offset), .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), + .main_sel_mem_op_a = FF(1), }); clk++; write_slice_to_memory(call_ptr, @@ -2767,19 +2767,19 @@ void AvmTraceBuilder::op_get_contract_instance(uint8_t indirect, uint32_t addres .main_clk = clk, .main_ia = read_address.val, .main_ib = read_dst.val, - .main_ind_a = indirect_address_flag ? address_offset : 0, - .main_ind_b = indirect_dst_flag ? dst_offset : 0, - .main_ind_op_a = FF(static_cast(indirect_address_flag)), - .main_ind_op_b = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_address_flag ? address_offset : 0, + .main_ind_addr_b = indirect_dst_flag ? dst_offset : 0, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_address_offset), - .main_mem_idx_b = FF(direct_dst_offset), - .main_mem_op_a = FF(1), - .main_mem_op_activate_gas = FF(1), // TODO: remove in the long term - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_address_offset), + .main_mem_addr_b = FF(direct_dst_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_activate_gas = FF(1), // TODO: remove in the long term + .main_sel_mem_op_b = FF(1), .main_sel_op_get_contract_instance = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_address_flag)), + .main_sel_resolve_ind_addr_b = FF(static_cast(indirect_dst_flag)), }); clk++; // Read the contract instance @@ -2862,18 +2862,18 @@ void AvmTraceBuilder::op_to_radix_le( .main_ib = dst_addr, .main_ic = radix, .main_id = num_limbs, - .main_ind_a = indirect_src_flag ? src_offset : 0, - .main_ind_b = indirect_dst_flag ? dst_offset : 0, - .main_ind_op_a = FF(static_cast(indirect_src_flag)), - .main_ind_op_b = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_src_flag ? src_offset : 0, + .main_ind_addr_b = indirect_dst_flag ? dst_offset : 0, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_src_offset), - .main_mem_idx_b = FF(direct_dst_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_src_offset), + .main_mem_addr_b = FF(direct_dst_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), .main_sel_op_radix_le = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_src_flag)), + .main_sel_resolve_ind_addr_b = FF(static_cast(indirect_dst_flag)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U8)), }); // Increment the clock so we dont write at the same clock cycle @@ -2936,22 +2936,22 @@ void AvmTraceBuilder::op_sha256_compression(uint8_t indirect, .main_ia = read_a.val, // First element of output (trivially 0) .main_ib = read_b.val, // First element of state .main_ic = read_c.val, // First element of input - .main_ind_a = res.indirect_flag_a ? FF(h_init_offset) : FF(0), - .main_ind_b = res.indirect_flag_b ? FF(input_offset) : FF(0), - .main_ind_c = res.indirect_flag_a ? FF(output_offset) : FF(0), - .main_ind_op_a = FF(static_cast(res.indirect_flag_a)), - .main_ind_op_b = FF(static_cast(res.indirect_flag_b)), - .main_ind_op_c = FF(static_cast(res.indirect_flag_c)), + .main_ind_addr_a = res.indirect_flag_a ? FF(h_init_offset) : FF(0), + .main_ind_addr_b = res.indirect_flag_b ? FF(input_offset) : FF(0), + .main_ind_addr_c = res.indirect_flag_a ? FF(output_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(res.direct_a_offset), - .main_mem_idx_b = FF(res.direct_b_offset), - .main_mem_idx_c = FF(res.direct_c_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(res.direct_a_offset), + .main_mem_addr_b = FF(res.direct_b_offset), + .main_mem_addr_c = FF(res.direct_c_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_sha256 = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(res.indirect_flag_a)), + .main_sel_resolve_ind_addr_b = FF(static_cast(res.indirect_flag_b)), + .main_sel_resolve_ind_addr_c = FF(static_cast(res.indirect_flag_c)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U32)), }); // We store the current clk this main trace row occurred so that we can line up the sha256 gadget operation at @@ -3056,18 +3056,18 @@ void AvmTraceBuilder::op_sha256(uint8_t indirect, .main_clk = clk, .main_ia = input_read.val, // First element of input .main_ic = output_read.val, // First element of output - .main_ind_a = indirect_src_flag ? FF(input_offset) : FF(0), - .main_ind_c = indirect_dst_flag ? FF(output_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_src_flag)), - .main_ind_op_c = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_src_flag ? FF(input_offset) : FF(0), + .main_ind_addr_c = indirect_dst_flag ? FF(output_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_src_offset), // input - .main_mem_idx_c = FF(direct_dst_offset), // output - .main_mem_op_a = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(direct_src_offset), // input + .main_mem_addr_c = FF(direct_dst_offset), // output .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U8)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_sha256 = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_src_flag)), + .main_sel_resolve_ind_addr_c = FF(static_cast(indirect_dst_flag)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U8)), }); clk++; @@ -3077,10 +3077,10 @@ void AvmTraceBuilder::op_sha256(uint8_t indirect, .main_clk = clk, .main_ib = input_length_read.val, // Message Length .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_b = FF(input_size_offset), // length - .main_mem_op_b = FF(1), + .main_mem_addr_b = FF(input_size_offset), // length .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), + .main_sel_mem_op_b = FF(1), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U32)), }); clk++; @@ -3115,23 +3115,23 @@ void AvmTraceBuilder::op_sha256(uint8_t indirect, // This looks a bit gross, but it is fine for now. if (j == 0) { main_row.main_ia = input.at(offset); - main_row.main_mem_idx_a = FF(direct_src_offset + offset); - main_row.main_mem_op_a = FF(1); + main_row.main_mem_addr_a = FF(direct_src_offset + offset); + main_row.main_sel_mem_op_a = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } else if (j == 1) { main_row.main_ib = input.at(offset); - main_row.main_mem_idx_b = FF(direct_src_offset + offset); - main_row.main_mem_op_b = FF(1); + main_row.main_mem_addr_b = FF(direct_src_offset + offset); + main_row.main_sel_mem_op_b = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } else if (j == 2) { main_row.main_ic = input.at(offset); - main_row.main_mem_idx_c = FF(direct_src_offset + offset); - main_row.main_mem_op_c = FF(1); + main_row.main_mem_addr_c = FF(direct_src_offset + offset); + main_row.main_sel_mem_op_c = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } else { main_row.main_id = input.at(offset); - main_row.main_mem_idx_d = FF(direct_src_offset + offset); - main_row.main_mem_op_d = FF(1); + main_row.main_mem_addr_d = FF(direct_src_offset + offset); + main_row.main_sel_mem_op_d = FF(1); main_row.main_tag_err = FF(static_cast(!mem_read.tag_match)); } } @@ -3200,18 +3200,18 @@ void AvmTraceBuilder::op_poseidon2_permutation(uint8_t indirect, uint32_t input_ .main_clk = clk, .main_ia = read_a.val, // First element of input .main_ib = read_b.val, // First element of output (trivially zero) - .main_ind_a = indirect_src_flag ? FF(input_offset) : FF(0), - .main_ind_b = indirect_dst_flag ? FF(output_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_src_flag)), - .main_ind_op_b = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_src_flag ? FF(input_offset) : FF(0), + .main_ind_addr_b = indirect_dst_flag ? FF(output_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_src_offset), - .main_mem_idx_b = FF(direct_dst_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_src_offset), + .main_mem_addr_b = FF(direct_dst_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), .main_sel_op_poseidon2 = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_src_flag)), + .main_sel_resolve_ind_addr_b = FF(static_cast(indirect_dst_flag)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), }); // We store the current clk this main trace row occurred so that we can line up the poseidon2 gadget operation @@ -3290,18 +3290,18 @@ void AvmTraceBuilder::op_keccakf1600(uint8_t indirect, .main_clk = clk, .main_ia = input_read.val, // First element of input .main_ic = output_read.val, // First element of output - .main_ind_a = indirect_src_flag ? FF(input_offset) : FF(0), - .main_ind_c = indirect_dst_flag ? FF(output_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_src_flag)), - .main_ind_op_c = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_src_flag ? FF(input_offset) : FF(0), + .main_ind_addr_c = indirect_dst_flag ? FF(output_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_src_offset), // input - .main_mem_idx_c = FF(direct_dst_offset), // output - .main_mem_op_a = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(direct_src_offset), // input + .main_mem_addr_c = FF(direct_dst_offset), // output .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U64)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_keccak = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_src_flag)), + .main_sel_resolve_ind_addr_c = FF(static_cast(indirect_dst_flag)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U64)), }); // We store the current clk this main trace row occurred so that we can line up the keccak gadget operation @@ -3315,10 +3315,10 @@ void AvmTraceBuilder::op_keccakf1600(uint8_t indirect, .main_clk = clk, .main_ib = input_length_read.val, // Message Length .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_b = FF(input_size_offset), // length - .main_mem_op_b = FF(1), + .main_mem_addr_b = FF(input_size_offset), // length .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), + .main_sel_mem_op_b = FF(1), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U32)), }); clk++; @@ -3398,18 +3398,18 @@ void AvmTraceBuilder::op_keccak(uint8_t indirect, .main_clk = clk, .main_ia = input_read.val, // First element of input .main_ic = output_read.val, // First element of output - .main_ind_a = indirect_src_flag ? FF(input_offset) : FF(0), - .main_ind_c = indirect_dst_flag ? FF(output_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_src_flag)), - .main_ind_op_c = FF(static_cast(indirect_dst_flag)), + .main_ind_addr_a = indirect_src_flag ? FF(input_offset) : FF(0), + .main_ind_addr_c = indirect_dst_flag ? FF(output_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_src_offset), // input - .main_mem_idx_c = FF(direct_dst_offset), // output - .main_mem_op_a = FF(1), - .main_mem_op_c = FF(1), + .main_mem_addr_a = FF(direct_src_offset), // input + .main_mem_addr_c = FF(direct_dst_offset), // output .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U8)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_c = FF(1), .main_sel_op_keccak = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_src_flag)), + .main_sel_resolve_ind_addr_c = FF(static_cast(indirect_dst_flag)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U8)), }); clk++; @@ -3419,10 +3419,10 @@ void AvmTraceBuilder::op_keccak(uint8_t indirect, .main_clk = clk, .main_ib = input_length_read.val, // Message Length .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_b = FF(input_size_offset), // length - .main_mem_op_b = FF(1), + .main_mem_addr_b = FF(input_size_offset), // length .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), + .main_sel_mem_op_b = FF(1), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U32)), }); clk++; @@ -3482,14 +3482,14 @@ void AvmTraceBuilder::op_pedersen_hash(uint8_t indirect, main_trace.push_back(Row{ .main_clk = clk, .main_ia = input_read.val, // First element of input - .main_ind_a = indirect_src_flag ? FF(input_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_src_flag)), + .main_ind_addr_a = indirect_src_flag ? FF(input_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_src_offset), // input - .main_mem_op_a = FF(1), + .main_mem_addr_a = FF(direct_src_offset), // input .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), .main_sel_op_pedersen = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_src_flag)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), }); clk++; @@ -3503,12 +3503,12 @@ void AvmTraceBuilder::op_pedersen_hash(uint8_t indirect, .main_ia = input_size_read.val, .main_ib = gen_ctx_read.val, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(input_size_offset), - .main_mem_idx_b = FF(gen_ctx_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(input_size_offset), + .main_mem_addr_b = FF(gen_ctx_offset), .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U32)), }); clk++; @@ -3558,16 +3558,16 @@ void AvmTraceBuilder::op_ec_add(uint8_t indirect, .main_ic = rhs_x_read.val, .main_id = rhs_y_read.val, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(lhs_x_offset), - .main_mem_idx_b = FF(lhs_y_offset), - .main_mem_idx_c = FF(rhs_x_offset), - .main_mem_idx_d = FF(rhs_y_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), - .main_mem_op_d = FF(1), + .main_mem_addr_a = FF(lhs_x_offset), + .main_mem_addr_b = FF(lhs_y_offset), + .main_mem_addr_c = FF(rhs_x_offset), + .main_mem_addr_d = FF(rhs_y_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), + .main_sel_mem_op_d = FF(1), }); clk++; // Load the infinite bools separately since they have a different memory tag @@ -3581,12 +3581,12 @@ void AvmTraceBuilder::op_ec_add(uint8_t indirect, .main_ia = lhs_is_inf_read.val, .main_ib = rhs_is_inf_read.val, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(lhs_is_inf_offset), - .main_mem_idx_b = FF(rhs_is_inf_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(lhs_is_inf_offset), + .main_mem_addr_b = FF(rhs_is_inf_offset), .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U8)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), }); clk++; grumpkin::g1::affine_element lhs = uint8_t(lhs_is_inf_read.val) == 1 @@ -3613,16 +3613,16 @@ void AvmTraceBuilder::op_ec_add(uint8_t indirect, .main_clk = clk, .main_ia = result.x, .main_ib = result.y, - .main_ind_a = indirect_flag_output ? FF(output_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_flag_output)), + .main_ind_addr_a = indirect_flag_output ? FF(output_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_output_offset), - .main_mem_idx_b = FF(direct_output_offset + 1), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_output_offset), + .main_mem_addr_b = FF(direct_output_offset + 1), .main_pc = FF(pc), .main_rwa = FF(1), .main_rwb = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_flag_output)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), }); clk++; @@ -3680,17 +3680,17 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, .main_clk = clk, .main_ia = read_points.val, .main_ib = read_scalars.val, - .main_ind_a = indirect_points_flag ? FF(points_offset) : FF(0), - .main_ind_b = indirect_scalars_flag ? FF(scalars_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_points_flag)), - .main_ind_op_b = FF(static_cast(indirect_scalars_flag)), + .main_ind_addr_a = indirect_points_flag ? FF(points_offset) : FF(0), + .main_ind_addr_b = indirect_scalars_flag ? FF(scalars_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_points_offset), - .main_mem_idx_b = FF(direct_scalars_offset), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_points_offset), + .main_mem_addr_b = FF(direct_scalars_offset), .main_pc = FF(pc++), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_points_flag)), + .main_sel_resolve_ind_addr_b = FF(static_cast(indirect_scalars_flag)), .main_tag_err = FF(static_cast(!tag_match)), }); clk++; @@ -3702,10 +3702,10 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, .main_clk = clk, .main_ia = points_length_read.val, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(point_length_offset), - .main_mem_op_a = FF(1), + .main_mem_addr_a = FF(point_length_offset), .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U32)), + .main_sel_mem_op_a = FF(1), .main_tag_err = FF(static_cast(!points_length_read.tag_match)), }); clk++; @@ -3743,16 +3743,16 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, .main_ic = point_x2_read.val, .main_id = point_y2_read.val, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_points_offset + i * 3), - .main_mem_idx_b = FF(direct_points_offset + i * 3 + 1), - .main_mem_idx_c = FF(direct_points_offset + (i + 1) * 3), - .main_mem_idx_d = FF(direct_points_offset + (i + 1) * 3 + 1), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), - .main_mem_op_d = FF(1), + .main_mem_addr_a = FF(direct_points_offset + i * 3), + .main_mem_addr_b = FF(direct_points_offset + i * 3 + 1), + .main_mem_addr_c = FF(direct_points_offset + (i + 1) * 3), + .main_mem_addr_d = FF(direct_points_offset + (i + 1) * 3 + 1), .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::FF)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), + .main_sel_mem_op_d = FF(1), .main_tag_err = FF(static_cast(!tag_match)), }); clk++; @@ -3788,16 +3788,16 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, .main_ic = point_inf3_read.val, .main_id = point_inf4_read.val, .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_points_offset + i * 3 + 2), - .main_mem_idx_b = FF(direct_points_offset + (i + 1) * 3 + 2), - .main_mem_idx_c = FF(direct_points_offset + (i + 2) * 3 + 2), - .main_mem_idx_d = FF(direct_points_offset + (i + 3) * 3 + 2), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), - .main_mem_op_c = FF(1), - .main_mem_op_d = FF(1), + .main_mem_addr_a = FF(direct_points_offset + i * 3 + 2), + .main_mem_addr_b = FF(direct_points_offset + (i + 1) * 3 + 2), + .main_mem_addr_c = FF(direct_points_offset + (i + 2) * 3 + 2), + .main_mem_addr_d = FF(direct_points_offset + (i + 3) * 3 + 2), .main_pc = FF(pc), .main_r_in_tag = FF(static_cast(AvmMemoryTag::U8)), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_mem_op_c = FF(1), + .main_sel_mem_op_d = FF(1), .main_tag_err = FF(static_cast(!tag_match)), }); clk++; @@ -3851,16 +3851,16 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, .main_clk = clk, .main_ia = result.x, .main_ib = result.y, - .main_ind_a = indirect_output_flag ? FF(output_offset) : FF(0), - .main_ind_op_a = FF(static_cast(indirect_output_flag)), + .main_ind_addr_a = indirect_output_flag ? FF(output_offset) : FF(0), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_output_offset), - .main_mem_idx_b = FF(direct_output_offset + 1), - .main_mem_op_a = FF(1), - .main_mem_op_b = FF(1), + .main_mem_addr_a = FF(direct_output_offset), + .main_mem_addr_b = FF(direct_output_offset + 1), .main_pc = FF(pc), .main_rwa = FF(1), .main_rwb = FF(1), + .main_sel_mem_op_a = FF(1), + .main_sel_mem_op_b = FF(1), + .main_sel_resolve_ind_addr_a = FF(static_cast(indirect_output_flag)), .main_w_in_tag = FF(static_cast(AvmMemoryTag::FF)), }); clk++; @@ -3876,10 +3876,10 @@ void AvmTraceBuilder::op_variable_msm(uint8_t indirect, .main_clk = clk, .main_ia = static_cast(result.is_point_at_infinity()), .main_internal_return_ptr = FF(internal_return_ptr), - .main_mem_idx_a = FF(direct_output_offset + 2), - .main_mem_op_a = FF(1), + .main_mem_addr_a = FF(direct_output_offset + 2), .main_pc = FF(pc), .main_rwa = FF(1), + .main_sel_mem_op_a = FF(1), .main_w_in_tag = FF(static_cast(AvmMemoryTag::U8)), }); } @@ -3920,7 +3920,7 @@ uint32_t finalize_bin_trace_lookup_for_testing(std::vector& main_trace, Avm if (clk > (main_trace.size() - 1)) { main_trace.push_back(Row{ .main_clk = FF(clk), - .byte_lookup_bin_sel = FF(1), + .byte_lookup_sel_bin = FF(1), .byte_lookup_table_input_a = a, .byte_lookup_table_input_b = b, .byte_lookup_table_op_id = op_id, @@ -3929,7 +3929,7 @@ uint32_t finalize_bin_trace_lookup_for_testing(std::vector& main_trace, Avm }); } else { main_trace.at(clk).lookup_byte_operations_counts = count; - main_trace.at(clk).byte_lookup_bin_sel = FF(1); + main_trace.at(clk).byte_lookup_sel_bin = FF(1); main_trace.at(clk).byte_lookup_table_op_id = op_id; main_trace.at(clk).byte_lookup_table_input_a = a; main_trace.at(clk).byte_lookup_table_input_b = b; @@ -4070,7 +4070,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c main_trace_size = *trace_size; main_trace.resize(*trace_size, {}); - main_trace.at(*trace_size - 1).main_last = FF(1); + main_trace.at(*trace_size - 1).main_sel_last = FF(1); // Memory trace inclusion @@ -4087,7 +4087,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c auto const& src = mem_trace.at(i); auto& dest = main_trace.at(i); - dest.mem_mem_sel = FF(1); + dest.mem_sel_mem = FF(1); dest.mem_clk = FF(src.m_clk); dest.mem_addr = FF(src.m_addr); dest.mem_space_id = FF(src.m_space_id); @@ -4098,48 +4098,48 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.mem_tag = FF(static_cast(src.m_tag)); dest.mem_tag_err = FF(static_cast(src.m_tag_err)); dest.mem_one_min_inv = src.m_one_min_inv; - dest.mem_sel_mov_a = FF(static_cast(src.m_sel_mov_a)); - dest.mem_sel_mov_b = FF(static_cast(src.m_sel_mov_b)); - dest.mem_sel_cmov = FF(static_cast(src.m_sel_cmov)); + 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.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_op_a = 1; + dest.mem_sel_op_a = 1; break; case AvmMemTraceBuilder::SUB_CLK_LOAD_B: case AvmMemTraceBuilder::SUB_CLK_STORE_B: - dest.mem_op_b = 1; + dest.mem_sel_op_b = 1; break; case AvmMemTraceBuilder::SUB_CLK_LOAD_C: case AvmMemTraceBuilder::SUB_CLK_STORE_C: - dest.mem_op_c = 1; + dest.mem_sel_op_c = 1; break; case AvmMemTraceBuilder::SUB_CLK_LOAD_D: case AvmMemTraceBuilder::SUB_CLK_STORE_D: - dest.mem_op_d = 1; + dest.mem_sel_op_d = 1; break; case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_A: - dest.mem_ind_op_a = 1; + dest.mem_sel_resolve_ind_addr_a = 1; break; case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_B: - dest.mem_ind_op_b = 1; + dest.mem_sel_resolve_ind_addr_b = 1; break; case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_C: - dest.mem_ind_op_c = 1; + dest.mem_sel_resolve_ind_addr_c = 1; break; case AvmMemTraceBuilder::SUB_CLK_IND_LOAD_D: - dest.mem_ind_op_d = 1; + dest.mem_sel_resolve_ind_addr_d = 1; break; default: break; } if (src.m_sel_cmov) { - dest.mem_skip_check_tag = - dest.mem_op_d + dest.mem_op_a * (-dest.mem_sel_mov_a + 1) + dest.mem_op_b * (-dest.mem_sel_mov_b + 1); + 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 (i + 1 < mem_trace_size) { @@ -4155,7 +4155,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c diff = dest_next.mem_glob_addr - dest.mem_glob_addr; dest.mem_lastAccess = FF(1); } - dest.mem_rng_chk_sel = FF(1); + dest.mem_sel_rng_chk = FF(1); // Decomposition of diff auto const diff_64 = uint64_t(diff); @@ -4192,8 +4192,8 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.alu_op_lte = FF(static_cast(src.alu_op_lte)); dest.alu_op_cast = FF(static_cast(src.alu_op_cast)); dest.alu_op_cast_prev = FF(static_cast(src.alu_op_cast_prev)); - dest.alu_cmp_sel = FF(static_cast(src.alu_op_lt) + static_cast(src.alu_op_lte)); - dest.alu_rng_chk_sel = FF(static_cast(src.rng_chk_sel)); + dest.alu_sel_cmp = FF(static_cast(src.alu_op_lt) + static_cast(src.alu_op_lte)); + dest.alu_sel_rng_chk = FF(static_cast(src.rng_chk_sel)); dest.alu_op_shr = FF(static_cast(src.alu_op_shr)); dest.alu_op_shl = FF(static_cast(src.alu_op_shl)); dest.alu_op_div = FF(static_cast(src.alu_op_div)); @@ -4233,7 +4233,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.alu_u16_r13 = FF(src.alu_u16_reg.at(13)); dest.alu_u16_r14 = FF(src.alu_u16_reg.at(14)); - dest.alu_div_rng_chk_selector = FF(static_cast(src.div_u64_range_chk_sel)); + dest.alu_sel_div_rng_chk = FF(static_cast(src.div_u64_range_chk_sel)); dest.alu_div_u16_r0 = FF(src.div_u64_range_chk.at(0)); dest.alu_div_u16_r1 = FF(src.div_u64_range_chk.at(1)); dest.alu_div_u16_r2 = FF(src.div_u64_range_chk.at(2)); @@ -4247,10 +4247,10 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c // Not all rows in ALU are enabled with a selector. For instance, // multiplication over u128 and cast is taking two lines. if (AvmAluTraceBuilder::is_alu_row_enabled(src)) { - dest.alu_alu_sel = FF(1); + dest.alu_sel_alu = FF(1); } - if (dest.alu_cmp_sel == FF(1) || dest.alu_rng_chk_sel == FF(1)) { + if (dest.alu_sel_cmp == FF(1) || dest.alu_sel_rng_chk == FF(1)) { dest.alu_a_lo = FF(src.hi_lo_limbs.at(0)); dest.alu_a_hi = FF(src.hi_lo_limbs.at(1)); dest.alu_b_lo = FF(src.hi_lo_limbs.at(2)); @@ -4265,12 +4265,12 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.alu_p_b_borrow = FF(static_cast(src.p_b_borrow)); dest.alu_borrow = FF(static_cast(src.borrow)); dest.alu_cmp_rng_ctr = FF(static_cast(src.cmp_rng_ctr)); - dest.alu_rng_chk_lookup_selector = FF(1); + dest.alu_sel_rng_chk_lookup = FF(1); } if (dest.alu_op_div == FF(1)) { dest.alu_op_div_std = uint256_t(src.alu_ia) >= uint256_t(src.alu_ib); dest.alu_op_div_a_lt_b = uint256_t(src.alu_ia) < uint256_t(src.alu_ib); - dest.alu_rng_chk_lookup_selector = FF(1); + dest.alu_sel_rng_chk_lookup = FF(1); dest.alu_a_lo = FF(src.hi_lo_limbs.at(0)); dest.alu_a_hi = FF(src.hi_lo_limbs.at(1)); dest.alu_b_lo = FF(src.hi_lo_limbs.at(2)); @@ -4287,7 +4287,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c } if (dest.alu_op_add == FF(1) || dest.alu_op_sub == FF(1) || dest.alu_op_mul == FF(1)) { - dest.alu_rng_chk_lookup_selector = FF(1); + dest.alu_sel_rng_chk_lookup = FF(1); } if (dest.alu_op_cast == FF(1)) { @@ -4296,30 +4296,30 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.alu_p_sub_a_lo = FF(src.hi_lo_limbs.at(2)); dest.alu_p_sub_a_hi = FF(src.hi_lo_limbs.at(3)); dest.alu_p_a_borrow = FF(static_cast(src.p_a_borrow)); - dest.alu_rng_chk_lookup_selector = FF(1); + dest.alu_sel_rng_chk_lookup = FF(1); } if (dest.alu_op_cast_prev == FF(1)) { dest.alu_a_lo = FF(src.hi_lo_limbs.at(0)); dest.alu_a_hi = FF(src.hi_lo_limbs.at(1)); - dest.alu_rng_chk_lookup_selector = FF(1); + dest.alu_sel_rng_chk_lookup = FF(1); } // Multiplication over u128 expands over two rows. if (dest.alu_op_mul == FF(1) && dest.alu_u128_tag) { - main_trace.at(i + 1).alu_rng_chk_lookup_selector = FF(1); + main_trace.at(i + 1).alu_sel_rng_chk_lookup = FF(1); } if (src.alu_op_shr || src.alu_op_shl) { dest.alu_a_lo = FF(src.hi_lo_limbs[0]); dest.alu_a_hi = FF(src.hi_lo_limbs[1]); dest.alu_b_lo = FF(src.hi_lo_limbs[2]); dest.alu_b_hi = FF(src.hi_lo_limbs[3]); - dest.alu_shift_sel = FF(1); + dest.alu_sel_shift_which = FF(1); dest.alu_shift_lt_bit_len = FF(static_cast(src.shift_lt_bit_len)); dest.alu_t_sub_s_bits = FF(src.mem_tag_sub_shift); dest.alu_two_pow_s = FF(uint256_t(1) << dest.alu_ib); dest.alu_two_pow_t_sub_s = FF(uint256_t(1) << uint256_t(dest.alu_t_sub_s_bits)); - dest.alu_rng_chk_lookup_selector = FF(1); + dest.alu_sel_rng_chk_lookup = FF(1); } } @@ -4327,7 +4327,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c for (size_t i = 0; i < conv_trace_size; i++) { auto const& src = conv_trace.at(i); auto& dest = main_trace.at(i); - dest.conversion_to_radix_le_sel = FF(static_cast(src.to_radix_le_sel)); + dest.conversion_sel_to_radix_le = FF(static_cast(src.to_radix_le_sel)); dest.conversion_clk = FF(src.conversion_clk); dest.conversion_input = src.input; dest.conversion_radix = FF(src.radix); @@ -4342,7 +4342,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.sha256_input = src.input[0]; // TODO: This will need to be enabled later // dest.sha256_output = src.output[0]; - dest.sha256_sha256_compression_sel = FF(1); + dest.sha256_sel_sha256_compression = FF(1); dest.sha256_state = src.state[0]; } @@ -4354,7 +4354,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.poseidon2_input = src.input[0]; // TODO: This will need to be enabled later // dest.poseidon2_output = src.output[0]; - dest.poseidon2_poseidon_perm_sel = FF(1); + dest.poseidon2_sel_poseidon_perm = FF(1); } // Add KeccakF1600 Gadget table @@ -4365,7 +4365,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c dest.keccakf1600_input = FF(src.input[0]); // TODO: This will need to be enabled later // dest.keccakf1600_output = src.output[0]; - dest.keccakf1600_keccakf1600_sel = FF(1); + dest.keccakf1600_sel_keccakf1600 = FF(1); } // Add Pedersen Gadget table @@ -4374,7 +4374,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c auto& dest = main_trace.at(i); dest.pedersen_clk = FF(src.clk); dest.pedersen_input = FF(src.input[0]); - dest.pedersen_pedersen_sel = FF(1); + dest.pedersen_sel_pedersen = FF(1); } // Add Binary Trace table @@ -4382,7 +4382,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c auto const& src = bin_trace.at(i); auto& dest = main_trace.at(i); dest.binary_clk = src.binary_clk; - dest.binary_bin_sel = static_cast(src.bin_sel); + dest.binary_sel_bin = static_cast(src.bin_sel); dest.binary_acc_ia = src.acc_ia; dest.binary_acc_ib = src.acc_ib; dest.binary_acc_ic = src.acc_ic; @@ -4411,7 +4411,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c // Derive a unique row index given op_id, a, and b. auto main_trace_index = (op_id << 16) + (input_a << 8) + b; - main_trace.at(main_trace_index).byte_lookup_bin_sel = FF(1); + main_trace.at(main_trace_index).byte_lookup_sel_bin = FF(1); main_trace.at(main_trace_index).byte_lookup_table_op_id = op_id; main_trace.at(main_trace_index).byte_lookup_table_input_a = a; main_trace.at(main_trace_index).byte_lookup_table_input_b = b; @@ -4434,7 +4434,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c for (uint8_t avm_in_tag = 0; avm_in_tag < 5; avm_in_tag++) { // The +1 here is because the instruction tags we care about (i.e excl U0 and FF) has the range // [1,5] - main_trace.at(avm_in_tag).byte_lookup_bin_sel = FF(1); + main_trace.at(avm_in_tag).byte_lookup_sel_bin = FF(1); main_trace.at(avm_in_tag).byte_lookup_table_in_tags = avm_in_tag + 1; main_trace.at(avm_in_tag).byte_lookup_table_byte_lengths = static_cast(pow(2, avm_in_tag)); main_trace.at(avm_in_tag).lookup_byte_lengths_counts = @@ -4486,8 +4486,8 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c // Write each of the relevant gas accounting values dest.main_opcode_val = static_cast(gas_entry.opcode); - dest.main_l2_gas_op = gas_entry.l2_gas_cost; - dest.main_da_gas_op = gas_entry.da_gas_cost; + dest.main_l2_gas_op_cost = gas_entry.l2_gas_cost; + dest.main_da_gas_op_cost = gas_entry.da_gas_cost; // If gas remaining is increasing, it means we underflowed in uint32_t bool l2_out_of_gas = current_l2_gas_remaining < gas_entry.remaining_l2_gas; @@ -4503,7 +4503,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c // TODO: gas is not constrained for external call at this time if (gas_entry.opcode != OpCode::CALL) { - dest.main_gas_cost_active = FF(1); + dest.main_sel_gas_accounting_active = FF(1); // lookups counting rem_gas_rng_check_counts[L2_HI_GAS_COUNTS_IDX][static_cast(dest.main_abs_l2_rem_gas_hi)]++; @@ -4535,7 +4535,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c /////////// END OF GAS ACCOUNTING ////////////////////////// // Adding extra row for the shifted values at the top of the execution trace. - Row first_row = Row{ .main_first = FF(1), .mem_lastAccess = FF(1) }; + Row first_row = Row{ .main_sel_first = FF(1), .mem_lastAccess = FF(1) }; main_trace.insert(main_trace.begin(), first_row); auto const old_trace_size = main_trace.size(); @@ -4555,10 +4555,10 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c r.main_sel_op_lte == FF(1) || r.main_sel_op_cast == FF(1) || r.main_sel_op_shr == FF(1) || r.main_sel_op_shl == FF(1) || r.main_sel_op_div == FF(1)) && r.main_tag_err == FF(0) && r.main_op_err == FF(0)) { - r.main_alu_sel = FF(1); + r.main_sel_alu = FF(1); } - if (r.main_sel_internal_call == FF(1) || r.main_sel_internal_return == FF(1)) { + if (r.main_sel_op_internal_call == FF(1) || r.main_sel_op_internal_return == FF(1)) { r.main_space_id = INTERNAL_CALL_SPACE_ID; } else { r.main_space_id = r.main_call_ptr; @@ -4671,8 +4671,8 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c // Lookup values curr.kernel_kernel_in_offset = src.kernel_in_offset; curr.kernel_kernel_out_offset = src.kernel_out_offset; - curr.main_q_kernel_lookup = static_cast(src.q_kernel_lookup); - curr.main_q_kernel_output_lookup = static_cast(src.q_kernel_output_lookup); + curr.main_sel_q_kernel_lookup = static_cast(src.q_kernel_lookup); + curr.main_sel_q_kernel_output_lookup = static_cast(src.q_kernel_output_lookup); // Operation selectors curr.main_sel_op_note_hash_exists = static_cast(src.op_note_hash_exists); @@ -4800,7 +4800,7 @@ std::vector AvmTraceBuilder::finalize(uint32_t min_trace_size, bool range_c for (auto const& [opcode, gas_entry] : GAS_COST_TABLE) { auto& dest = main_trace.at(static_cast(opcode)); - dest.gas_gas_cost_sel = FF(1); + dest.gas_sel_gas_cost = FF(1); dest.gas_l2_gas_fixed_table = gas_entry.l2_fixed_gas_cost; dest.gas_da_gas_fixed_table = gas_entry.da_fixed_gas_cost; } diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.cpp index cb189e1750b..fe65a655a2a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.cpp @@ -1,13 +1,7 @@ - #include "barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.hpp" namespace bb::avm_trace { -AvmConversionTraceBuilder::AvmConversionTraceBuilder() -{ - conversion_trace.reserve(AVM_TRACE_SIZE); -} - std::vector AvmConversionTraceBuilder::finalize() { return std::move(conversion_trace); @@ -40,7 +34,7 @@ std::vector AvmConversionTraceBuilder::op_to_radix_le(FF const& a, auto a_uint256 = uint256_t(a); auto radix_uint256 = uint256_t(radix); - std::vector bytes{}; + std::vector bytes; for (uint32_t i = 0; i < num_limbs; i++) { bytes.emplace_back(static_cast(a_uint256 % radix_uint256)); a_uint256 /= radix_uint256; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.hpp index 1cdce6502d7..e45d069ec2a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_conversion_trace.hpp @@ -20,7 +20,7 @@ class AvmConversionTraceBuilder { std::vector limbs; }; - AvmConversionTraceBuilder(); + AvmConversionTraceBuilder() = default; void reset(); // Finalize the trace std::vector finalize(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.cpp index 494da13d192..88cfccd42af 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.cpp @@ -2,12 +2,8 @@ #include "barretenberg/vm/avm_trace/avm_common.hpp" namespace bb::avm_trace { -using element = grumpkin::g1::affine_element; -AvmEccTraceBuilder::AvmEccTraceBuilder() -{ - ecc_trace.reserve(AVM_TRACE_SIZE); -} +using element = grumpkin::g1::affine_element; std::vector AvmEccTraceBuilder::finalize() { diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.hpp index 71f070c85a3..e3b4599dbc2 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_ecc.hpp @@ -5,6 +5,7 @@ #include "barretenberg/vm/avm_trace/avm_common.hpp" namespace bb::avm_trace { + class AvmEccTraceBuilder { public: struct EccTraceEntry { @@ -14,7 +15,7 @@ class AvmEccTraceBuilder { std::tuple result = { FF(0), FF(0), true }; }; - AvmEccTraceBuilder(); + AvmEccTraceBuilder() = default; void reset(); // Finalize the trace std::vector finalize(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.cpp index 6a6230b417a..c3048ca0c93 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.cpp @@ -7,11 +7,6 @@ namespace bb::avm_trace { -AvmKeccakTraceBuilder::AvmKeccakTraceBuilder() -{ - keccak_trace.reserve(AVM_TRACE_SIZE); -} - std::vector AvmKeccakTraceBuilder::finalize() { return std::move(keccak_trace); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.hpp index 341c728c9aa..fb21c3495de 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_keccak.hpp @@ -18,7 +18,7 @@ class AvmKeccakTraceBuilder { uint32_t output_size = 0; }; - AvmKeccakTraceBuilder(); + AvmKeccakTraceBuilder() = default; void reset(); // Finalize the trace std::vector finalize(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.cpp index 81c0200db7b..d4321b9f8cc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.cpp @@ -4,11 +4,6 @@ namespace bb::avm_trace { -AvmPedersenTraceBuilder::AvmPedersenTraceBuilder() -{ - pedersen_trace.reserve(AVM_TRACE_SIZE); -} - std::vector AvmPedersenTraceBuilder::finalize() { return std::move(pedersen_trace); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.hpp index 609e47f47ec..4ca459127e5 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_pedersen.hpp @@ -15,7 +15,7 @@ class AvmPedersenTraceBuilder { FF output; }; - AvmPedersenTraceBuilder(); + AvmPedersenTraceBuilder() = default; void reset(); // Finalize the trace std::vector finalize(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.cpp index 430fcec84cb..e61ce5810c4 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.cpp @@ -4,11 +4,6 @@ namespace bb::avm_trace { -AvmPoseidon2TraceBuilder::AvmPoseidon2TraceBuilder() -{ - poseidon2_trace.reserve(AVM_TRACE_SIZE); -} - std::vector AvmPoseidon2TraceBuilder::finalize() { return std::move(poseidon2_trace); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.hpp index 19248058ca4..1db074b658a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_poseidon2.hpp @@ -7,6 +7,7 @@ #include namespace bb::avm_trace { + class AvmPoseidon2TraceBuilder { public: struct Poseidon2TraceEntry { @@ -15,7 +16,7 @@ class AvmPoseidon2TraceBuilder { std::array output; }; - AvmPoseidon2TraceBuilder(); + AvmPoseidon2TraceBuilder() = default; void reset(); // Finalize the trace std::vector finalize(); @@ -25,4 +26,5 @@ class AvmPoseidon2TraceBuilder { private: std::vector poseidon2_trace; }; + } // namespace bb::avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.cpp index a877aea1019..f431c271866 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.cpp @@ -11,11 +11,6 @@ namespace bb::avm_trace { -AvmSha256TraceBuilder::AvmSha256TraceBuilder() -{ - sha256_trace.reserve(AVM_TRACE_SIZE); -} - std::vector AvmSha256TraceBuilder::finalize() { return std::move(sha256_trace); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.hpp index 26bd9173503..672ad98c770 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/gadgets/avm_sha256.hpp @@ -7,6 +7,7 @@ #include namespace bb::avm_trace { + class AvmSha256TraceBuilder { public: struct Sha256TraceEntry { @@ -16,7 +17,7 @@ class AvmSha256TraceBuilder { std::array output{}; }; - AvmSha256TraceBuilder(); + AvmSha256TraceBuilder() = default; void reset(); // Finalize the trace std::vector finalize(); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp index fc2f8b5a3a5..a0db02764b3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.cpp @@ -19,18 +19,15 @@ template std::string field_to_string(const FF& ff) template std::vector AvmFullRow::names() { return { "main_clk", - "main_first", + "main_sel_first", "alu_a_hi", "alu_a_lo", - "alu_alu_sel", "alu_b_hi", "alu_b_lo", "alu_borrow", "alu_cf", "alu_clk", "alu_cmp_rng_ctr", - "alu_cmp_sel", - "alu_div_rng_chk_selector", "alu_div_u16_r0", "alu_div_u16_r1", "alu_div_u16_r2", @@ -74,10 +71,13 @@ template std::vector AvmFullRow::names() "alu_remainder", "alu_res_hi", "alu_res_lo", - "alu_rng_chk_lookup_selector", - "alu_rng_chk_sel", + "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_shift_sel", "alu_t_sub_s_bits", "alu_two_pow_s", "alu_two_pow_t_sub_s", @@ -106,7 +106,6 @@ template std::vector AvmFullRow::names() "binary_acc_ia", "binary_acc_ib", "binary_acc_ic", - "binary_bin_sel", "binary_clk", "binary_ia_bytes", "binary_ib_bytes", @@ -115,8 +114,9 @@ template std::vector AvmFullRow::names() "binary_mem_tag_ctr", "binary_mem_tag_ctr_inv", "binary_op_id", + "binary_sel_bin", "binary_start", - "byte_lookup_bin_sel", + "byte_lookup_sel_bin", "byte_lookup_table_byte_lengths", "byte_lookup_table_in_tags", "byte_lookup_table_input_a", @@ -127,14 +127,14 @@ template std::vector AvmFullRow::names() "conversion_input", "conversion_num_limbs", "conversion_radix", - "conversion_to_radix_le_sel", + "conversion_sel_to_radix_le", "gas_da_gas_fixed_table", - "gas_gas_cost_sel", "gas_l2_gas_fixed_table", + "gas_sel_gas_cost", "keccakf1600_clk", "keccakf1600_input", - "keccakf1600_keccakf1600_sel", "keccakf1600_output", + "keccakf1600_sel_keccakf1600", "kernel_emit_l2_to_l1_msg_write_offset", "kernel_emit_note_hash_write_offset", "kernel_emit_nullifier_write_offset", @@ -159,68 +159,55 @@ template std::vector AvmFullRow::names() "main_abs_l2_rem_gas_hi", "main_abs_l2_rem_gas_lo", "main_alu_in_tag", - "main_alu_sel", "main_bin_op_id", - "main_bin_sel", "main_call_ptr", - "main_da_gas_op", + "main_da_gas_op_cost", "main_da_gas_remaining", "main_da_out_of_gas", - "main_gas_cost_active", "main_ia", "main_ib", "main_ic", "main_id", "main_id_zero", - "main_ind_a", - "main_ind_b", - "main_ind_c", - "main_ind_d", - "main_ind_op_a", - "main_ind_op_b", - "main_ind_op_c", - "main_ind_op_d", + "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", + "main_l2_gas_op_cost", "main_l2_gas_remaining", "main_l2_out_of_gas", - "main_last", - "main_mem_idx_a", - "main_mem_idx_b", - "main_mem_idx_c", - "main_mem_idx_d", - "main_mem_op_a", - "main_mem_op_activate_gas", - "main_mem_op_b", - "main_mem_op_c", - "main_mem_op_d", + "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_q_kernel_lookup", - "main_q_kernel_output_lookup", "main_r_in_tag", "main_rwa", "main_rwb", "main_rwc", "main_rwd", - "main_sel_cmov", - "main_sel_external_call", - "main_sel_halt", - "main_sel_internal_call", - "main_sel_internal_return", - "main_sel_jump", - "main_sel_jumpi", - "main_sel_mov", - "main_sel_mov_a", - "main_sel_mov_b", + "main_sel_alu", + "main_sel_bin", + "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_cast", "main_sel_op_chain_id", + "main_sel_op_cmov", "main_sel_op_coinbase", "main_sel_op_dagasleft", "main_sel_op_div", @@ -229,15 +216,22 @@ template std::vector AvmFullRow::names() "main_sel_op_emit_nullifier", "main_sel_op_emit_unencrypted_log", "main_sel_op_eq", + "main_sel_op_external_call", "main_sel_op_fdiv", "main_sel_op_fee_per_da_gas", "main_sel_op_fee_per_l2_gas", "main_sel_op_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", @@ -258,6 +252,12 @@ template std::vector AvmFullRow::names() "main_sel_op_transaction_fee", "main_sel_op_version", "main_sel_op_xor", + "main_sel_q_kernel_lookup", + "main_sel_q_kernel_output_lookup", + "main_sel_resolve_ind_addr_a", + "main_sel_resolve_ind_addr_b", + "main_sel_resolve_ind_addr_c", + "main_sel_resolve_ind_addr_d", "main_sel_rng_16", "main_sel_rng_8", "main_space_id", @@ -270,24 +270,24 @@ template std::vector AvmFullRow::names() "mem_diff_lo", "mem_diff_mid", "mem_glob_addr", - "mem_ind_op_a", - "mem_ind_op_b", - "mem_ind_op_c", - "mem_ind_op_d", "mem_last", "mem_lastAccess", - "mem_mem_sel", "mem_one_min_inv", - "mem_op_a", - "mem_op_b", - "mem_op_c", - "mem_op_d", "mem_r_in_tag", - "mem_rng_chk_sel", "mem_rw", - "mem_sel_cmov", - "mem_sel_mov_a", - "mem_sel_mov_b", + "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_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", @@ -298,15 +298,15 @@ template std::vector AvmFullRow::names() "pedersen_clk", "pedersen_input", "pedersen_output", - "pedersen_pedersen_sel", + "pedersen_sel_pedersen", "poseidon2_clk", "poseidon2_input", "poseidon2_output", - "poseidon2_poseidon_perm_sel", + "poseidon2_sel_poseidon_perm", "sha256_clk", "sha256_input", "sha256_output", - "sha256_sha256_compression_sel", + "sha256_sel_sha256_compression", "sha256_state", "perm_main_alu", "perm_main_bin", @@ -317,10 +317,10 @@ template std::vector AvmFullRow::names() "perm_main_mem_b", "perm_main_mem_c", "perm_main_mem_d", - "perm_main_mem_ind_a", - "perm_main_mem_ind_b", - "perm_main_mem_ind_c", - "perm_main_mem_ind_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_opcode_gas", @@ -409,20 +409,19 @@ template std::vector AvmFullRow::names() template std::ostream& operator<<(std::ostream& os, AvmFullRow const& row) { return os - << field_to_string(row.main_clk) << "," << field_to_string(row.main_first) << "," + << field_to_string(row.main_clk) << "," << field_to_string(row.main_sel_first) << "," << field_to_string(row.alu_a_hi) << "," << field_to_string(row.alu_a_lo) << "," - << field_to_string(row.alu_alu_sel) << "," << 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_cmp_sel) << "," - << field_to_string(row.alu_div_rng_chk_selector) << "," << 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_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) << "," @@ -436,38 +435,40 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << 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_rng_chk_lookup_selector) << "," - << field_to_string(row.alu_rng_chk_sel) << "," << field_to_string(row.alu_shift_lt_bit_len) << "," - << field_to_string(row.alu_shift_sel) << "," << 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_bin_sel) << "," + << 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_start) << "," << field_to_string(row.byte_lookup_bin_sel) << "," - << 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_to_radix_le_sel) << "," << field_to_string(row.gas_da_gas_fixed_table) - << "," << field_to_string(row.gas_gas_cost_sel) << "," << field_to_string(row.gas_l2_gas_fixed_table) << "," - << field_to_string(row.keccakf1600_clk) << "," << field_to_string(row.keccakf1600_input) << "," - << field_to_string(row.keccakf1600_keccakf1600_sel) << "," << field_to_string(row.keccakf1600_output) << "," + << 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) << "," @@ -486,47 +487,45 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << "," << 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_alu_sel) << "," - << field_to_string(row.main_bin_op_id) << "," << field_to_string(row.main_bin_sel) << "," - << field_to_string(row.main_call_ptr) << "," << field_to_string(row.main_da_gas_op) << "," + << 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_gas_cost_active) << "," << 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_a) << "," - << field_to_string(row.main_ind_b) << "," << field_to_string(row.main_ind_c) << "," - << field_to_string(row.main_ind_d) << "," << field_to_string(row.main_ind_op_a) << "," - << field_to_string(row.main_ind_op_b) << "," << field_to_string(row.main_ind_op_c) << "," - << field_to_string(row.main_ind_op_d) << "," << field_to_string(row.main_internal_return_ptr) << "," - << field_to_string(row.main_inv) << "," << field_to_string(row.main_l2_gas_op) << "," - << field_to_string(row.main_l2_gas_remaining) << "," << field_to_string(row.main_l2_out_of_gas) << "," - << field_to_string(row.main_last) << "," << field_to_string(row.main_mem_idx_a) << "," - << field_to_string(row.main_mem_idx_b) << "," << field_to_string(row.main_mem_idx_c) << "," - << field_to_string(row.main_mem_idx_d) << "," << field_to_string(row.main_mem_op_a) << "," - << field_to_string(row.main_mem_op_activate_gas) << "," << field_to_string(row.main_mem_op_b) << "," - << field_to_string(row.main_mem_op_c) << "," << field_to_string(row.main_mem_op_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_q_kernel_lookup) << "," - << field_to_string(row.main_q_kernel_output_lookup) << "," << 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_cmov) << "," << field_to_string(row.main_sel_external_call) << "," - << field_to_string(row.main_sel_halt) << "," << field_to_string(row.main_sel_internal_call) << "," - << field_to_string(row.main_sel_internal_return) << "," << field_to_string(row.main_sel_jump) << "," - << field_to_string(row.main_sel_jumpi) << "," << field_to_string(row.main_sel_mov) << "," - << field_to_string(row.main_sel_mov_a) << "," << field_to_string(row.main_sel_mov_b) << "," + << 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_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_cast) << "," << field_to_string(row.main_sel_op_chain_id) << "," - << 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_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_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_get_contract_instance) << "," << 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_mul) << "," + << "," << field_to_string(row.main_sel_op_external_call) << "," << field_to_string(row.main_sel_op_fdiv) + << "," << field_to_string(row.main_sel_op_fee_per_da_gas) << "," + << field_to_string(row.main_sel_op_fee_per_l2_gas) << "," + << field_to_string(row.main_sel_op_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) << "," @@ -536,59 +535,65 @@ template std::ostream& operator<<(std::ostream& os, AvmFullRow << 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_rng_16) << "," + << field_to_string(row.main_sel_op_xor) << "," << field_to_string(row.main_sel_q_kernel_lookup) << "," + << field_to_string(row.main_sel_q_kernel_output_lookup) << "," + << field_to_string(row.main_sel_resolve_ind_addr_a) << "," + << field_to_string(row.main_sel_resolve_ind_addr_b) << "," + << field_to_string(row.main_sel_resolve_ind_addr_c) << "," + << field_to_string(row.main_sel_resolve_ind_addr_d) << "," << field_to_string(row.main_sel_rng_16) << "," << field_to_string(row.main_sel_rng_8) << "," << field_to_string(row.main_space_id) << "," << field_to_string(row.main_table_pow_2) << "," << 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_ind_op_a) << "," - << field_to_string(row.mem_ind_op_b) << "," << field_to_string(row.mem_ind_op_c) << "," - << field_to_string(row.mem_ind_op_d) << "," << field_to_string(row.mem_last) << "," - << field_to_string(row.mem_lastAccess) << "," << field_to_string(row.mem_mem_sel) << "," - << field_to_string(row.mem_one_min_inv) << "," << field_to_string(row.mem_op_a) << "," - << field_to_string(row.mem_op_b) << "," << field_to_string(row.mem_op_c) << "," - << field_to_string(row.mem_op_d) << "," << field_to_string(row.mem_r_in_tag) << "," - << field_to_string(row.mem_rng_chk_sel) << "," << field_to_string(row.mem_rw) << "," - << field_to_string(row.mem_sel_cmov) << "," << field_to_string(row.mem_sel_mov_a) << "," - << field_to_string(row.mem_sel_mov_b) << "," << 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_pedersen_sel) << "," - << field_to_string(row.poseidon2_clk) << "," << field_to_string(row.poseidon2_input) << "," - << field_to_string(row.poseidon2_output) << "," << field_to_string(row.poseidon2_poseidon_perm_sel) << "," - << field_to_string(row.sha256_clk) << "," << field_to_string(row.sha256_input) << "," - << field_to_string(row.sha256_output) << "," << field_to_string(row.sha256_sha256_compression_sel) << "," - << field_to_string(row.sha256_state) << "," << 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_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_a) << "," << field_to_string(row.perm_main_mem_ind_b) << "," - << field_to_string(row.perm_main_mem_ind_c) << "," << field_to_string(row.perm_main_mem_ind_d) << "," - << field_to_string(row.lookup_byte_lengths) << "," << field_to_string(row.lookup_byte_operations) << "," - << 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.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_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.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.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_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_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_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_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 3cb0b1f7c38..83e3cd74b16 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -68,10 +68,10 @@ #include "barretenberg/relations/generated/avm/perm_main_mem_b.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_c.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_d.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_a.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_b.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_c.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_d.hpp" +#include "barretenberg/relations/generated/avm/perm_main_mem_ind_addr_a.hpp" +#include "barretenberg/relations/generated/avm/perm_main_mem_ind_addr_b.hpp" +#include "barretenberg/relations/generated/avm/perm_main_mem_ind_addr_c.hpp" +#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/poseidon2.hpp" @@ -86,18 +86,15 @@ namespace bb { template struct AvmFullRow { FF main_clk{}; - FF main_first{}; + FF main_sel_first{}; FF alu_a_hi{}; FF alu_a_lo{}; - FF alu_alu_sel{}; FF alu_b_hi{}; FF alu_b_lo{}; FF alu_borrow{}; FF alu_cf{}; FF alu_clk{}; FF alu_cmp_rng_ctr{}; - FF alu_cmp_sel{}; - FF alu_div_rng_chk_selector{}; FF alu_div_u16_r0{}; FF alu_div_u16_r1{}; FF alu_div_u16_r2{}; @@ -141,10 +138,13 @@ template struct AvmFullRow { FF alu_remainder{}; FF alu_res_hi{}; FF alu_res_lo{}; - FF alu_rng_chk_lookup_selector{}; - FF alu_rng_chk_sel{}; + FF alu_sel_alu{}; + FF alu_sel_cmp{}; + FF alu_sel_div_rng_chk{}; + FF alu_sel_rng_chk{}; + FF alu_sel_rng_chk_lookup{}; + FF alu_sel_shift_which{}; FF alu_shift_lt_bit_len{}; - FF alu_shift_sel{}; FF alu_t_sub_s_bits{}; FF alu_two_pow_s{}; FF alu_two_pow_t_sub_s{}; @@ -173,7 +173,6 @@ template struct AvmFullRow { FF binary_acc_ia{}; FF binary_acc_ib{}; FF binary_acc_ic{}; - FF binary_bin_sel{}; FF binary_clk{}; FF binary_ia_bytes{}; FF binary_ib_bytes{}; @@ -182,8 +181,9 @@ template struct AvmFullRow { FF binary_mem_tag_ctr{}; FF binary_mem_tag_ctr_inv{}; FF binary_op_id{}; + FF binary_sel_bin{}; FF binary_start{}; - FF byte_lookup_bin_sel{}; + FF byte_lookup_sel_bin{}; FF byte_lookup_table_byte_lengths{}; FF byte_lookup_table_in_tags{}; FF byte_lookup_table_input_a{}; @@ -194,14 +194,14 @@ template struct AvmFullRow { FF conversion_input{}; FF conversion_num_limbs{}; FF conversion_radix{}; - FF conversion_to_radix_le_sel{}; + FF conversion_sel_to_radix_le{}; FF gas_da_gas_fixed_table{}; - FF gas_gas_cost_sel{}; FF gas_l2_gas_fixed_table{}; + FF gas_sel_gas_cost{}; FF keccakf1600_clk{}; FF keccakf1600_input{}; - FF keccakf1600_keccakf1600_sel{}; FF keccakf1600_output{}; + FF keccakf1600_sel_keccakf1600{}; FF kernel_emit_l2_to_l1_msg_write_offset{}; FF kernel_emit_note_hash_write_offset{}; FF kernel_emit_nullifier_write_offset{}; @@ -226,68 +226,55 @@ template struct AvmFullRow { FF main_abs_l2_rem_gas_hi{}; FF main_abs_l2_rem_gas_lo{}; FF main_alu_in_tag{}; - FF main_alu_sel{}; FF main_bin_op_id{}; - FF main_bin_sel{}; FF main_call_ptr{}; - FF main_da_gas_op{}; + FF main_da_gas_op_cost{}; FF main_da_gas_remaining{}; FF main_da_out_of_gas{}; - FF main_gas_cost_active{}; FF main_ia{}; FF main_ib{}; FF main_ic{}; FF main_id{}; FF main_id_zero{}; - FF main_ind_a{}; - FF main_ind_b{}; - FF main_ind_c{}; - FF main_ind_d{}; - FF main_ind_op_a{}; - FF main_ind_op_b{}; - FF main_ind_op_c{}; - FF main_ind_op_d{}; + FF main_ind_addr_a{}; + FF main_ind_addr_b{}; + FF main_ind_addr_c{}; + FF main_ind_addr_d{}; FF main_internal_return_ptr{}; FF main_inv{}; - FF main_l2_gas_op{}; + FF main_l2_gas_op_cost{}; FF main_l2_gas_remaining{}; FF main_l2_out_of_gas{}; - FF main_last{}; - FF main_mem_idx_a{}; - FF main_mem_idx_b{}; - FF main_mem_idx_c{}; - FF main_mem_idx_d{}; - FF main_mem_op_a{}; - FF main_mem_op_activate_gas{}; - FF main_mem_op_b{}; - FF main_mem_op_c{}; - FF main_mem_op_d{}; + FF main_mem_addr_a{}; + FF main_mem_addr_b{}; + FF main_mem_addr_c{}; + FF main_mem_addr_d{}; FF main_op_err{}; FF main_opcode_val{}; FF main_pc{}; - FF main_q_kernel_lookup{}; - FF main_q_kernel_output_lookup{}; FF main_r_in_tag{}; FF main_rwa{}; FF main_rwb{}; FF main_rwc{}; FF main_rwd{}; - FF main_sel_cmov{}; - FF main_sel_external_call{}; - FF main_sel_halt{}; - FF main_sel_internal_call{}; - FF main_sel_internal_return{}; - FF main_sel_jump{}; - FF main_sel_jumpi{}; - FF main_sel_mov{}; - FF main_sel_mov_a{}; - FF main_sel_mov_b{}; + FF main_sel_alu{}; + FF main_sel_bin{}; + FF main_sel_gas_accounting_active{}; + FF main_sel_last{}; + FF main_sel_mem_op_a{}; + FF main_sel_mem_op_activate_gas{}; + FF main_sel_mem_op_b{}; + FF main_sel_mem_op_c{}; + FF main_sel_mem_op_d{}; + FF main_sel_mov_ia_to_ic{}; + FF main_sel_mov_ib_to_ic{}; FF main_sel_op_add{}; FF main_sel_op_address{}; FF main_sel_op_and{}; FF main_sel_op_block_number{}; FF main_sel_op_cast{}; FF main_sel_op_chain_id{}; + FF main_sel_op_cmov{}; FF main_sel_op_coinbase{}; FF main_sel_op_dagasleft{}; FF main_sel_op_div{}; @@ -296,15 +283,22 @@ template struct AvmFullRow { FF main_sel_op_emit_nullifier{}; FF main_sel_op_emit_unencrypted_log{}; FF main_sel_op_eq{}; + FF main_sel_op_external_call{}; FF main_sel_op_fdiv{}; FF main_sel_op_fee_per_da_gas{}; FF main_sel_op_fee_per_l2_gas{}; FF main_sel_op_get_contract_instance{}; + FF main_sel_op_halt{}; + FF main_sel_op_internal_call{}; + FF main_sel_op_internal_return{}; + FF main_sel_op_jump{}; + FF main_sel_op_jumpi{}; FF main_sel_op_keccak{}; FF main_sel_op_l1_to_l2_msg_exists{}; FF main_sel_op_l2gasleft{}; FF main_sel_op_lt{}; FF main_sel_op_lte{}; + FF main_sel_op_mov{}; FF main_sel_op_mul{}; FF main_sel_op_not{}; FF main_sel_op_note_hash_exists{}; @@ -325,6 +319,12 @@ template struct AvmFullRow { FF main_sel_op_transaction_fee{}; FF main_sel_op_version{}; FF main_sel_op_xor{}; + FF main_sel_q_kernel_lookup{}; + FF main_sel_q_kernel_output_lookup{}; + FF main_sel_resolve_ind_addr_a{}; + FF main_sel_resolve_ind_addr_b{}; + FF main_sel_resolve_ind_addr_c{}; + FF main_sel_resolve_ind_addr_d{}; FF main_sel_rng_16{}; FF main_sel_rng_8{}; FF main_space_id{}; @@ -337,24 +337,24 @@ template struct AvmFullRow { FF mem_diff_lo{}; FF mem_diff_mid{}; FF mem_glob_addr{}; - FF mem_ind_op_a{}; - FF mem_ind_op_b{}; - FF mem_ind_op_c{}; - FF mem_ind_op_d{}; FF mem_last{}; FF mem_lastAccess{}; - FF mem_mem_sel{}; FF mem_one_min_inv{}; - FF mem_op_a{}; - FF mem_op_b{}; - FF mem_op_c{}; - FF mem_op_d{}; FF mem_r_in_tag{}; - FF mem_rng_chk_sel{}; FF mem_rw{}; - FF mem_sel_cmov{}; - FF mem_sel_mov_a{}; - FF mem_sel_mov_b{}; + FF mem_sel_mem{}; + FF mem_sel_mov_ia_to_ic{}; + FF mem_sel_mov_ib_to_ic{}; + FF mem_sel_op_a{}; + FF mem_sel_op_b{}; + FF mem_sel_op_c{}; + FF mem_sel_op_cmov{}; + FF mem_sel_op_d{}; + FF mem_sel_resolve_ind_addr_a{}; + FF mem_sel_resolve_ind_addr_b{}; + FF mem_sel_resolve_ind_addr_c{}; + FF mem_sel_resolve_ind_addr_d{}; + FF mem_sel_rng_chk{}; FF mem_skip_check_tag{}; FF mem_space_id{}; FF mem_tag{}; @@ -365,15 +365,15 @@ template struct AvmFullRow { FF pedersen_clk{}; FF pedersen_input{}; FF pedersen_output{}; - FF pedersen_pedersen_sel{}; + FF pedersen_sel_pedersen{}; FF poseidon2_clk{}; FF poseidon2_input{}; FF poseidon2_output{}; - FF poseidon2_poseidon_perm_sel{}; + FF poseidon2_sel_poseidon_perm{}; FF sha256_clk{}; FF sha256_input{}; FF sha256_output{}; - FF sha256_sha256_compression_sel{}; + FF sha256_sel_sha256_compression{}; FF sha256_state{}; FF perm_main_alu{}; FF perm_main_bin{}; @@ -384,10 +384,10 @@ template struct AvmFullRow { FF perm_main_mem_b{}; FF perm_main_mem_c{}; FF perm_main_mem_d{}; - FF perm_main_mem_ind_a{}; - FF perm_main_mem_ind_b{}; - FF perm_main_mem_ind_c{}; - FF perm_main_mem_ind_d{}; + FF perm_main_mem_ind_addr_a{}; + FF perm_main_mem_ind_addr_b{}; + FF perm_main_mem_ind_addr_c{}; + FF perm_main_mem_ind_addr_d{}; FF lookup_byte_lengths{}; FF lookup_byte_operations{}; FF lookup_opcode_gas{}; @@ -472,12 +472,9 @@ template struct AvmFullRow { FF lookup_div_u16_7_counts{}; FF alu_a_hi_shift{}; FF alu_a_lo_shift{}; - FF alu_alu_sel_shift{}; FF alu_b_hi_shift{}; FF alu_b_lo_shift{}; FF alu_cmp_rng_ctr_shift{}; - FF alu_cmp_sel_shift{}; - FF alu_div_rng_chk_selector_shift{}; FF alu_div_u16_r0_shift{}; FF alu_div_u16_r1_shift{}; FF alu_div_u16_r2_shift{}; @@ -498,8 +495,11 @@ template struct AvmFullRow { FF alu_p_sub_a_lo_shift{}; FF alu_p_sub_b_hi_shift{}; FF alu_p_sub_b_lo_shift{}; - FF alu_rng_chk_lookup_selector_shift{}; - FF alu_rng_chk_sel_shift{}; + FF alu_sel_alu_shift{}; + FF alu_sel_cmp_shift{}; + FF alu_sel_div_rng_chk_shift{}; + FF alu_sel_rng_chk_lookup_shift{}; + FF alu_sel_rng_chk_shift{}; FF alu_u16_r0_shift{}; FF alu_u16_r1_shift{}; FF alu_u16_r2_shift{}; @@ -530,8 +530,8 @@ template struct AvmFullRow { FF main_l2_gas_remaining_shift{}; FF main_pc_shift{}; FF mem_glob_addr_shift{}; - FF mem_mem_sel_shift{}; FF mem_rw_shift{}; + FF mem_sel_mem_shift{}; FF mem_tag_shift{}; FF mem_tsp_shift{}; FF mem_val_shift{}; @@ -569,18 +569,15 @@ class AvmCircuitBuilder { for (size_t i = 0; i < rows.size(); i++) { polys.main_clk[i] = rows[i].main_clk; - polys.main_first[i] = rows[i].main_first; + polys.main_sel_first[i] = rows[i].main_sel_first; polys.alu_a_hi[i] = rows[i].alu_a_hi; polys.alu_a_lo[i] = rows[i].alu_a_lo; - polys.alu_alu_sel[i] = rows[i].alu_alu_sel; polys.alu_b_hi[i] = rows[i].alu_b_hi; polys.alu_b_lo[i] = rows[i].alu_b_lo; polys.alu_borrow[i] = rows[i].alu_borrow; polys.alu_cf[i] = rows[i].alu_cf; polys.alu_clk[i] = rows[i].alu_clk; polys.alu_cmp_rng_ctr[i] = rows[i].alu_cmp_rng_ctr; - polys.alu_cmp_sel[i] = rows[i].alu_cmp_sel; - polys.alu_div_rng_chk_selector[i] = rows[i].alu_div_rng_chk_selector; polys.alu_div_u16_r0[i] = rows[i].alu_div_u16_r0; polys.alu_div_u16_r1[i] = rows[i].alu_div_u16_r1; polys.alu_div_u16_r2[i] = rows[i].alu_div_u16_r2; @@ -624,10 +621,13 @@ class AvmCircuitBuilder { polys.alu_remainder[i] = rows[i].alu_remainder; polys.alu_res_hi[i] = rows[i].alu_res_hi; polys.alu_res_lo[i] = rows[i].alu_res_lo; - polys.alu_rng_chk_lookup_selector[i] = rows[i].alu_rng_chk_lookup_selector; - polys.alu_rng_chk_sel[i] = rows[i].alu_rng_chk_sel; + polys.alu_sel_alu[i] = rows[i].alu_sel_alu; + polys.alu_sel_cmp[i] = rows[i].alu_sel_cmp; + polys.alu_sel_div_rng_chk[i] = rows[i].alu_sel_div_rng_chk; + polys.alu_sel_rng_chk[i] = rows[i].alu_sel_rng_chk; + polys.alu_sel_rng_chk_lookup[i] = rows[i].alu_sel_rng_chk_lookup; + polys.alu_sel_shift_which[i] = rows[i].alu_sel_shift_which; polys.alu_shift_lt_bit_len[i] = rows[i].alu_shift_lt_bit_len; - polys.alu_shift_sel[i] = rows[i].alu_shift_sel; polys.alu_t_sub_s_bits[i] = rows[i].alu_t_sub_s_bits; polys.alu_two_pow_s[i] = rows[i].alu_two_pow_s; polys.alu_two_pow_t_sub_s[i] = rows[i].alu_two_pow_t_sub_s; @@ -656,7 +656,6 @@ class AvmCircuitBuilder { polys.binary_acc_ia[i] = rows[i].binary_acc_ia; polys.binary_acc_ib[i] = rows[i].binary_acc_ib; polys.binary_acc_ic[i] = rows[i].binary_acc_ic; - polys.binary_bin_sel[i] = rows[i].binary_bin_sel; polys.binary_clk[i] = rows[i].binary_clk; polys.binary_ia_bytes[i] = rows[i].binary_ia_bytes; polys.binary_ib_bytes[i] = rows[i].binary_ib_bytes; @@ -665,8 +664,9 @@ class AvmCircuitBuilder { polys.binary_mem_tag_ctr[i] = rows[i].binary_mem_tag_ctr; polys.binary_mem_tag_ctr_inv[i] = rows[i].binary_mem_tag_ctr_inv; polys.binary_op_id[i] = rows[i].binary_op_id; + polys.binary_sel_bin[i] = rows[i].binary_sel_bin; polys.binary_start[i] = rows[i].binary_start; - polys.byte_lookup_bin_sel[i] = rows[i].byte_lookup_bin_sel; + polys.byte_lookup_sel_bin[i] = rows[i].byte_lookup_sel_bin; polys.byte_lookup_table_byte_lengths[i] = rows[i].byte_lookup_table_byte_lengths; polys.byte_lookup_table_in_tags[i] = rows[i].byte_lookup_table_in_tags; polys.byte_lookup_table_input_a[i] = rows[i].byte_lookup_table_input_a; @@ -677,14 +677,14 @@ class AvmCircuitBuilder { polys.conversion_input[i] = rows[i].conversion_input; polys.conversion_num_limbs[i] = rows[i].conversion_num_limbs; polys.conversion_radix[i] = rows[i].conversion_radix; - polys.conversion_to_radix_le_sel[i] = rows[i].conversion_to_radix_le_sel; + polys.conversion_sel_to_radix_le[i] = rows[i].conversion_sel_to_radix_le; polys.gas_da_gas_fixed_table[i] = rows[i].gas_da_gas_fixed_table; - polys.gas_gas_cost_sel[i] = rows[i].gas_gas_cost_sel; polys.gas_l2_gas_fixed_table[i] = rows[i].gas_l2_gas_fixed_table; + polys.gas_sel_gas_cost[i] = rows[i].gas_sel_gas_cost; polys.keccakf1600_clk[i] = rows[i].keccakf1600_clk; polys.keccakf1600_input[i] = rows[i].keccakf1600_input; - polys.keccakf1600_keccakf1600_sel[i] = rows[i].keccakf1600_keccakf1600_sel; polys.keccakf1600_output[i] = rows[i].keccakf1600_output; + polys.keccakf1600_sel_keccakf1600[i] = rows[i].keccakf1600_sel_keccakf1600; polys.kernel_emit_l2_to_l1_msg_write_offset[i] = rows[i].kernel_emit_l2_to_l1_msg_write_offset; polys.kernel_emit_note_hash_write_offset[i] = rows[i].kernel_emit_note_hash_write_offset; polys.kernel_emit_nullifier_write_offset[i] = rows[i].kernel_emit_nullifier_write_offset; @@ -710,68 +710,55 @@ class AvmCircuitBuilder { polys.main_abs_l2_rem_gas_hi[i] = rows[i].main_abs_l2_rem_gas_hi; polys.main_abs_l2_rem_gas_lo[i] = rows[i].main_abs_l2_rem_gas_lo; polys.main_alu_in_tag[i] = rows[i].main_alu_in_tag; - polys.main_alu_sel[i] = rows[i].main_alu_sel; polys.main_bin_op_id[i] = rows[i].main_bin_op_id; - polys.main_bin_sel[i] = rows[i].main_bin_sel; polys.main_call_ptr[i] = rows[i].main_call_ptr; - polys.main_da_gas_op[i] = rows[i].main_da_gas_op; + polys.main_da_gas_op_cost[i] = rows[i].main_da_gas_op_cost; polys.main_da_gas_remaining[i] = rows[i].main_da_gas_remaining; polys.main_da_out_of_gas[i] = rows[i].main_da_out_of_gas; - polys.main_gas_cost_active[i] = rows[i].main_gas_cost_active; polys.main_ia[i] = rows[i].main_ia; polys.main_ib[i] = rows[i].main_ib; polys.main_ic[i] = rows[i].main_ic; polys.main_id[i] = rows[i].main_id; polys.main_id_zero[i] = rows[i].main_id_zero; - polys.main_ind_a[i] = rows[i].main_ind_a; - polys.main_ind_b[i] = rows[i].main_ind_b; - polys.main_ind_c[i] = rows[i].main_ind_c; - polys.main_ind_d[i] = rows[i].main_ind_d; - polys.main_ind_op_a[i] = rows[i].main_ind_op_a; - polys.main_ind_op_b[i] = rows[i].main_ind_op_b; - polys.main_ind_op_c[i] = rows[i].main_ind_op_c; - polys.main_ind_op_d[i] = rows[i].main_ind_op_d; + polys.main_ind_addr_a[i] = rows[i].main_ind_addr_a; + polys.main_ind_addr_b[i] = rows[i].main_ind_addr_b; + polys.main_ind_addr_c[i] = rows[i].main_ind_addr_c; + polys.main_ind_addr_d[i] = rows[i].main_ind_addr_d; polys.main_internal_return_ptr[i] = rows[i].main_internal_return_ptr; polys.main_inv[i] = rows[i].main_inv; - polys.main_l2_gas_op[i] = rows[i].main_l2_gas_op; + polys.main_l2_gas_op_cost[i] = rows[i].main_l2_gas_op_cost; polys.main_l2_gas_remaining[i] = rows[i].main_l2_gas_remaining; polys.main_l2_out_of_gas[i] = rows[i].main_l2_out_of_gas; - polys.main_last[i] = rows[i].main_last; - polys.main_mem_idx_a[i] = rows[i].main_mem_idx_a; - polys.main_mem_idx_b[i] = rows[i].main_mem_idx_b; - polys.main_mem_idx_c[i] = rows[i].main_mem_idx_c; - polys.main_mem_idx_d[i] = rows[i].main_mem_idx_d; - polys.main_mem_op_a[i] = rows[i].main_mem_op_a; - polys.main_mem_op_activate_gas[i] = rows[i].main_mem_op_activate_gas; - polys.main_mem_op_b[i] = rows[i].main_mem_op_b; - polys.main_mem_op_c[i] = rows[i].main_mem_op_c; - polys.main_mem_op_d[i] = rows[i].main_mem_op_d; + polys.main_mem_addr_a[i] = rows[i].main_mem_addr_a; + polys.main_mem_addr_b[i] = rows[i].main_mem_addr_b; + polys.main_mem_addr_c[i] = rows[i].main_mem_addr_c; + polys.main_mem_addr_d[i] = rows[i].main_mem_addr_d; polys.main_op_err[i] = rows[i].main_op_err; polys.main_opcode_val[i] = rows[i].main_opcode_val; polys.main_pc[i] = rows[i].main_pc; - polys.main_q_kernel_lookup[i] = rows[i].main_q_kernel_lookup; - polys.main_q_kernel_output_lookup[i] = rows[i].main_q_kernel_output_lookup; polys.main_r_in_tag[i] = rows[i].main_r_in_tag; polys.main_rwa[i] = rows[i].main_rwa; polys.main_rwb[i] = rows[i].main_rwb; polys.main_rwc[i] = rows[i].main_rwc; polys.main_rwd[i] = rows[i].main_rwd; - polys.main_sel_cmov[i] = rows[i].main_sel_cmov; - polys.main_sel_external_call[i] = rows[i].main_sel_external_call; - polys.main_sel_halt[i] = rows[i].main_sel_halt; - polys.main_sel_internal_call[i] = rows[i].main_sel_internal_call; - polys.main_sel_internal_return[i] = rows[i].main_sel_internal_return; - polys.main_sel_jump[i] = rows[i].main_sel_jump; - polys.main_sel_jumpi[i] = rows[i].main_sel_jumpi; - polys.main_sel_mov[i] = rows[i].main_sel_mov; - polys.main_sel_mov_a[i] = rows[i].main_sel_mov_a; - polys.main_sel_mov_b[i] = rows[i].main_sel_mov_b; + polys.main_sel_alu[i] = rows[i].main_sel_alu; + polys.main_sel_bin[i] = rows[i].main_sel_bin; + 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; + polys.main_sel_mem_op_activate_gas[i] = rows[i].main_sel_mem_op_activate_gas; + polys.main_sel_mem_op_b[i] = rows[i].main_sel_mem_op_b; + polys.main_sel_mem_op_c[i] = rows[i].main_sel_mem_op_c; + polys.main_sel_mem_op_d[i] = rows[i].main_sel_mem_op_d; + polys.main_sel_mov_ia_to_ic[i] = rows[i].main_sel_mov_ia_to_ic; + polys.main_sel_mov_ib_to_ic[i] = rows[i].main_sel_mov_ib_to_ic; polys.main_sel_op_add[i] = rows[i].main_sel_op_add; 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_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; polys.main_sel_op_coinbase[i] = rows[i].main_sel_op_coinbase; polys.main_sel_op_dagasleft[i] = rows[i].main_sel_op_dagasleft; polys.main_sel_op_div[i] = rows[i].main_sel_op_div; @@ -780,15 +767,22 @@ class AvmCircuitBuilder { polys.main_sel_op_emit_nullifier[i] = rows[i].main_sel_op_emit_nullifier; 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_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; polys.main_sel_op_get_contract_instance[i] = rows[i].main_sel_op_get_contract_instance; + polys.main_sel_op_halt[i] = rows[i].main_sel_op_halt; + polys.main_sel_op_internal_call[i] = rows[i].main_sel_op_internal_call; + polys.main_sel_op_internal_return[i] = rows[i].main_sel_op_internal_return; + polys.main_sel_op_jump[i] = rows[i].main_sel_op_jump; + polys.main_sel_op_jumpi[i] = rows[i].main_sel_op_jumpi; polys.main_sel_op_keccak[i] = rows[i].main_sel_op_keccak; polys.main_sel_op_l1_to_l2_msg_exists[i] = rows[i].main_sel_op_l1_to_l2_msg_exists; polys.main_sel_op_l2gasleft[i] = rows[i].main_sel_op_l2gasleft; polys.main_sel_op_lt[i] = rows[i].main_sel_op_lt; polys.main_sel_op_lte[i] = rows[i].main_sel_op_lte; + polys.main_sel_op_mov[i] = rows[i].main_sel_op_mov; polys.main_sel_op_mul[i] = rows[i].main_sel_op_mul; polys.main_sel_op_not[i] = rows[i].main_sel_op_not; polys.main_sel_op_note_hash_exists[i] = rows[i].main_sel_op_note_hash_exists; @@ -809,6 +803,12 @@ class AvmCircuitBuilder { polys.main_sel_op_transaction_fee[i] = rows[i].main_sel_op_transaction_fee; polys.main_sel_op_version[i] = rows[i].main_sel_op_version; polys.main_sel_op_xor[i] = rows[i].main_sel_op_xor; + polys.main_sel_q_kernel_lookup[i] = rows[i].main_sel_q_kernel_lookup; + polys.main_sel_q_kernel_output_lookup[i] = rows[i].main_sel_q_kernel_output_lookup; + polys.main_sel_resolve_ind_addr_a[i] = rows[i].main_sel_resolve_ind_addr_a; + 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_rng_16[i] = rows[i].main_sel_rng_16; polys.main_sel_rng_8[i] = rows[i].main_sel_rng_8; polys.main_space_id[i] = rows[i].main_space_id; @@ -821,24 +821,24 @@ class AvmCircuitBuilder { polys.mem_diff_lo[i] = rows[i].mem_diff_lo; polys.mem_diff_mid[i] = rows[i].mem_diff_mid; polys.mem_glob_addr[i] = rows[i].mem_glob_addr; - polys.mem_ind_op_a[i] = rows[i].mem_ind_op_a; - polys.mem_ind_op_b[i] = rows[i].mem_ind_op_b; - polys.mem_ind_op_c[i] = rows[i].mem_ind_op_c; - polys.mem_ind_op_d[i] = rows[i].mem_ind_op_d; polys.mem_last[i] = rows[i].mem_last; polys.mem_lastAccess[i] = rows[i].mem_lastAccess; - polys.mem_mem_sel[i] = rows[i].mem_mem_sel; polys.mem_one_min_inv[i] = rows[i].mem_one_min_inv; - polys.mem_op_a[i] = rows[i].mem_op_a; - polys.mem_op_b[i] = rows[i].mem_op_b; - polys.mem_op_c[i] = rows[i].mem_op_c; - polys.mem_op_d[i] = rows[i].mem_op_d; polys.mem_r_in_tag[i] = rows[i].mem_r_in_tag; - polys.mem_rng_chk_sel[i] = rows[i].mem_rng_chk_sel; polys.mem_rw[i] = rows[i].mem_rw; - polys.mem_sel_cmov[i] = rows[i].mem_sel_cmov; - polys.mem_sel_mov_a[i] = rows[i].mem_sel_mov_a; - polys.mem_sel_mov_b[i] = rows[i].mem_sel_mov_b; + polys.mem_sel_mem[i] = rows[i].mem_sel_mem; + polys.mem_sel_mov_ia_to_ic[i] = rows[i].mem_sel_mov_ia_to_ic; + polys.mem_sel_mov_ib_to_ic[i] = rows[i].mem_sel_mov_ib_to_ic; + polys.mem_sel_op_a[i] = rows[i].mem_sel_op_a; + polys.mem_sel_op_b[i] = rows[i].mem_sel_op_b; + polys.mem_sel_op_c[i] = rows[i].mem_sel_op_c; + polys.mem_sel_op_cmov[i] = rows[i].mem_sel_op_cmov; + polys.mem_sel_op_d[i] = rows[i].mem_sel_op_d; + polys.mem_sel_resolve_ind_addr_a[i] = rows[i].mem_sel_resolve_ind_addr_a; + 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; + polys.mem_sel_resolve_ind_addr_d[i] = rows[i].mem_sel_resolve_ind_addr_d; + polys.mem_sel_rng_chk[i] = rows[i].mem_sel_rng_chk; polys.mem_skip_check_tag[i] = rows[i].mem_skip_check_tag; polys.mem_space_id[i] = rows[i].mem_space_id; polys.mem_tag[i] = rows[i].mem_tag; @@ -849,15 +849,15 @@ class AvmCircuitBuilder { polys.pedersen_clk[i] = rows[i].pedersen_clk; polys.pedersen_input[i] = rows[i].pedersen_input; polys.pedersen_output[i] = rows[i].pedersen_output; - polys.pedersen_pedersen_sel[i] = rows[i].pedersen_pedersen_sel; + polys.pedersen_sel_pedersen[i] = rows[i].pedersen_sel_pedersen; polys.poseidon2_clk[i] = rows[i].poseidon2_clk; polys.poseidon2_input[i] = rows[i].poseidon2_input; polys.poseidon2_output[i] = rows[i].poseidon2_output; - polys.poseidon2_poseidon_perm_sel[i] = rows[i].poseidon2_poseidon_perm_sel; + polys.poseidon2_sel_poseidon_perm[i] = rows[i].poseidon2_sel_poseidon_perm; polys.sha256_clk[i] = rows[i].sha256_clk; polys.sha256_input[i] = rows[i].sha256_input; polys.sha256_output[i] = rows[i].sha256_output; - polys.sha256_sha256_compression_sel[i] = rows[i].sha256_sha256_compression_sel; + polys.sha256_sel_sha256_compression[i] = rows[i].sha256_sel_sha256_compression; polys.sha256_state[i] = rows[i].sha256_state; polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; @@ -904,12 +904,9 @@ class AvmCircuitBuilder { polys.alu_a_hi_shift = Polynomial(polys.alu_a_hi.shifted()); polys.alu_a_lo_shift = Polynomial(polys.alu_a_lo.shifted()); - polys.alu_alu_sel_shift = Polynomial(polys.alu_alu_sel.shifted()); polys.alu_b_hi_shift = Polynomial(polys.alu_b_hi.shifted()); polys.alu_b_lo_shift = Polynomial(polys.alu_b_lo.shifted()); polys.alu_cmp_rng_ctr_shift = Polynomial(polys.alu_cmp_rng_ctr.shifted()); - polys.alu_cmp_sel_shift = Polynomial(polys.alu_cmp_sel.shifted()); - polys.alu_div_rng_chk_selector_shift = Polynomial(polys.alu_div_rng_chk_selector.shifted()); polys.alu_div_u16_r0_shift = Polynomial(polys.alu_div_u16_r0.shifted()); polys.alu_div_u16_r1_shift = Polynomial(polys.alu_div_u16_r1.shifted()); polys.alu_div_u16_r2_shift = Polynomial(polys.alu_div_u16_r2.shifted()); @@ -930,8 +927,11 @@ class AvmCircuitBuilder { polys.alu_p_sub_a_lo_shift = Polynomial(polys.alu_p_sub_a_lo.shifted()); polys.alu_p_sub_b_hi_shift = Polynomial(polys.alu_p_sub_b_hi.shifted()); polys.alu_p_sub_b_lo_shift = Polynomial(polys.alu_p_sub_b_lo.shifted()); - polys.alu_rng_chk_lookup_selector_shift = Polynomial(polys.alu_rng_chk_lookup_selector.shifted()); - polys.alu_rng_chk_sel_shift = Polynomial(polys.alu_rng_chk_sel.shifted()); + polys.alu_sel_alu_shift = Polynomial(polys.alu_sel_alu.shifted()); + polys.alu_sel_cmp_shift = Polynomial(polys.alu_sel_cmp.shifted()); + polys.alu_sel_div_rng_chk_shift = Polynomial(polys.alu_sel_div_rng_chk.shifted()); + polys.alu_sel_rng_chk_lookup_shift = Polynomial(polys.alu_sel_rng_chk_lookup.shifted()); + polys.alu_sel_rng_chk_shift = Polynomial(polys.alu_sel_rng_chk.shifted()); polys.alu_u16_r0_shift = Polynomial(polys.alu_u16_r0.shifted()); polys.alu_u16_r1_shift = Polynomial(polys.alu_u16_r1.shifted()); polys.alu_u16_r2_shift = Polynomial(polys.alu_u16_r2.shifted()); @@ -968,8 +968,8 @@ class AvmCircuitBuilder { polys.main_l2_gas_remaining_shift = Polynomial(polys.main_l2_gas_remaining.shifted()); polys.main_pc_shift = Polynomial(polys.main_pc.shifted()); polys.mem_glob_addr_shift = Polynomial(polys.mem_glob_addr.shifted()); - polys.mem_mem_sel_shift = Polynomial(polys.mem_mem_sel.shifted()); polys.mem_rw_shift = Polynomial(polys.mem_rw.shifted()); + polys.mem_sel_mem_shift = Polynomial(polys.mem_sel_mem.shifted()); 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()); @@ -1127,20 +1127,24 @@ class AvmCircuitBuilder { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_D"); }; - auto perm_main_mem_ind_a = [=]() { - return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_A"); + auto perm_main_mem_ind_addr_a = [=]() { + return evaluate_logderivative.template operator()>( + "PERM_MAIN_MEM_IND_ADDR_A"); }; - auto perm_main_mem_ind_b = [=]() { - return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_B"); + auto perm_main_mem_ind_addr_b = [=]() { + return evaluate_logderivative.template operator()>( + "PERM_MAIN_MEM_IND_ADDR_B"); }; - auto perm_main_mem_ind_c = [=]() { - return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_C"); + auto perm_main_mem_ind_addr_c = [=]() { + return evaluate_logderivative.template operator()>( + "PERM_MAIN_MEM_IND_ADDR_C"); }; - auto perm_main_mem_ind_d = [=]() { - return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_D"); + auto perm_main_mem_ind_addr_d = [=]() { + return evaluate_logderivative.template operator()>( + "PERM_MAIN_MEM_IND_ADDR_D"); }; auto lookup_byte_lengths = [=]() { @@ -1359,13 +1363,13 @@ class AvmCircuitBuilder { relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_d)); - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_a)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_addr_a)); - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_b)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_addr_b)); - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_c)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_addr_c)); - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_d)); + 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)); @@ -1496,13 +1500,13 @@ class AvmCircuitBuilder { perm_main_mem_d(); - perm_main_mem_ind_a(); + perm_main_mem_ind_addr_a(); - perm_main_mem_ind_b(); + perm_main_mem_ind_addr_b(); - perm_main_mem_ind_c(); + perm_main_mem_ind_addr_c(); - perm_main_mem_ind_d(); + perm_main_mem_ind_addr_d(); lookup_byte_lengths(); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 4f0f8feadc8..41cae773d42 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -65,10 +65,10 @@ #include "barretenberg/relations/generated/avm/perm_main_mem_b.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_c.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_d.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_a.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_b.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_c.hpp" -#include "barretenberg/relations/generated/avm/perm_main_mem_ind_d.hpp" +#include "barretenberg/relations/generated/avm/perm_main_mem_ind_addr_a.hpp" +#include "barretenberg/relations/generated/avm/perm_main_mem_ind_addr_b.hpp" +#include "barretenberg/relations/generated/avm/perm_main_mem_ind_addr_c.hpp" +#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/poseidon2.hpp" @@ -113,10 +113,10 @@ class AvmFlavor { perm_main_mem_b_relation, perm_main_mem_c_relation, perm_main_mem_d_relation, - perm_main_mem_ind_a_relation, - perm_main_mem_ind_b_relation, - perm_main_mem_ind_c_relation, - perm_main_mem_ind_d_relation, + perm_main_mem_ind_addr_a_relation, + perm_main_mem_ind_addr_b_relation, + perm_main_mem_ind_addr_c_relation, + perm_main_mem_ind_addr_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, lookup_opcode_gas_relation, @@ -178,10 +178,10 @@ class AvmFlavor { perm_main_mem_b_relation, perm_main_mem_c_relation, perm_main_mem_d_relation, - perm_main_mem_ind_a_relation, - perm_main_mem_ind_b_relation, - perm_main_mem_ind_c_relation, - perm_main_mem_ind_d_relation, + perm_main_mem_ind_addr_a_relation, + perm_main_mem_ind_addr_b_relation, + perm_main_mem_ind_addr_c_relation, + perm_main_mem_ind_addr_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, lookup_opcode_gas_relation, @@ -245,9 +245,9 @@ class AvmFlavor { public: using DataType = DataType_; - DEFINE_FLAVOR_MEMBERS(DataType, main_clk, main_first) + DEFINE_FLAVOR_MEMBERS(DataType, main_clk, main_sel_first) - RefVector get_selectors() { return { main_clk, main_first }; }; + RefVector get_selectors() { return { main_clk, main_sel_first }; }; RefVector get_sigma_polynomials() { return {}; }; RefVector get_id_polynomials() { return {}; }; RefVector get_table_polynomials() { return {}; }; @@ -258,15 +258,12 @@ class AvmFlavor { DEFINE_FLAVOR_MEMBERS(DataType, alu_a_hi, alu_a_lo, - alu_alu_sel, alu_b_hi, alu_b_lo, alu_borrow, alu_cf, alu_clk, alu_cmp_rng_ctr, - alu_cmp_sel, - alu_div_rng_chk_selector, alu_div_u16_r0, alu_div_u16_r1, alu_div_u16_r2, @@ -310,10 +307,13 @@ class AvmFlavor { alu_remainder, alu_res_hi, alu_res_lo, - alu_rng_chk_lookup_selector, - alu_rng_chk_sel, + 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_shift_sel, alu_t_sub_s_bits, alu_two_pow_s, alu_two_pow_t_sub_s, @@ -342,7 +342,6 @@ class AvmFlavor { binary_acc_ia, binary_acc_ib, binary_acc_ic, - binary_bin_sel, binary_clk, binary_ia_bytes, binary_ib_bytes, @@ -351,8 +350,9 @@ class AvmFlavor { binary_mem_tag_ctr, binary_mem_tag_ctr_inv, binary_op_id, + binary_sel_bin, binary_start, - byte_lookup_bin_sel, + byte_lookup_sel_bin, byte_lookup_table_byte_lengths, byte_lookup_table_in_tags, byte_lookup_table_input_a, @@ -363,14 +363,14 @@ class AvmFlavor { conversion_input, conversion_num_limbs, conversion_radix, - conversion_to_radix_le_sel, + conversion_sel_to_radix_le, gas_da_gas_fixed_table, - gas_gas_cost_sel, gas_l2_gas_fixed_table, + gas_sel_gas_cost, keccakf1600_clk, keccakf1600_input, - keccakf1600_keccakf1600_sel, keccakf1600_output, + keccakf1600_sel_keccakf1600, kernel_emit_l2_to_l1_msg_write_offset, kernel_emit_note_hash_write_offset, kernel_emit_nullifier_write_offset, @@ -395,68 +395,55 @@ class AvmFlavor { main_abs_l2_rem_gas_hi, main_abs_l2_rem_gas_lo, main_alu_in_tag, - main_alu_sel, main_bin_op_id, - main_bin_sel, main_call_ptr, - main_da_gas_op, + main_da_gas_op_cost, main_da_gas_remaining, main_da_out_of_gas, - main_gas_cost_active, main_ia, main_ib, main_ic, main_id, main_id_zero, - main_ind_a, - main_ind_b, - main_ind_c, - main_ind_d, - main_ind_op_a, - main_ind_op_b, - main_ind_op_c, - main_ind_op_d, + 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, + main_l2_gas_op_cost, main_l2_gas_remaining, main_l2_out_of_gas, - main_last, - main_mem_idx_a, - main_mem_idx_b, - main_mem_idx_c, - main_mem_idx_d, - main_mem_op_a, - main_mem_op_activate_gas, - main_mem_op_b, - main_mem_op_c, - main_mem_op_d, + 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_q_kernel_lookup, - main_q_kernel_output_lookup, main_r_in_tag, main_rwa, main_rwb, main_rwc, main_rwd, - main_sel_cmov, - main_sel_external_call, - main_sel_halt, - main_sel_internal_call, - main_sel_internal_return, - main_sel_jump, - main_sel_jumpi, - main_sel_mov, - main_sel_mov_a, - main_sel_mov_b, + main_sel_alu, + main_sel_bin, + 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_cast, main_sel_op_chain_id, + main_sel_op_cmov, main_sel_op_coinbase, main_sel_op_dagasleft, main_sel_op_div, @@ -465,15 +452,22 @@ class AvmFlavor { main_sel_op_emit_nullifier, main_sel_op_emit_unencrypted_log, main_sel_op_eq, + main_sel_op_external_call, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, main_sel_op_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, @@ -494,6 +488,12 @@ class AvmFlavor { main_sel_op_transaction_fee, main_sel_op_version, main_sel_op_xor, + main_sel_q_kernel_lookup, + main_sel_q_kernel_output_lookup, + main_sel_resolve_ind_addr_a, + main_sel_resolve_ind_addr_b, + main_sel_resolve_ind_addr_c, + main_sel_resolve_ind_addr_d, main_sel_rng_16, main_sel_rng_8, main_space_id, @@ -506,24 +506,24 @@ class AvmFlavor { mem_diff_lo, mem_diff_mid, mem_glob_addr, - mem_ind_op_a, - mem_ind_op_b, - mem_ind_op_c, - mem_ind_op_d, mem_last, mem_lastAccess, - mem_mem_sel, mem_one_min_inv, - mem_op_a, - mem_op_b, - mem_op_c, - mem_op_d, mem_r_in_tag, - mem_rng_chk_sel, mem_rw, - mem_sel_cmov, - mem_sel_mov_a, - mem_sel_mov_b, + 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_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, @@ -534,15 +534,15 @@ class AvmFlavor { pedersen_clk, pedersen_input, pedersen_output, - pedersen_pedersen_sel, + pedersen_sel_pedersen, poseidon2_clk, poseidon2_input, poseidon2_output, - poseidon2_poseidon_perm_sel, + poseidon2_sel_poseidon_perm, sha256_clk, sha256_input, sha256_output, - sha256_sha256_compression_sel, + sha256_sel_sha256_compression, sha256_state, perm_main_alu, perm_main_bin, @@ -553,10 +553,10 @@ class AvmFlavor { perm_main_mem_b, perm_main_mem_c, perm_main_mem_d, - perm_main_mem_ind_a, - perm_main_mem_ind_b, - perm_main_mem_ind_c, - perm_main_mem_ind_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_opcode_gas, @@ -644,15 +644,12 @@ class AvmFlavor { { return { alu_a_hi, alu_a_lo, - alu_alu_sel, alu_b_hi, alu_b_lo, alu_borrow, alu_cf, alu_clk, alu_cmp_rng_ctr, - alu_cmp_sel, - alu_div_rng_chk_selector, alu_div_u16_r0, alu_div_u16_r1, alu_div_u16_r2, @@ -696,10 +693,13 @@ class AvmFlavor { alu_remainder, alu_res_hi, alu_res_lo, - alu_rng_chk_lookup_selector, - alu_rng_chk_sel, + 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_shift_sel, alu_t_sub_s_bits, alu_two_pow_s, alu_two_pow_t_sub_s, @@ -728,7 +728,6 @@ class AvmFlavor { binary_acc_ia, binary_acc_ib, binary_acc_ic, - binary_bin_sel, binary_clk, binary_ia_bytes, binary_ib_bytes, @@ -737,8 +736,9 @@ class AvmFlavor { binary_mem_tag_ctr, binary_mem_tag_ctr_inv, binary_op_id, + binary_sel_bin, binary_start, - byte_lookup_bin_sel, + byte_lookup_sel_bin, byte_lookup_table_byte_lengths, byte_lookup_table_in_tags, byte_lookup_table_input_a, @@ -749,14 +749,14 @@ class AvmFlavor { conversion_input, conversion_num_limbs, conversion_radix, - conversion_to_radix_le_sel, + conversion_sel_to_radix_le, gas_da_gas_fixed_table, - gas_gas_cost_sel, gas_l2_gas_fixed_table, + gas_sel_gas_cost, keccakf1600_clk, keccakf1600_input, - keccakf1600_keccakf1600_sel, keccakf1600_output, + keccakf1600_sel_keccakf1600, kernel_emit_l2_to_l1_msg_write_offset, kernel_emit_note_hash_write_offset, kernel_emit_nullifier_write_offset, @@ -781,68 +781,55 @@ class AvmFlavor { main_abs_l2_rem_gas_hi, main_abs_l2_rem_gas_lo, main_alu_in_tag, - main_alu_sel, main_bin_op_id, - main_bin_sel, main_call_ptr, - main_da_gas_op, + main_da_gas_op_cost, main_da_gas_remaining, main_da_out_of_gas, - main_gas_cost_active, main_ia, main_ib, main_ic, main_id, main_id_zero, - main_ind_a, - main_ind_b, - main_ind_c, - main_ind_d, - main_ind_op_a, - main_ind_op_b, - main_ind_op_c, - main_ind_op_d, + 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, + main_l2_gas_op_cost, main_l2_gas_remaining, main_l2_out_of_gas, - main_last, - main_mem_idx_a, - main_mem_idx_b, - main_mem_idx_c, - main_mem_idx_d, - main_mem_op_a, - main_mem_op_activate_gas, - main_mem_op_b, - main_mem_op_c, - main_mem_op_d, + 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_q_kernel_lookup, - main_q_kernel_output_lookup, main_r_in_tag, main_rwa, main_rwb, main_rwc, main_rwd, - main_sel_cmov, - main_sel_external_call, - main_sel_halt, - main_sel_internal_call, - main_sel_internal_return, - main_sel_jump, - main_sel_jumpi, - main_sel_mov, - main_sel_mov_a, - main_sel_mov_b, + main_sel_alu, + main_sel_bin, + 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_cast, main_sel_op_chain_id, + main_sel_op_cmov, main_sel_op_coinbase, main_sel_op_dagasleft, main_sel_op_div, @@ -851,15 +838,22 @@ class AvmFlavor { main_sel_op_emit_nullifier, main_sel_op_emit_unencrypted_log, main_sel_op_eq, + main_sel_op_external_call, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, main_sel_op_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, @@ -880,6 +874,12 @@ class AvmFlavor { main_sel_op_transaction_fee, main_sel_op_version, main_sel_op_xor, + main_sel_q_kernel_lookup, + main_sel_q_kernel_output_lookup, + main_sel_resolve_ind_addr_a, + main_sel_resolve_ind_addr_b, + main_sel_resolve_ind_addr_c, + main_sel_resolve_ind_addr_d, main_sel_rng_16, main_sel_rng_8, main_space_id, @@ -892,24 +892,24 @@ class AvmFlavor { mem_diff_lo, mem_diff_mid, mem_glob_addr, - mem_ind_op_a, - mem_ind_op_b, - mem_ind_op_c, - mem_ind_op_d, mem_last, mem_lastAccess, - mem_mem_sel, mem_one_min_inv, - mem_op_a, - mem_op_b, - mem_op_c, - mem_op_d, mem_r_in_tag, - mem_rng_chk_sel, mem_rw, - mem_sel_cmov, - mem_sel_mov_a, - mem_sel_mov_b, + 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_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, @@ -920,15 +920,15 @@ class AvmFlavor { pedersen_clk, pedersen_input, pedersen_output, - pedersen_pedersen_sel, + pedersen_sel_pedersen, poseidon2_clk, poseidon2_input, poseidon2_output, - poseidon2_poseidon_perm_sel, + poseidon2_sel_poseidon_perm, sha256_clk, sha256_input, sha256_output, - sha256_sha256_compression_sel, + sha256_sel_sha256_compression, sha256_state, perm_main_alu, perm_main_bin, @@ -939,10 +939,10 @@ class AvmFlavor { perm_main_mem_b, perm_main_mem_c, perm_main_mem_d, - perm_main_mem_ind_a, - perm_main_mem_ind_b, - perm_main_mem_ind_c, - perm_main_mem_ind_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_opcode_gas, @@ -1032,18 +1032,15 @@ class AvmFlavor { public: DEFINE_FLAVOR_MEMBERS(DataType, main_clk, - main_first, + main_sel_first, alu_a_hi, alu_a_lo, - alu_alu_sel, alu_b_hi, alu_b_lo, alu_borrow, alu_cf, alu_clk, alu_cmp_rng_ctr, - alu_cmp_sel, - alu_div_rng_chk_selector, alu_div_u16_r0, alu_div_u16_r1, alu_div_u16_r2, @@ -1087,10 +1084,13 @@ class AvmFlavor { alu_remainder, alu_res_hi, alu_res_lo, - alu_rng_chk_lookup_selector, - alu_rng_chk_sel, + 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_shift_sel, alu_t_sub_s_bits, alu_two_pow_s, alu_two_pow_t_sub_s, @@ -1119,7 +1119,6 @@ class AvmFlavor { binary_acc_ia, binary_acc_ib, binary_acc_ic, - binary_bin_sel, binary_clk, binary_ia_bytes, binary_ib_bytes, @@ -1128,8 +1127,9 @@ class AvmFlavor { binary_mem_tag_ctr, binary_mem_tag_ctr_inv, binary_op_id, + binary_sel_bin, binary_start, - byte_lookup_bin_sel, + byte_lookup_sel_bin, byte_lookup_table_byte_lengths, byte_lookup_table_in_tags, byte_lookup_table_input_a, @@ -1140,14 +1140,14 @@ class AvmFlavor { conversion_input, conversion_num_limbs, conversion_radix, - conversion_to_radix_le_sel, + conversion_sel_to_radix_le, gas_da_gas_fixed_table, - gas_gas_cost_sel, gas_l2_gas_fixed_table, + gas_sel_gas_cost, keccakf1600_clk, keccakf1600_input, - keccakf1600_keccakf1600_sel, keccakf1600_output, + keccakf1600_sel_keccakf1600, kernel_emit_l2_to_l1_msg_write_offset, kernel_emit_note_hash_write_offset, kernel_emit_nullifier_write_offset, @@ -1172,68 +1172,55 @@ class AvmFlavor { main_abs_l2_rem_gas_hi, main_abs_l2_rem_gas_lo, main_alu_in_tag, - main_alu_sel, main_bin_op_id, - main_bin_sel, main_call_ptr, - main_da_gas_op, + main_da_gas_op_cost, main_da_gas_remaining, main_da_out_of_gas, - main_gas_cost_active, main_ia, main_ib, main_ic, main_id, main_id_zero, - main_ind_a, - main_ind_b, - main_ind_c, - main_ind_d, - main_ind_op_a, - main_ind_op_b, - main_ind_op_c, - main_ind_op_d, + 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, + main_l2_gas_op_cost, main_l2_gas_remaining, main_l2_out_of_gas, - main_last, - main_mem_idx_a, - main_mem_idx_b, - main_mem_idx_c, - main_mem_idx_d, - main_mem_op_a, - main_mem_op_activate_gas, - main_mem_op_b, - main_mem_op_c, - main_mem_op_d, + 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_q_kernel_lookup, - main_q_kernel_output_lookup, main_r_in_tag, main_rwa, main_rwb, main_rwc, main_rwd, - main_sel_cmov, - main_sel_external_call, - main_sel_halt, - main_sel_internal_call, - main_sel_internal_return, - main_sel_jump, - main_sel_jumpi, - main_sel_mov, - main_sel_mov_a, - main_sel_mov_b, + main_sel_alu, + main_sel_bin, + 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_cast, main_sel_op_chain_id, + main_sel_op_cmov, main_sel_op_coinbase, main_sel_op_dagasleft, main_sel_op_div, @@ -1242,15 +1229,22 @@ class AvmFlavor { main_sel_op_emit_nullifier, main_sel_op_emit_unencrypted_log, main_sel_op_eq, + main_sel_op_external_call, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, main_sel_op_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, @@ -1271,6 +1265,12 @@ class AvmFlavor { main_sel_op_transaction_fee, main_sel_op_version, main_sel_op_xor, + main_sel_q_kernel_lookup, + main_sel_q_kernel_output_lookup, + main_sel_resolve_ind_addr_a, + main_sel_resolve_ind_addr_b, + main_sel_resolve_ind_addr_c, + main_sel_resolve_ind_addr_d, main_sel_rng_16, main_sel_rng_8, main_space_id, @@ -1283,24 +1283,24 @@ class AvmFlavor { mem_diff_lo, mem_diff_mid, mem_glob_addr, - mem_ind_op_a, - mem_ind_op_b, - mem_ind_op_c, - mem_ind_op_d, mem_last, mem_lastAccess, - mem_mem_sel, mem_one_min_inv, - mem_op_a, - mem_op_b, - mem_op_c, - mem_op_d, mem_r_in_tag, - mem_rng_chk_sel, mem_rw, - mem_sel_cmov, - mem_sel_mov_a, - mem_sel_mov_b, + 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_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, @@ -1311,15 +1311,15 @@ class AvmFlavor { pedersen_clk, pedersen_input, pedersen_output, - pedersen_pedersen_sel, + pedersen_sel_pedersen, poseidon2_clk, poseidon2_input, poseidon2_output, - poseidon2_poseidon_perm_sel, + poseidon2_sel_poseidon_perm, sha256_clk, sha256_input, sha256_output, - sha256_sha256_compression_sel, + sha256_sel_sha256_compression, sha256_state, perm_main_alu, perm_main_bin, @@ -1330,10 +1330,10 @@ class AvmFlavor { perm_main_mem_b, perm_main_mem_c, perm_main_mem_d, - perm_main_mem_ind_a, - perm_main_mem_ind_b, - perm_main_mem_ind_c, - perm_main_mem_ind_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_opcode_gas, @@ -1418,12 +1418,9 @@ class AvmFlavor { lookup_div_u16_7_counts, alu_a_hi_shift, alu_a_lo_shift, - alu_alu_sel_shift, alu_b_hi_shift, alu_b_lo_shift, alu_cmp_rng_ctr_shift, - alu_cmp_sel_shift, - alu_div_rng_chk_selector_shift, alu_div_u16_r0_shift, alu_div_u16_r1_shift, alu_div_u16_r2_shift, @@ -1444,8 +1441,11 @@ class AvmFlavor { alu_p_sub_a_lo_shift, alu_p_sub_b_hi_shift, alu_p_sub_b_lo_shift, - alu_rng_chk_lookup_selector_shift, - alu_rng_chk_sel_shift, + alu_sel_alu_shift, + alu_sel_cmp_shift, + alu_sel_div_rng_chk_shift, + alu_sel_rng_chk_lookup_shift, + alu_sel_rng_chk_shift, alu_u16_r0_shift, alu_u16_r1_shift, alu_u16_r2_shift, @@ -1476,8 +1476,8 @@ class AvmFlavor { main_l2_gas_remaining_shift, main_pc_shift, mem_glob_addr_shift, - mem_mem_sel_shift, mem_rw_shift, + mem_sel_mem_shift, mem_tag_shift, mem_tsp_shift, mem_val_shift) @@ -1485,18 +1485,15 @@ class AvmFlavor { RefVector get_wires() { return { main_clk, - main_first, + main_sel_first, alu_a_hi, alu_a_lo, - alu_alu_sel, alu_b_hi, alu_b_lo, alu_borrow, alu_cf, alu_clk, alu_cmp_rng_ctr, - alu_cmp_sel, - alu_div_rng_chk_selector, alu_div_u16_r0, alu_div_u16_r1, alu_div_u16_r2, @@ -1540,10 +1537,13 @@ class AvmFlavor { alu_remainder, alu_res_hi, alu_res_lo, - alu_rng_chk_lookup_selector, - alu_rng_chk_sel, + 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_shift_sel, alu_t_sub_s_bits, alu_two_pow_s, alu_two_pow_t_sub_s, @@ -1572,7 +1572,6 @@ class AvmFlavor { binary_acc_ia, binary_acc_ib, binary_acc_ic, - binary_bin_sel, binary_clk, binary_ia_bytes, binary_ib_bytes, @@ -1581,8 +1580,9 @@ class AvmFlavor { binary_mem_tag_ctr, binary_mem_tag_ctr_inv, binary_op_id, + binary_sel_bin, binary_start, - byte_lookup_bin_sel, + byte_lookup_sel_bin, byte_lookup_table_byte_lengths, byte_lookup_table_in_tags, byte_lookup_table_input_a, @@ -1593,14 +1593,14 @@ class AvmFlavor { conversion_input, conversion_num_limbs, conversion_radix, - conversion_to_radix_le_sel, + conversion_sel_to_radix_le, gas_da_gas_fixed_table, - gas_gas_cost_sel, gas_l2_gas_fixed_table, + gas_sel_gas_cost, keccakf1600_clk, keccakf1600_input, - keccakf1600_keccakf1600_sel, keccakf1600_output, + keccakf1600_sel_keccakf1600, kernel_emit_l2_to_l1_msg_write_offset, kernel_emit_note_hash_write_offset, kernel_emit_nullifier_write_offset, @@ -1625,68 +1625,55 @@ class AvmFlavor { main_abs_l2_rem_gas_hi, main_abs_l2_rem_gas_lo, main_alu_in_tag, - main_alu_sel, main_bin_op_id, - main_bin_sel, main_call_ptr, - main_da_gas_op, + main_da_gas_op_cost, main_da_gas_remaining, main_da_out_of_gas, - main_gas_cost_active, main_ia, main_ib, main_ic, main_id, main_id_zero, - main_ind_a, - main_ind_b, - main_ind_c, - main_ind_d, - main_ind_op_a, - main_ind_op_b, - main_ind_op_c, - main_ind_op_d, + 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, + main_l2_gas_op_cost, main_l2_gas_remaining, main_l2_out_of_gas, - main_last, - main_mem_idx_a, - main_mem_idx_b, - main_mem_idx_c, - main_mem_idx_d, - main_mem_op_a, - main_mem_op_activate_gas, - main_mem_op_b, - main_mem_op_c, - main_mem_op_d, + 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_q_kernel_lookup, - main_q_kernel_output_lookup, main_r_in_tag, main_rwa, main_rwb, main_rwc, main_rwd, - main_sel_cmov, - main_sel_external_call, - main_sel_halt, - main_sel_internal_call, - main_sel_internal_return, - main_sel_jump, - main_sel_jumpi, - main_sel_mov, - main_sel_mov_a, - main_sel_mov_b, + main_sel_alu, + main_sel_bin, + 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_cast, main_sel_op_chain_id, + main_sel_op_cmov, main_sel_op_coinbase, main_sel_op_dagasleft, main_sel_op_div, @@ -1695,15 +1682,22 @@ class AvmFlavor { main_sel_op_emit_nullifier, main_sel_op_emit_unencrypted_log, main_sel_op_eq, + main_sel_op_external_call, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, main_sel_op_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, @@ -1724,6 +1718,12 @@ class AvmFlavor { main_sel_op_transaction_fee, main_sel_op_version, main_sel_op_xor, + main_sel_q_kernel_lookup, + main_sel_q_kernel_output_lookup, + main_sel_resolve_ind_addr_a, + main_sel_resolve_ind_addr_b, + main_sel_resolve_ind_addr_c, + main_sel_resolve_ind_addr_d, main_sel_rng_16, main_sel_rng_8, main_space_id, @@ -1736,24 +1736,24 @@ class AvmFlavor { mem_diff_lo, mem_diff_mid, mem_glob_addr, - mem_ind_op_a, - mem_ind_op_b, - mem_ind_op_c, - mem_ind_op_d, mem_last, mem_lastAccess, - mem_mem_sel, mem_one_min_inv, - mem_op_a, - mem_op_b, - mem_op_c, - mem_op_d, mem_r_in_tag, - mem_rng_chk_sel, mem_rw, - mem_sel_cmov, - mem_sel_mov_a, - mem_sel_mov_b, + 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_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, @@ -1764,15 +1764,15 @@ class AvmFlavor { pedersen_clk, pedersen_input, pedersen_output, - pedersen_pedersen_sel, + pedersen_sel_pedersen, poseidon2_clk, poseidon2_input, poseidon2_output, - poseidon2_poseidon_perm_sel, + poseidon2_sel_poseidon_perm, sha256_clk, sha256_input, sha256_output, - sha256_sha256_compression_sel, + sha256_sel_sha256_compression, sha256_state, perm_main_alu, perm_main_bin, @@ -1783,10 +1783,10 @@ class AvmFlavor { perm_main_mem_b, perm_main_mem_c, perm_main_mem_d, - perm_main_mem_ind_a, - perm_main_mem_ind_b, - perm_main_mem_ind_c, - perm_main_mem_ind_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_opcode_gas, @@ -1871,12 +1871,9 @@ class AvmFlavor { lookup_div_u16_7_counts, alu_a_hi_shift, alu_a_lo_shift, - alu_alu_sel_shift, alu_b_hi_shift, alu_b_lo_shift, alu_cmp_rng_ctr_shift, - alu_cmp_sel_shift, - alu_div_rng_chk_selector_shift, alu_div_u16_r0_shift, alu_div_u16_r1_shift, alu_div_u16_r2_shift, @@ -1897,8 +1894,11 @@ class AvmFlavor { alu_p_sub_a_lo_shift, alu_p_sub_b_hi_shift, alu_p_sub_b_lo_shift, - alu_rng_chk_lookup_selector_shift, - alu_rng_chk_sel_shift, + alu_sel_alu_shift, + alu_sel_cmp_shift, + alu_sel_div_rng_chk_shift, + alu_sel_rng_chk_lookup_shift, + alu_sel_rng_chk_shift, alu_u16_r0_shift, alu_u16_r1_shift, alu_u16_r2_shift, @@ -1929,8 +1929,8 @@ class AvmFlavor { main_l2_gas_remaining_shift, main_pc_shift, mem_glob_addr_shift, - mem_mem_sel_shift, mem_rw_shift, + mem_sel_mem_shift, mem_tag_shift, mem_tsp_shift, mem_val_shift }; @@ -1938,18 +1938,15 @@ class AvmFlavor { RefVector get_unshifted() { return { main_clk, - main_first, + main_sel_first, alu_a_hi, alu_a_lo, - alu_alu_sel, alu_b_hi, alu_b_lo, alu_borrow, alu_cf, alu_clk, alu_cmp_rng_ctr, - alu_cmp_sel, - alu_div_rng_chk_selector, alu_div_u16_r0, alu_div_u16_r1, alu_div_u16_r2, @@ -1993,10 +1990,13 @@ class AvmFlavor { alu_remainder, alu_res_hi, alu_res_lo, - alu_rng_chk_lookup_selector, - alu_rng_chk_sel, + 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_shift_sel, alu_t_sub_s_bits, alu_two_pow_s, alu_two_pow_t_sub_s, @@ -2025,7 +2025,6 @@ class AvmFlavor { binary_acc_ia, binary_acc_ib, binary_acc_ic, - binary_bin_sel, binary_clk, binary_ia_bytes, binary_ib_bytes, @@ -2034,8 +2033,9 @@ class AvmFlavor { binary_mem_tag_ctr, binary_mem_tag_ctr_inv, binary_op_id, + binary_sel_bin, binary_start, - byte_lookup_bin_sel, + byte_lookup_sel_bin, byte_lookup_table_byte_lengths, byte_lookup_table_in_tags, byte_lookup_table_input_a, @@ -2046,14 +2046,14 @@ class AvmFlavor { conversion_input, conversion_num_limbs, conversion_radix, - conversion_to_radix_le_sel, + conversion_sel_to_radix_le, gas_da_gas_fixed_table, - gas_gas_cost_sel, gas_l2_gas_fixed_table, + gas_sel_gas_cost, keccakf1600_clk, keccakf1600_input, - keccakf1600_keccakf1600_sel, keccakf1600_output, + keccakf1600_sel_keccakf1600, kernel_emit_l2_to_l1_msg_write_offset, kernel_emit_note_hash_write_offset, kernel_emit_nullifier_write_offset, @@ -2078,68 +2078,55 @@ class AvmFlavor { main_abs_l2_rem_gas_hi, main_abs_l2_rem_gas_lo, main_alu_in_tag, - main_alu_sel, main_bin_op_id, - main_bin_sel, main_call_ptr, - main_da_gas_op, + main_da_gas_op_cost, main_da_gas_remaining, main_da_out_of_gas, - main_gas_cost_active, main_ia, main_ib, main_ic, main_id, main_id_zero, - main_ind_a, - main_ind_b, - main_ind_c, - main_ind_d, - main_ind_op_a, - main_ind_op_b, - main_ind_op_c, - main_ind_op_d, + 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, + main_l2_gas_op_cost, main_l2_gas_remaining, main_l2_out_of_gas, - main_last, - main_mem_idx_a, - main_mem_idx_b, - main_mem_idx_c, - main_mem_idx_d, - main_mem_op_a, - main_mem_op_activate_gas, - main_mem_op_b, - main_mem_op_c, - main_mem_op_d, + 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_q_kernel_lookup, - main_q_kernel_output_lookup, main_r_in_tag, main_rwa, main_rwb, main_rwc, main_rwd, - main_sel_cmov, - main_sel_external_call, - main_sel_halt, - main_sel_internal_call, - main_sel_internal_return, - main_sel_jump, - main_sel_jumpi, - main_sel_mov, - main_sel_mov_a, - main_sel_mov_b, + main_sel_alu, + main_sel_bin, + 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_cast, main_sel_op_chain_id, + main_sel_op_cmov, main_sel_op_coinbase, main_sel_op_dagasleft, main_sel_op_div, @@ -2148,15 +2135,22 @@ class AvmFlavor { main_sel_op_emit_nullifier, main_sel_op_emit_unencrypted_log, main_sel_op_eq, + main_sel_op_external_call, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, main_sel_op_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, @@ -2177,6 +2171,12 @@ class AvmFlavor { main_sel_op_transaction_fee, main_sel_op_version, main_sel_op_xor, + main_sel_q_kernel_lookup, + main_sel_q_kernel_output_lookup, + main_sel_resolve_ind_addr_a, + main_sel_resolve_ind_addr_b, + main_sel_resolve_ind_addr_c, + main_sel_resolve_ind_addr_d, main_sel_rng_16, main_sel_rng_8, main_space_id, @@ -2189,24 +2189,24 @@ class AvmFlavor { mem_diff_lo, mem_diff_mid, mem_glob_addr, - mem_ind_op_a, - mem_ind_op_b, - mem_ind_op_c, - mem_ind_op_d, mem_last, mem_lastAccess, - mem_mem_sel, mem_one_min_inv, - mem_op_a, - mem_op_b, - mem_op_c, - mem_op_d, mem_r_in_tag, - mem_rng_chk_sel, mem_rw, - mem_sel_cmov, - mem_sel_mov_a, - mem_sel_mov_b, + 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_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, @@ -2217,15 +2217,15 @@ class AvmFlavor { pedersen_clk, pedersen_input, pedersen_output, - pedersen_pedersen_sel, + pedersen_sel_pedersen, poseidon2_clk, poseidon2_input, poseidon2_output, - poseidon2_poseidon_perm_sel, + poseidon2_sel_poseidon_perm, sha256_clk, sha256_input, sha256_output, - sha256_sha256_compression_sel, + sha256_sel_sha256_compression, sha256_state, perm_main_alu, perm_main_bin, @@ -2236,10 +2236,10 @@ class AvmFlavor { perm_main_mem_b, perm_main_mem_c, perm_main_mem_d, - perm_main_mem_ind_a, - perm_main_mem_ind_b, - perm_main_mem_ind_c, - perm_main_mem_ind_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_opcode_gas, @@ -2327,12 +2327,9 @@ class AvmFlavor { { return { alu_a_hi, alu_a_lo, - alu_alu_sel, alu_b_hi, alu_b_lo, alu_cmp_rng_ctr, - alu_cmp_sel, - alu_div_rng_chk_selector, alu_div_u16_r0, alu_div_u16_r1, alu_div_u16_r2, @@ -2353,8 +2350,11 @@ class AvmFlavor { alu_p_sub_a_lo, alu_p_sub_b_hi, alu_p_sub_b_lo, - alu_rng_chk_lookup_selector, - alu_rng_chk_sel, + alu_sel_alu, + alu_sel_cmp, + alu_sel_div_rng_chk, + alu_sel_rng_chk_lookup, + alu_sel_rng_chk, alu_u16_r0, alu_u16_r1, alu_u16_r2, @@ -2385,8 +2385,8 @@ class AvmFlavor { main_l2_gas_remaining, main_pc, mem_glob_addr, - mem_mem_sel, mem_rw, + mem_sel_mem, mem_tag, mem_tsp, mem_val }; @@ -2395,12 +2395,9 @@ class AvmFlavor { { return { alu_a_hi_shift, alu_a_lo_shift, - alu_alu_sel_shift, alu_b_hi_shift, alu_b_lo_shift, alu_cmp_rng_ctr_shift, - alu_cmp_sel_shift, - alu_div_rng_chk_selector_shift, alu_div_u16_r0_shift, alu_div_u16_r1_shift, alu_div_u16_r2_shift, @@ -2421,8 +2418,11 @@ class AvmFlavor { alu_p_sub_a_lo_shift, alu_p_sub_b_hi_shift, alu_p_sub_b_lo_shift, - alu_rng_chk_lookup_selector_shift, - alu_rng_chk_sel_shift, + alu_sel_alu_shift, + alu_sel_cmp_shift, + alu_sel_div_rng_chk_shift, + alu_sel_rng_chk_lookup_shift, + alu_sel_rng_chk_shift, alu_u16_r0_shift, alu_u16_r1_shift, alu_u16_r2_shift, @@ -2453,8 +2453,8 @@ class AvmFlavor { main_l2_gas_remaining_shift, main_pc_shift, mem_glob_addr_shift, - mem_mem_sel_shift, mem_rw_shift, + mem_sel_mem_shift, mem_tag_shift, mem_tsp_shift, mem_val_shift }; @@ -2473,12 +2473,9 @@ class AvmFlavor { { return { alu_a_hi, alu_a_lo, - alu_alu_sel, alu_b_hi, alu_b_lo, alu_cmp_rng_ctr, - alu_cmp_sel, - alu_div_rng_chk_selector, alu_div_u16_r0, alu_div_u16_r1, alu_div_u16_r2, @@ -2499,8 +2496,11 @@ class AvmFlavor { alu_p_sub_a_lo, alu_p_sub_b_hi, alu_p_sub_b_lo, - alu_rng_chk_lookup_selector, - alu_rng_chk_sel, + alu_sel_alu, + alu_sel_cmp, + alu_sel_div_rng_chk, + alu_sel_rng_chk_lookup, + alu_sel_rng_chk, alu_u16_r0, alu_u16_r1, alu_u16_r2, @@ -2531,8 +2531,8 @@ class AvmFlavor { main_l2_gas_remaining, main_pc, mem_glob_addr, - mem_mem_sel, mem_rw, + mem_sel_mem, mem_tag, mem_tsp, mem_val }; @@ -2560,13 +2560,13 @@ class AvmFlavor { prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); @@ -2747,18 +2747,15 @@ class AvmFlavor { : AllEntities() { Base::main_clk = "MAIN_CLK"; - Base::main_first = "MAIN_FIRST"; + Base::main_sel_first = "MAIN_SEL_FIRST"; Base::alu_a_hi = "ALU_A_HI"; Base::alu_a_lo = "ALU_A_LO"; - Base::alu_alu_sel = "ALU_ALU_SEL"; Base::alu_b_hi = "ALU_B_HI"; Base::alu_b_lo = "ALU_B_LO"; Base::alu_borrow = "ALU_BORROW"; Base::alu_cf = "ALU_CF"; Base::alu_clk = "ALU_CLK"; Base::alu_cmp_rng_ctr = "ALU_CMP_RNG_CTR"; - Base::alu_cmp_sel = "ALU_CMP_SEL"; - Base::alu_div_rng_chk_selector = "ALU_DIV_RNG_CHK_SELECTOR"; Base::alu_div_u16_r0 = "ALU_DIV_U16_R0"; Base::alu_div_u16_r1 = "ALU_DIV_U16_R1"; Base::alu_div_u16_r2 = "ALU_DIV_U16_R2"; @@ -2802,10 +2799,13 @@ class AvmFlavor { Base::alu_remainder = "ALU_REMAINDER"; Base::alu_res_hi = "ALU_RES_HI"; Base::alu_res_lo = "ALU_RES_LO"; - Base::alu_rng_chk_lookup_selector = "ALU_RNG_CHK_LOOKUP_SELECTOR"; - Base::alu_rng_chk_sel = "ALU_RNG_CHK_SEL"; + Base::alu_sel_alu = "ALU_SEL_ALU"; + Base::alu_sel_cmp = "ALU_SEL_CMP"; + Base::alu_sel_div_rng_chk = "ALU_SEL_DIV_RNG_CHK"; + Base::alu_sel_rng_chk = "ALU_SEL_RNG_CHK"; + Base::alu_sel_rng_chk_lookup = "ALU_SEL_RNG_CHK_LOOKUP"; + Base::alu_sel_shift_which = "ALU_SEL_SHIFT_WHICH"; Base::alu_shift_lt_bit_len = "ALU_SHIFT_LT_BIT_LEN"; - Base::alu_shift_sel = "ALU_SHIFT_SEL"; Base::alu_t_sub_s_bits = "ALU_T_SUB_S_BITS"; Base::alu_two_pow_s = "ALU_TWO_POW_S"; Base::alu_two_pow_t_sub_s = "ALU_TWO_POW_T_SUB_S"; @@ -2834,7 +2834,6 @@ class AvmFlavor { Base::binary_acc_ia = "BINARY_ACC_IA"; Base::binary_acc_ib = "BINARY_ACC_IB"; Base::binary_acc_ic = "BINARY_ACC_IC"; - Base::binary_bin_sel = "BINARY_BIN_SEL"; Base::binary_clk = "BINARY_CLK"; Base::binary_ia_bytes = "BINARY_IA_BYTES"; Base::binary_ib_bytes = "BINARY_IB_BYTES"; @@ -2843,8 +2842,9 @@ class AvmFlavor { Base::binary_mem_tag_ctr = "BINARY_MEM_TAG_CTR"; Base::binary_mem_tag_ctr_inv = "BINARY_MEM_TAG_CTR_INV"; Base::binary_op_id = "BINARY_OP_ID"; + Base::binary_sel_bin = "BINARY_SEL_BIN"; Base::binary_start = "BINARY_START"; - Base::byte_lookup_bin_sel = "BYTE_LOOKUP_BIN_SEL"; + Base::byte_lookup_sel_bin = "BYTE_LOOKUP_SEL_BIN"; Base::byte_lookup_table_byte_lengths = "BYTE_LOOKUP_TABLE_BYTE_LENGTHS"; Base::byte_lookup_table_in_tags = "BYTE_LOOKUP_TABLE_IN_TAGS"; Base::byte_lookup_table_input_a = "BYTE_LOOKUP_TABLE_INPUT_A"; @@ -2855,14 +2855,14 @@ class AvmFlavor { Base::conversion_input = "CONVERSION_INPUT"; Base::conversion_num_limbs = "CONVERSION_NUM_LIMBS"; Base::conversion_radix = "CONVERSION_RADIX"; - Base::conversion_to_radix_le_sel = "CONVERSION_TO_RADIX_LE_SEL"; + Base::conversion_sel_to_radix_le = "CONVERSION_SEL_TO_RADIX_LE"; Base::gas_da_gas_fixed_table = "GAS_DA_GAS_FIXED_TABLE"; - Base::gas_gas_cost_sel = "GAS_GAS_COST_SEL"; Base::gas_l2_gas_fixed_table = "GAS_L2_GAS_FIXED_TABLE"; + Base::gas_sel_gas_cost = "GAS_SEL_GAS_COST"; Base::keccakf1600_clk = "KECCAKF1600_CLK"; Base::keccakf1600_input = "KECCAKF1600_INPUT"; - Base::keccakf1600_keccakf1600_sel = "KECCAKF1600_KECCAKF1600_SEL"; Base::keccakf1600_output = "KECCAKF1600_OUTPUT"; + Base::keccakf1600_sel_keccakf1600 = "KECCAKF1600_SEL_KECCAKF1600"; Base::kernel_emit_l2_to_l1_msg_write_offset = "KERNEL_EMIT_L2_TO_L1_MSG_WRITE_OFFSET"; Base::kernel_emit_note_hash_write_offset = "KERNEL_EMIT_NOTE_HASH_WRITE_OFFSET"; Base::kernel_emit_nullifier_write_offset = "KERNEL_EMIT_NULLIFIER_WRITE_OFFSET"; @@ -2887,68 +2887,55 @@ class AvmFlavor { Base::main_abs_l2_rem_gas_hi = "MAIN_ABS_L2_REM_GAS_HI"; Base::main_abs_l2_rem_gas_lo = "MAIN_ABS_L2_REM_GAS_LO"; Base::main_alu_in_tag = "MAIN_ALU_IN_TAG"; - Base::main_alu_sel = "MAIN_ALU_SEL"; Base::main_bin_op_id = "MAIN_BIN_OP_ID"; - Base::main_bin_sel = "MAIN_BIN_SEL"; Base::main_call_ptr = "MAIN_CALL_PTR"; - Base::main_da_gas_op = "MAIN_DA_GAS_OP"; + Base::main_da_gas_op_cost = "MAIN_DA_GAS_OP_COST"; Base::main_da_gas_remaining = "MAIN_DA_GAS_REMAINING"; Base::main_da_out_of_gas = "MAIN_DA_OUT_OF_GAS"; - Base::main_gas_cost_active = "MAIN_GAS_COST_ACTIVE"; Base::main_ia = "MAIN_IA"; Base::main_ib = "MAIN_IB"; Base::main_ic = "MAIN_IC"; Base::main_id = "MAIN_ID"; Base::main_id_zero = "MAIN_ID_ZERO"; - Base::main_ind_a = "MAIN_IND_A"; - Base::main_ind_b = "MAIN_IND_B"; - Base::main_ind_c = "MAIN_IND_C"; - Base::main_ind_d = "MAIN_IND_D"; - Base::main_ind_op_a = "MAIN_IND_OP_A"; - Base::main_ind_op_b = "MAIN_IND_OP_B"; - Base::main_ind_op_c = "MAIN_IND_OP_C"; - Base::main_ind_op_d = "MAIN_IND_OP_D"; + Base::main_ind_addr_a = "MAIN_IND_ADDR_A"; + Base::main_ind_addr_b = "MAIN_IND_ADDR_B"; + Base::main_ind_addr_c = "MAIN_IND_ADDR_C"; + Base::main_ind_addr_d = "MAIN_IND_ADDR_D"; Base::main_internal_return_ptr = "MAIN_INTERNAL_RETURN_PTR"; Base::main_inv = "MAIN_INV"; - Base::main_l2_gas_op = "MAIN_L2_GAS_OP"; + Base::main_l2_gas_op_cost = "MAIN_L2_GAS_OP_COST"; Base::main_l2_gas_remaining = "MAIN_L2_GAS_REMAINING"; Base::main_l2_out_of_gas = "MAIN_L2_OUT_OF_GAS"; - Base::main_last = "MAIN_LAST"; - Base::main_mem_idx_a = "MAIN_MEM_IDX_A"; - Base::main_mem_idx_b = "MAIN_MEM_IDX_B"; - Base::main_mem_idx_c = "MAIN_MEM_IDX_C"; - Base::main_mem_idx_d = "MAIN_MEM_IDX_D"; - Base::main_mem_op_a = "MAIN_MEM_OP_A"; - Base::main_mem_op_activate_gas = "MAIN_MEM_OP_ACTIVATE_GAS"; - Base::main_mem_op_b = "MAIN_MEM_OP_B"; - Base::main_mem_op_c = "MAIN_MEM_OP_C"; - Base::main_mem_op_d = "MAIN_MEM_OP_D"; + Base::main_mem_addr_a = "MAIN_MEM_ADDR_A"; + Base::main_mem_addr_b = "MAIN_MEM_ADDR_B"; + Base::main_mem_addr_c = "MAIN_MEM_ADDR_C"; + Base::main_mem_addr_d = "MAIN_MEM_ADDR_D"; Base::main_op_err = "MAIN_OP_ERR"; Base::main_opcode_val = "MAIN_OPCODE_VAL"; Base::main_pc = "MAIN_PC"; - Base::main_q_kernel_lookup = "MAIN_Q_KERNEL_LOOKUP"; - Base::main_q_kernel_output_lookup = "MAIN_Q_KERNEL_OUTPUT_LOOKUP"; Base::main_r_in_tag = "MAIN_R_IN_TAG"; Base::main_rwa = "MAIN_RWA"; Base::main_rwb = "MAIN_RWB"; Base::main_rwc = "MAIN_RWC"; Base::main_rwd = "MAIN_RWD"; - Base::main_sel_cmov = "MAIN_SEL_CMOV"; - Base::main_sel_external_call = "MAIN_SEL_EXTERNAL_CALL"; - Base::main_sel_halt = "MAIN_SEL_HALT"; - Base::main_sel_internal_call = "MAIN_SEL_INTERNAL_CALL"; - Base::main_sel_internal_return = "MAIN_SEL_INTERNAL_RETURN"; - Base::main_sel_jump = "MAIN_SEL_JUMP"; - Base::main_sel_jumpi = "MAIN_SEL_JUMPI"; - Base::main_sel_mov = "MAIN_SEL_MOV"; - Base::main_sel_mov_a = "MAIN_SEL_MOV_A"; - Base::main_sel_mov_b = "MAIN_SEL_MOV_B"; + Base::main_sel_alu = "MAIN_SEL_ALU"; + Base::main_sel_bin = "MAIN_SEL_BIN"; + 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"; + Base::main_sel_mem_op_activate_gas = "MAIN_SEL_MEM_OP_ACTIVATE_GAS"; + Base::main_sel_mem_op_b = "MAIN_SEL_MEM_OP_B"; + Base::main_sel_mem_op_c = "MAIN_SEL_MEM_OP_C"; + Base::main_sel_mem_op_d = "MAIN_SEL_MEM_OP_D"; + Base::main_sel_mov_ia_to_ic = "MAIN_SEL_MOV_IA_TO_IC"; + Base::main_sel_mov_ib_to_ic = "MAIN_SEL_MOV_IB_TO_IC"; Base::main_sel_op_add = "MAIN_SEL_OP_ADD"; 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_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"; Base::main_sel_op_coinbase = "MAIN_SEL_OP_COINBASE"; Base::main_sel_op_dagasleft = "MAIN_SEL_OP_DAGASLEFT"; Base::main_sel_op_div = "MAIN_SEL_OP_DIV"; @@ -2957,15 +2944,22 @@ class AvmFlavor { Base::main_sel_op_emit_nullifier = "MAIN_SEL_OP_EMIT_NULLIFIER"; 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_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"; Base::main_sel_op_get_contract_instance = "MAIN_SEL_OP_GET_CONTRACT_INSTANCE"; + Base::main_sel_op_halt = "MAIN_SEL_OP_HALT"; + Base::main_sel_op_internal_call = "MAIN_SEL_OP_INTERNAL_CALL"; + Base::main_sel_op_internal_return = "MAIN_SEL_OP_INTERNAL_RETURN"; + Base::main_sel_op_jump = "MAIN_SEL_OP_JUMP"; + Base::main_sel_op_jumpi = "MAIN_SEL_OP_JUMPI"; Base::main_sel_op_keccak = "MAIN_SEL_OP_KECCAK"; Base::main_sel_op_l1_to_l2_msg_exists = "MAIN_SEL_OP_L1_TO_L2_MSG_EXISTS"; Base::main_sel_op_l2gasleft = "MAIN_SEL_OP_L2GASLEFT"; Base::main_sel_op_lt = "MAIN_SEL_OP_LT"; Base::main_sel_op_lte = "MAIN_SEL_OP_LTE"; + Base::main_sel_op_mov = "MAIN_SEL_OP_MOV"; Base::main_sel_op_mul = "MAIN_SEL_OP_MUL"; Base::main_sel_op_not = "MAIN_SEL_OP_NOT"; Base::main_sel_op_note_hash_exists = "MAIN_SEL_OP_NOTE_HASH_EXISTS"; @@ -2986,6 +2980,12 @@ class AvmFlavor { Base::main_sel_op_transaction_fee = "MAIN_SEL_OP_TRANSACTION_FEE"; Base::main_sel_op_version = "MAIN_SEL_OP_VERSION"; Base::main_sel_op_xor = "MAIN_SEL_OP_XOR"; + Base::main_sel_q_kernel_lookup = "MAIN_SEL_Q_KERNEL_LOOKUP"; + Base::main_sel_q_kernel_output_lookup = "MAIN_SEL_Q_KERNEL_OUTPUT_LOOKUP"; + Base::main_sel_resolve_ind_addr_a = "MAIN_SEL_RESOLVE_IND_ADDR_A"; + 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_rng_16 = "MAIN_SEL_RNG_16"; Base::main_sel_rng_8 = "MAIN_SEL_RNG_8"; Base::main_space_id = "MAIN_SPACE_ID"; @@ -2998,24 +2998,24 @@ class AvmFlavor { Base::mem_diff_lo = "MEM_DIFF_LO"; Base::mem_diff_mid = "MEM_DIFF_MID"; Base::mem_glob_addr = "MEM_GLOB_ADDR"; - Base::mem_ind_op_a = "MEM_IND_OP_A"; - Base::mem_ind_op_b = "MEM_IND_OP_B"; - Base::mem_ind_op_c = "MEM_IND_OP_C"; - Base::mem_ind_op_d = "MEM_IND_OP_D"; Base::mem_last = "MEM_LAST"; Base::mem_lastAccess = "MEM_LASTACCESS"; - Base::mem_mem_sel = "MEM_MEM_SEL"; Base::mem_one_min_inv = "MEM_ONE_MIN_INV"; - Base::mem_op_a = "MEM_OP_A"; - Base::mem_op_b = "MEM_OP_B"; - Base::mem_op_c = "MEM_OP_C"; - Base::mem_op_d = "MEM_OP_D"; Base::mem_r_in_tag = "MEM_R_IN_TAG"; - Base::mem_rng_chk_sel = "MEM_RNG_CHK_SEL"; Base::mem_rw = "MEM_RW"; - Base::mem_sel_cmov = "MEM_SEL_CMOV"; - Base::mem_sel_mov_a = "MEM_SEL_MOV_A"; - Base::mem_sel_mov_b = "MEM_SEL_MOV_B"; + Base::mem_sel_mem = "MEM_SEL_MEM"; + Base::mem_sel_mov_ia_to_ic = "MEM_SEL_MOV_IA_TO_IC"; + Base::mem_sel_mov_ib_to_ic = "MEM_SEL_MOV_IB_TO_IC"; + Base::mem_sel_op_a = "MEM_SEL_OP_A"; + Base::mem_sel_op_b = "MEM_SEL_OP_B"; + Base::mem_sel_op_c = "MEM_SEL_OP_C"; + Base::mem_sel_op_cmov = "MEM_SEL_OP_CMOV"; + Base::mem_sel_op_d = "MEM_SEL_OP_D"; + Base::mem_sel_resolve_ind_addr_a = "MEM_SEL_RESOLVE_IND_ADDR_A"; + 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"; + Base::mem_sel_resolve_ind_addr_d = "MEM_SEL_RESOLVE_IND_ADDR_D"; + Base::mem_sel_rng_chk = "MEM_SEL_RNG_CHK"; Base::mem_skip_check_tag = "MEM_SKIP_CHECK_TAG"; Base::mem_space_id = "MEM_SPACE_ID"; Base::mem_tag = "MEM_TAG"; @@ -3026,15 +3026,15 @@ class AvmFlavor { Base::pedersen_clk = "PEDERSEN_CLK"; Base::pedersen_input = "PEDERSEN_INPUT"; Base::pedersen_output = "PEDERSEN_OUTPUT"; - Base::pedersen_pedersen_sel = "PEDERSEN_PEDERSEN_SEL"; + Base::pedersen_sel_pedersen = "PEDERSEN_SEL_PEDERSEN"; Base::poseidon2_clk = "POSEIDON2_CLK"; Base::poseidon2_input = "POSEIDON2_INPUT"; Base::poseidon2_output = "POSEIDON2_OUTPUT"; - Base::poseidon2_poseidon_perm_sel = "POSEIDON2_POSEIDON_PERM_SEL"; + Base::poseidon2_sel_poseidon_perm = "POSEIDON2_SEL_POSEIDON_PERM"; Base::sha256_clk = "SHA256_CLK"; Base::sha256_input = "SHA256_INPUT"; Base::sha256_output = "SHA256_OUTPUT"; - Base::sha256_sha256_compression_sel = "SHA256_SHA256_COMPRESSION_SEL"; + Base::sha256_sel_sha256_compression = "SHA256_SEL_SHA256_COMPRESSION"; Base::sha256_state = "SHA256_STATE"; Base::perm_main_alu = "PERM_MAIN_ALU"; Base::perm_main_bin = "PERM_MAIN_BIN"; @@ -3045,10 +3045,10 @@ class AvmFlavor { Base::perm_main_mem_b = "PERM_MAIN_MEM_B"; Base::perm_main_mem_c = "PERM_MAIN_MEM_C"; Base::perm_main_mem_d = "PERM_MAIN_MEM_D"; - Base::perm_main_mem_ind_a = "PERM_MAIN_MEM_IND_A"; - Base::perm_main_mem_ind_b = "PERM_MAIN_MEM_IND_B"; - Base::perm_main_mem_ind_c = "PERM_MAIN_MEM_IND_C"; - Base::perm_main_mem_ind_d = "PERM_MAIN_MEM_IND_D"; + Base::perm_main_mem_ind_addr_a = "PERM_MAIN_MEM_IND_ADDR_A"; + Base::perm_main_mem_ind_addr_b = "PERM_MAIN_MEM_IND_ADDR_B"; + Base::perm_main_mem_ind_addr_c = "PERM_MAIN_MEM_IND_ADDR_C"; + 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_opcode_gas = "LOOKUP_OPCODE_GAS"; @@ -3142,7 +3142,7 @@ class AvmFlavor { VerifierCommitments(const std::shared_ptr& verification_key) { main_clk = verification_key->main_clk; - main_first = verification_key->main_first; + main_sel_first = verification_key->main_sel_first; } }; @@ -3152,15 +3152,12 @@ class AvmFlavor { Commitment alu_a_hi; Commitment alu_a_lo; - Commitment alu_alu_sel; Commitment alu_b_hi; Commitment alu_b_lo; Commitment alu_borrow; Commitment alu_cf; Commitment alu_clk; Commitment alu_cmp_rng_ctr; - Commitment alu_cmp_sel; - Commitment alu_div_rng_chk_selector; Commitment alu_div_u16_r0; Commitment alu_div_u16_r1; Commitment alu_div_u16_r2; @@ -3204,10 +3201,13 @@ class AvmFlavor { Commitment alu_remainder; Commitment alu_res_hi; Commitment alu_res_lo; - Commitment alu_rng_chk_lookup_selector; - Commitment alu_rng_chk_sel; + Commitment alu_sel_alu; + Commitment alu_sel_cmp; + Commitment alu_sel_div_rng_chk; + Commitment alu_sel_rng_chk; + Commitment alu_sel_rng_chk_lookup; + Commitment alu_sel_shift_which; Commitment alu_shift_lt_bit_len; - Commitment alu_shift_sel; Commitment alu_t_sub_s_bits; Commitment alu_two_pow_s; Commitment alu_two_pow_t_sub_s; @@ -3236,7 +3236,6 @@ class AvmFlavor { Commitment binary_acc_ia; Commitment binary_acc_ib; Commitment binary_acc_ic; - Commitment binary_bin_sel; Commitment binary_clk; Commitment binary_ia_bytes; Commitment binary_ib_bytes; @@ -3245,8 +3244,9 @@ class AvmFlavor { Commitment binary_mem_tag_ctr; Commitment binary_mem_tag_ctr_inv; Commitment binary_op_id; + Commitment binary_sel_bin; Commitment binary_start; - Commitment byte_lookup_bin_sel; + Commitment byte_lookup_sel_bin; Commitment byte_lookup_table_byte_lengths; Commitment byte_lookup_table_in_tags; Commitment byte_lookup_table_input_a; @@ -3257,14 +3257,14 @@ class AvmFlavor { Commitment conversion_input; Commitment conversion_num_limbs; Commitment conversion_radix; - Commitment conversion_to_radix_le_sel; + Commitment conversion_sel_to_radix_le; Commitment gas_da_gas_fixed_table; - Commitment gas_gas_cost_sel; Commitment gas_l2_gas_fixed_table; + Commitment gas_sel_gas_cost; Commitment keccakf1600_clk; Commitment keccakf1600_input; - Commitment keccakf1600_keccakf1600_sel; Commitment keccakf1600_output; + Commitment keccakf1600_sel_keccakf1600; Commitment kernel_emit_l2_to_l1_msg_write_offset; Commitment kernel_emit_note_hash_write_offset; Commitment kernel_emit_nullifier_write_offset; @@ -3289,68 +3289,55 @@ class AvmFlavor { Commitment main_abs_l2_rem_gas_hi; Commitment main_abs_l2_rem_gas_lo; Commitment main_alu_in_tag; - Commitment main_alu_sel; Commitment main_bin_op_id; - Commitment main_bin_sel; Commitment main_call_ptr; - Commitment main_da_gas_op; + Commitment main_da_gas_op_cost; Commitment main_da_gas_remaining; Commitment main_da_out_of_gas; - Commitment main_gas_cost_active; Commitment main_ia; Commitment main_ib; Commitment main_ic; Commitment main_id; Commitment main_id_zero; - Commitment main_ind_a; - Commitment main_ind_b; - Commitment main_ind_c; - Commitment main_ind_d; - Commitment main_ind_op_a; - Commitment main_ind_op_b; - Commitment main_ind_op_c; - Commitment main_ind_op_d; + Commitment main_ind_addr_a; + Commitment main_ind_addr_b; + Commitment main_ind_addr_c; + Commitment main_ind_addr_d; Commitment main_internal_return_ptr; Commitment main_inv; - Commitment main_l2_gas_op; + Commitment main_l2_gas_op_cost; Commitment main_l2_gas_remaining; Commitment main_l2_out_of_gas; - Commitment main_last; - Commitment main_mem_idx_a; - Commitment main_mem_idx_b; - Commitment main_mem_idx_c; - Commitment main_mem_idx_d; - Commitment main_mem_op_a; - Commitment main_mem_op_activate_gas; - Commitment main_mem_op_b; - Commitment main_mem_op_c; - Commitment main_mem_op_d; + Commitment main_mem_addr_a; + Commitment main_mem_addr_b; + Commitment main_mem_addr_c; + Commitment main_mem_addr_d; Commitment main_op_err; Commitment main_opcode_val; Commitment main_pc; - Commitment main_q_kernel_lookup; - Commitment main_q_kernel_output_lookup; Commitment main_r_in_tag; Commitment main_rwa; Commitment main_rwb; Commitment main_rwc; Commitment main_rwd; - Commitment main_sel_cmov; - Commitment main_sel_external_call; - Commitment main_sel_halt; - Commitment main_sel_internal_call; - Commitment main_sel_internal_return; - Commitment main_sel_jump; - Commitment main_sel_jumpi; - Commitment main_sel_mov; - Commitment main_sel_mov_a; - Commitment main_sel_mov_b; + Commitment main_sel_alu; + Commitment main_sel_bin; + Commitment main_sel_gas_accounting_active; + Commitment main_sel_last; + Commitment main_sel_mem_op_a; + Commitment main_sel_mem_op_activate_gas; + Commitment main_sel_mem_op_b; + Commitment main_sel_mem_op_c; + Commitment main_sel_mem_op_d; + Commitment main_sel_mov_ia_to_ic; + Commitment main_sel_mov_ib_to_ic; Commitment main_sel_op_add; Commitment main_sel_op_address; Commitment main_sel_op_and; Commitment main_sel_op_block_number; Commitment main_sel_op_cast; Commitment main_sel_op_chain_id; + Commitment main_sel_op_cmov; Commitment main_sel_op_coinbase; Commitment main_sel_op_dagasleft; Commitment main_sel_op_div; @@ -3359,15 +3346,22 @@ class AvmFlavor { Commitment main_sel_op_emit_nullifier; Commitment main_sel_op_emit_unencrypted_log; Commitment main_sel_op_eq; + Commitment main_sel_op_external_call; Commitment main_sel_op_fdiv; Commitment main_sel_op_fee_per_da_gas; Commitment main_sel_op_fee_per_l2_gas; Commitment main_sel_op_get_contract_instance; + Commitment main_sel_op_halt; + Commitment main_sel_op_internal_call; + Commitment main_sel_op_internal_return; + Commitment main_sel_op_jump; + Commitment main_sel_op_jumpi; Commitment main_sel_op_keccak; Commitment main_sel_op_l1_to_l2_msg_exists; Commitment main_sel_op_l2gasleft; Commitment main_sel_op_lt; Commitment main_sel_op_lte; + Commitment main_sel_op_mov; Commitment main_sel_op_mul; Commitment main_sel_op_not; Commitment main_sel_op_note_hash_exists; @@ -3388,6 +3382,12 @@ class AvmFlavor { Commitment main_sel_op_transaction_fee; Commitment main_sel_op_version; Commitment main_sel_op_xor; + Commitment main_sel_q_kernel_lookup; + Commitment main_sel_q_kernel_output_lookup; + Commitment main_sel_resolve_ind_addr_a; + Commitment main_sel_resolve_ind_addr_b; + Commitment main_sel_resolve_ind_addr_c; + Commitment main_sel_resolve_ind_addr_d; Commitment main_sel_rng_16; Commitment main_sel_rng_8; Commitment main_space_id; @@ -3400,24 +3400,24 @@ class AvmFlavor { Commitment mem_diff_lo; Commitment mem_diff_mid; Commitment mem_glob_addr; - Commitment mem_ind_op_a; - Commitment mem_ind_op_b; - Commitment mem_ind_op_c; - Commitment mem_ind_op_d; Commitment mem_last; Commitment mem_lastAccess; - Commitment mem_mem_sel; Commitment mem_one_min_inv; - Commitment mem_op_a; - Commitment mem_op_b; - Commitment mem_op_c; - Commitment mem_op_d; Commitment mem_r_in_tag; - Commitment mem_rng_chk_sel; Commitment mem_rw; - Commitment mem_sel_cmov; - Commitment mem_sel_mov_a; - Commitment mem_sel_mov_b; + Commitment mem_sel_mem; + Commitment mem_sel_mov_ia_to_ic; + Commitment mem_sel_mov_ib_to_ic; + Commitment mem_sel_op_a; + Commitment mem_sel_op_b; + Commitment mem_sel_op_c; + Commitment mem_sel_op_cmov; + Commitment mem_sel_op_d; + Commitment mem_sel_resolve_ind_addr_a; + Commitment mem_sel_resolve_ind_addr_b; + Commitment mem_sel_resolve_ind_addr_c; + Commitment mem_sel_resolve_ind_addr_d; + Commitment mem_sel_rng_chk; Commitment mem_skip_check_tag; Commitment mem_space_id; Commitment mem_tag; @@ -3428,15 +3428,15 @@ class AvmFlavor { Commitment pedersen_clk; Commitment pedersen_input; Commitment pedersen_output; - Commitment pedersen_pedersen_sel; + Commitment pedersen_sel_pedersen; Commitment poseidon2_clk; Commitment poseidon2_input; Commitment poseidon2_output; - Commitment poseidon2_poseidon_perm_sel; + Commitment poseidon2_sel_poseidon_perm; Commitment sha256_clk; Commitment sha256_input; Commitment sha256_output; - Commitment sha256_sha256_compression_sel; + Commitment sha256_sel_sha256_compression; Commitment sha256_state; Commitment perm_main_alu; Commitment perm_main_bin; @@ -3447,10 +3447,10 @@ class AvmFlavor { Commitment perm_main_mem_b; Commitment perm_main_mem_c; Commitment perm_main_mem_d; - Commitment perm_main_mem_ind_a; - Commitment perm_main_mem_ind_b; - Commitment perm_main_mem_ind_c; - Commitment perm_main_mem_ind_d; + Commitment perm_main_mem_ind_addr_a; + Commitment perm_main_mem_ind_addr_b; + Commitment perm_main_mem_ind_addr_c; + Commitment perm_main_mem_ind_addr_d; Commitment lookup_byte_lengths; Commitment lookup_byte_operations; Commitment lookup_opcode_gas; @@ -3554,15 +3554,12 @@ class AvmFlavor { alu_a_hi = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_a_lo = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - alu_alu_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_b_hi = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_b_lo = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_borrow = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_cf = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_clk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_cmp_rng_ctr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - alu_cmp_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - alu_div_rng_chk_selector = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_div_u16_r0 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_div_u16_r1 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_div_u16_r2 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3606,10 +3603,13 @@ class AvmFlavor { alu_remainder = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_res_hi = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_res_lo = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - alu_rng_chk_lookup_selector = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - alu_rng_chk_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + alu_sel_alu = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + alu_sel_cmp = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + alu_sel_div_rng_chk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + alu_sel_rng_chk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + alu_sel_rng_chk_lookup = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + alu_sel_shift_which = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_shift_lt_bit_len = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - alu_shift_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_t_sub_s_bits = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_two_pow_s = deserialize_from_buffer(Transcript::proof_data, num_frs_read); alu_two_pow_t_sub_s = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3638,7 +3638,6 @@ class AvmFlavor { binary_acc_ia = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_acc_ib = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_acc_ic = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - binary_bin_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_clk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_ia_bytes = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_ib_bytes = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3647,8 +3646,9 @@ class AvmFlavor { binary_mem_tag_ctr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_mem_tag_ctr_inv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_op_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + binary_sel_bin = deserialize_from_buffer(Transcript::proof_data, num_frs_read); binary_start = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - byte_lookup_bin_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + byte_lookup_sel_bin = deserialize_from_buffer(Transcript::proof_data, num_frs_read); byte_lookup_table_byte_lengths = deserialize_from_buffer(Transcript::proof_data, num_frs_read); byte_lookup_table_in_tags = deserialize_from_buffer(Transcript::proof_data, num_frs_read); byte_lookup_table_input_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3659,14 +3659,14 @@ class AvmFlavor { conversion_input = deserialize_from_buffer(Transcript::proof_data, num_frs_read); conversion_num_limbs = deserialize_from_buffer(Transcript::proof_data, num_frs_read); conversion_radix = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - conversion_to_radix_le_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + conversion_sel_to_radix_le = deserialize_from_buffer(Transcript::proof_data, num_frs_read); gas_da_gas_fixed_table = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - gas_gas_cost_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); gas_l2_gas_fixed_table = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + gas_sel_gas_cost = deserialize_from_buffer(Transcript::proof_data, num_frs_read); keccakf1600_clk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); keccakf1600_input = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - keccakf1600_keccakf1600_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); keccakf1600_output = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + keccakf1600_sel_keccakf1600 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); kernel_emit_l2_to_l1_msg_write_offset = deserialize_from_buffer(Transcript::proof_data, num_frs_read); kernel_emit_note_hash_write_offset = @@ -3701,68 +3701,55 @@ class AvmFlavor { main_abs_l2_rem_gas_hi = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_abs_l2_rem_gas_lo = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_alu_in_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_alu_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_bin_op_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_bin_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_call_ptr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_da_gas_op = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_da_gas_op_cost = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_da_gas_remaining = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_da_out_of_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_gas_cost_active = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_ia = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_ib = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_ic = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_id_zero = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_op_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_op_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_op_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_ind_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_ind_addr_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_ind_addr_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_ind_addr_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_ind_addr_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_internal_return_ptr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_inv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_l2_gas_op = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_l2_gas_op_cost = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_l2_gas_remaining = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_l2_out_of_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_last = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_idx_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_idx_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_idx_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_idx_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_op_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_op_activate_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_op_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_op_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_mem_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_mem_addr_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_mem_addr_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_mem_addr_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_mem_addr_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_op_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_opcode_val = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_pc = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_q_kernel_lookup = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_q_kernel_output_lookup = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_r_in_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_rwa = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_rwb = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_rwc = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_rwd = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_cmov = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_external_call = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_halt = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_internal_call = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_internal_return = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_jump = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_jumpi = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_mov = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_mov_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - main_sel_mov_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_alu = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_bin = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_gas_accounting_active = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_last = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_mem_op_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_mem_op_activate_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_mem_op_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_mem_op_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_mem_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_mov_ia_to_ic = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_mov_ib_to_ic = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_add = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_address = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_and = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_block_number = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_cast = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_chain_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_cmov = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_coinbase = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_dagasleft = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_div = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3772,16 +3759,23 @@ class AvmFlavor { main_sel_op_emit_unencrypted_log = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_eq = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_external_call = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_fdiv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_fee_per_da_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_fee_per_l2_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_get_contract_instance = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_halt = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_internal_call = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_internal_return = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_jump = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_jumpi = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_keccak = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_l1_to_l2_msg_exists = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_l2gasleft = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_lt = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_lte = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_op_mov = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_mul = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_not = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_note_hash_exists = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3802,6 +3796,12 @@ class AvmFlavor { main_sel_op_transaction_fee = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_version = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_op_xor = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_q_kernel_lookup = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_q_kernel_output_lookup = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_resolve_ind_addr_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_resolve_ind_addr_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_resolve_ind_addr_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + main_sel_resolve_ind_addr_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_rng_16 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_sel_rng_8 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); main_space_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3814,24 +3814,24 @@ class AvmFlavor { mem_diff_lo = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_diff_mid = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_glob_addr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_ind_op_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_ind_op_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_ind_op_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_ind_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_last = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_lastAccess = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_mem_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_one_min_inv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_op_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_op_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_op_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_r_in_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_rng_chk_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_rw = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_sel_cmov = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_sel_mov_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - mem_sel_mov_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_mem = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_mov_ia_to_ic = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_mov_ib_to_ic = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_op_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_op_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_op_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_op_cmov = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_resolve_ind_addr_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_resolve_ind_addr_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_resolve_ind_addr_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_resolve_ind_addr_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + mem_sel_rng_chk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_skip_check_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_space_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); mem_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3842,15 +3842,15 @@ class AvmFlavor { pedersen_clk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); pedersen_input = deserialize_from_buffer(Transcript::proof_data, num_frs_read); pedersen_output = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - pedersen_pedersen_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + pedersen_sel_pedersen = deserialize_from_buffer(Transcript::proof_data, num_frs_read); poseidon2_clk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); poseidon2_input = deserialize_from_buffer(Transcript::proof_data, num_frs_read); poseidon2_output = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - poseidon2_poseidon_perm_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + poseidon2_sel_poseidon_perm = deserialize_from_buffer(Transcript::proof_data, num_frs_read); sha256_clk = deserialize_from_buffer(Transcript::proof_data, num_frs_read); sha256_input = deserialize_from_buffer(Transcript::proof_data, num_frs_read); sha256_output = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - sha256_sha256_compression_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + sha256_sel_sha256_compression = deserialize_from_buffer(Transcript::proof_data, num_frs_read); sha256_state = deserialize_from_buffer(Transcript::proof_data, num_frs_read); perm_main_alu = deserialize_from_buffer(Transcript::proof_data, num_frs_read); perm_main_bin = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3861,10 +3861,10 @@ class AvmFlavor { perm_main_mem_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); perm_main_mem_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); perm_main_mem_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - perm_main_mem_ind_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - perm_main_mem_ind_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - perm_main_mem_ind_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - perm_main_mem_ind_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + perm_main_mem_ind_addr_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + perm_main_mem_ind_addr_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + perm_main_mem_ind_addr_c = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + perm_main_mem_ind_addr_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_lengths = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_operations = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_opcode_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3972,15 +3972,12 @@ class AvmFlavor { serialize_to_buffer(alu_a_hi, Transcript::proof_data); serialize_to_buffer(alu_a_lo, Transcript::proof_data); - serialize_to_buffer(alu_alu_sel, Transcript::proof_data); serialize_to_buffer(alu_b_hi, Transcript::proof_data); serialize_to_buffer(alu_b_lo, Transcript::proof_data); serialize_to_buffer(alu_borrow, Transcript::proof_data); serialize_to_buffer(alu_cf, Transcript::proof_data); serialize_to_buffer(alu_clk, Transcript::proof_data); serialize_to_buffer(alu_cmp_rng_ctr, Transcript::proof_data); - serialize_to_buffer(alu_cmp_sel, Transcript::proof_data); - serialize_to_buffer(alu_div_rng_chk_selector, Transcript::proof_data); serialize_to_buffer(alu_div_u16_r0, Transcript::proof_data); serialize_to_buffer(alu_div_u16_r1, Transcript::proof_data); serialize_to_buffer(alu_div_u16_r2, Transcript::proof_data); @@ -4024,10 +4021,13 @@ class AvmFlavor { serialize_to_buffer(alu_remainder, Transcript::proof_data); serialize_to_buffer(alu_res_hi, Transcript::proof_data); serialize_to_buffer(alu_res_lo, Transcript::proof_data); - serialize_to_buffer(alu_rng_chk_lookup_selector, Transcript::proof_data); - serialize_to_buffer(alu_rng_chk_sel, Transcript::proof_data); + serialize_to_buffer(alu_sel_alu, Transcript::proof_data); + serialize_to_buffer(alu_sel_cmp, Transcript::proof_data); + serialize_to_buffer(alu_sel_div_rng_chk, Transcript::proof_data); + serialize_to_buffer(alu_sel_rng_chk, Transcript::proof_data); + serialize_to_buffer(alu_sel_rng_chk_lookup, Transcript::proof_data); + serialize_to_buffer(alu_sel_shift_which, Transcript::proof_data); serialize_to_buffer(alu_shift_lt_bit_len, Transcript::proof_data); - serialize_to_buffer(alu_shift_sel, Transcript::proof_data); serialize_to_buffer(alu_t_sub_s_bits, Transcript::proof_data); serialize_to_buffer(alu_two_pow_s, Transcript::proof_data); serialize_to_buffer(alu_two_pow_t_sub_s, Transcript::proof_data); @@ -4056,7 +4056,6 @@ class AvmFlavor { serialize_to_buffer(binary_acc_ia, Transcript::proof_data); serialize_to_buffer(binary_acc_ib, Transcript::proof_data); serialize_to_buffer(binary_acc_ic, Transcript::proof_data); - serialize_to_buffer(binary_bin_sel, Transcript::proof_data); serialize_to_buffer(binary_clk, Transcript::proof_data); serialize_to_buffer(binary_ia_bytes, Transcript::proof_data); serialize_to_buffer(binary_ib_bytes, Transcript::proof_data); @@ -4065,8 +4064,9 @@ class AvmFlavor { serialize_to_buffer(binary_mem_tag_ctr, Transcript::proof_data); serialize_to_buffer(binary_mem_tag_ctr_inv, Transcript::proof_data); serialize_to_buffer(binary_op_id, Transcript::proof_data); + serialize_to_buffer(binary_sel_bin, Transcript::proof_data); serialize_to_buffer(binary_start, Transcript::proof_data); - serialize_to_buffer(byte_lookup_bin_sel, Transcript::proof_data); + serialize_to_buffer(byte_lookup_sel_bin, Transcript::proof_data); serialize_to_buffer(byte_lookup_table_byte_lengths, Transcript::proof_data); serialize_to_buffer(byte_lookup_table_in_tags, Transcript::proof_data); serialize_to_buffer(byte_lookup_table_input_a, Transcript::proof_data); @@ -4077,14 +4077,14 @@ class AvmFlavor { serialize_to_buffer(conversion_input, Transcript::proof_data); serialize_to_buffer(conversion_num_limbs, Transcript::proof_data); serialize_to_buffer(conversion_radix, Transcript::proof_data); - serialize_to_buffer(conversion_to_radix_le_sel, Transcript::proof_data); + serialize_to_buffer(conversion_sel_to_radix_le, Transcript::proof_data); serialize_to_buffer(gas_da_gas_fixed_table, Transcript::proof_data); - serialize_to_buffer(gas_gas_cost_sel, Transcript::proof_data); serialize_to_buffer(gas_l2_gas_fixed_table, Transcript::proof_data); + serialize_to_buffer(gas_sel_gas_cost, Transcript::proof_data); serialize_to_buffer(keccakf1600_clk, Transcript::proof_data); serialize_to_buffer(keccakf1600_input, Transcript::proof_data); - serialize_to_buffer(keccakf1600_keccakf1600_sel, Transcript::proof_data); serialize_to_buffer(keccakf1600_output, Transcript::proof_data); + serialize_to_buffer(keccakf1600_sel_keccakf1600, Transcript::proof_data); serialize_to_buffer(kernel_emit_l2_to_l1_msg_write_offset, Transcript::proof_data); serialize_to_buffer(kernel_emit_note_hash_write_offset, Transcript::proof_data); serialize_to_buffer(kernel_emit_nullifier_write_offset, Transcript::proof_data); @@ -4109,68 +4109,55 @@ class AvmFlavor { serialize_to_buffer(main_abs_l2_rem_gas_hi, Transcript::proof_data); serialize_to_buffer(main_abs_l2_rem_gas_lo, Transcript::proof_data); serialize_to_buffer(main_alu_in_tag, Transcript::proof_data); - serialize_to_buffer(main_alu_sel, Transcript::proof_data); serialize_to_buffer(main_bin_op_id, Transcript::proof_data); - serialize_to_buffer(main_bin_sel, Transcript::proof_data); serialize_to_buffer(main_call_ptr, Transcript::proof_data); - serialize_to_buffer(main_da_gas_op, Transcript::proof_data); + serialize_to_buffer(main_da_gas_op_cost, Transcript::proof_data); serialize_to_buffer(main_da_gas_remaining, Transcript::proof_data); serialize_to_buffer(main_da_out_of_gas, Transcript::proof_data); - serialize_to_buffer(main_gas_cost_active, Transcript::proof_data); serialize_to_buffer(main_ia, Transcript::proof_data); serialize_to_buffer(main_ib, Transcript::proof_data); serialize_to_buffer(main_ic, Transcript::proof_data); serialize_to_buffer(main_id, Transcript::proof_data); serialize_to_buffer(main_id_zero, Transcript::proof_data); - serialize_to_buffer(main_ind_a, Transcript::proof_data); - serialize_to_buffer(main_ind_b, Transcript::proof_data); - serialize_to_buffer(main_ind_c, Transcript::proof_data); - serialize_to_buffer(main_ind_d, Transcript::proof_data); - serialize_to_buffer(main_ind_op_a, Transcript::proof_data); - serialize_to_buffer(main_ind_op_b, Transcript::proof_data); - serialize_to_buffer(main_ind_op_c, Transcript::proof_data); - serialize_to_buffer(main_ind_op_d, Transcript::proof_data); + serialize_to_buffer(main_ind_addr_a, Transcript::proof_data); + serialize_to_buffer(main_ind_addr_b, Transcript::proof_data); + serialize_to_buffer(main_ind_addr_c, Transcript::proof_data); + serialize_to_buffer(main_ind_addr_d, Transcript::proof_data); serialize_to_buffer(main_internal_return_ptr, Transcript::proof_data); serialize_to_buffer(main_inv, Transcript::proof_data); - serialize_to_buffer(main_l2_gas_op, Transcript::proof_data); + serialize_to_buffer(main_l2_gas_op_cost, Transcript::proof_data); serialize_to_buffer(main_l2_gas_remaining, Transcript::proof_data); serialize_to_buffer(main_l2_out_of_gas, Transcript::proof_data); - serialize_to_buffer(main_last, Transcript::proof_data); - serialize_to_buffer(main_mem_idx_a, Transcript::proof_data); - serialize_to_buffer(main_mem_idx_b, Transcript::proof_data); - serialize_to_buffer(main_mem_idx_c, Transcript::proof_data); - serialize_to_buffer(main_mem_idx_d, Transcript::proof_data); - serialize_to_buffer(main_mem_op_a, Transcript::proof_data); - serialize_to_buffer(main_mem_op_activate_gas, Transcript::proof_data); - serialize_to_buffer(main_mem_op_b, Transcript::proof_data); - serialize_to_buffer(main_mem_op_c, Transcript::proof_data); - serialize_to_buffer(main_mem_op_d, Transcript::proof_data); + serialize_to_buffer(main_mem_addr_a, Transcript::proof_data); + serialize_to_buffer(main_mem_addr_b, Transcript::proof_data); + serialize_to_buffer(main_mem_addr_c, Transcript::proof_data); + serialize_to_buffer(main_mem_addr_d, Transcript::proof_data); serialize_to_buffer(main_op_err, Transcript::proof_data); serialize_to_buffer(main_opcode_val, Transcript::proof_data); serialize_to_buffer(main_pc, Transcript::proof_data); - serialize_to_buffer(main_q_kernel_lookup, Transcript::proof_data); - serialize_to_buffer(main_q_kernel_output_lookup, Transcript::proof_data); serialize_to_buffer(main_r_in_tag, Transcript::proof_data); serialize_to_buffer(main_rwa, Transcript::proof_data); serialize_to_buffer(main_rwb, Transcript::proof_data); serialize_to_buffer(main_rwc, Transcript::proof_data); serialize_to_buffer(main_rwd, Transcript::proof_data); - serialize_to_buffer(main_sel_cmov, Transcript::proof_data); - serialize_to_buffer(main_sel_external_call, Transcript::proof_data); - serialize_to_buffer(main_sel_halt, Transcript::proof_data); - serialize_to_buffer(main_sel_internal_call, Transcript::proof_data); - serialize_to_buffer(main_sel_internal_return, Transcript::proof_data); - serialize_to_buffer(main_sel_jump, Transcript::proof_data); - serialize_to_buffer(main_sel_jumpi, Transcript::proof_data); - serialize_to_buffer(main_sel_mov, Transcript::proof_data); - serialize_to_buffer(main_sel_mov_a, Transcript::proof_data); - serialize_to_buffer(main_sel_mov_b, Transcript::proof_data); + serialize_to_buffer(main_sel_alu, Transcript::proof_data); + serialize_to_buffer(main_sel_bin, Transcript::proof_data); + serialize_to_buffer(main_sel_gas_accounting_active, Transcript::proof_data); + serialize_to_buffer(main_sel_last, Transcript::proof_data); + serialize_to_buffer(main_sel_mem_op_a, Transcript::proof_data); + serialize_to_buffer(main_sel_mem_op_activate_gas, Transcript::proof_data); + serialize_to_buffer(main_sel_mem_op_b, Transcript::proof_data); + serialize_to_buffer(main_sel_mem_op_c, Transcript::proof_data); + serialize_to_buffer(main_sel_mem_op_d, Transcript::proof_data); + serialize_to_buffer(main_sel_mov_ia_to_ic, Transcript::proof_data); + serialize_to_buffer(main_sel_mov_ib_to_ic, Transcript::proof_data); serialize_to_buffer(main_sel_op_add, Transcript::proof_data); serialize_to_buffer(main_sel_op_address, Transcript::proof_data); serialize_to_buffer(main_sel_op_and, Transcript::proof_data); serialize_to_buffer(main_sel_op_block_number, Transcript::proof_data); serialize_to_buffer(main_sel_op_cast, Transcript::proof_data); serialize_to_buffer(main_sel_op_chain_id, Transcript::proof_data); + serialize_to_buffer(main_sel_op_cmov, Transcript::proof_data); serialize_to_buffer(main_sel_op_coinbase, Transcript::proof_data); serialize_to_buffer(main_sel_op_dagasleft, Transcript::proof_data); serialize_to_buffer(main_sel_op_div, Transcript::proof_data); @@ -4179,15 +4166,22 @@ class AvmFlavor { serialize_to_buffer(main_sel_op_emit_nullifier, Transcript::proof_data); serialize_to_buffer(main_sel_op_emit_unencrypted_log, Transcript::proof_data); serialize_to_buffer(main_sel_op_eq, Transcript::proof_data); + serialize_to_buffer(main_sel_op_external_call, Transcript::proof_data); serialize_to_buffer(main_sel_op_fdiv, Transcript::proof_data); serialize_to_buffer(main_sel_op_fee_per_da_gas, Transcript::proof_data); serialize_to_buffer(main_sel_op_fee_per_l2_gas, Transcript::proof_data); serialize_to_buffer(main_sel_op_get_contract_instance, Transcript::proof_data); + serialize_to_buffer(main_sel_op_halt, Transcript::proof_data); + serialize_to_buffer(main_sel_op_internal_call, Transcript::proof_data); + serialize_to_buffer(main_sel_op_internal_return, Transcript::proof_data); + serialize_to_buffer(main_sel_op_jump, Transcript::proof_data); + serialize_to_buffer(main_sel_op_jumpi, Transcript::proof_data); serialize_to_buffer(main_sel_op_keccak, Transcript::proof_data); serialize_to_buffer(main_sel_op_l1_to_l2_msg_exists, Transcript::proof_data); serialize_to_buffer(main_sel_op_l2gasleft, Transcript::proof_data); serialize_to_buffer(main_sel_op_lt, Transcript::proof_data); serialize_to_buffer(main_sel_op_lte, Transcript::proof_data); + serialize_to_buffer(main_sel_op_mov, Transcript::proof_data); serialize_to_buffer(main_sel_op_mul, Transcript::proof_data); serialize_to_buffer(main_sel_op_not, Transcript::proof_data); serialize_to_buffer(main_sel_op_note_hash_exists, Transcript::proof_data); @@ -4208,6 +4202,12 @@ class AvmFlavor { serialize_to_buffer(main_sel_op_transaction_fee, Transcript::proof_data); serialize_to_buffer(main_sel_op_version, Transcript::proof_data); serialize_to_buffer(main_sel_op_xor, Transcript::proof_data); + serialize_to_buffer(main_sel_q_kernel_lookup, Transcript::proof_data); + serialize_to_buffer(main_sel_q_kernel_output_lookup, Transcript::proof_data); + serialize_to_buffer(main_sel_resolve_ind_addr_a, Transcript::proof_data); + serialize_to_buffer(main_sel_resolve_ind_addr_b, Transcript::proof_data); + serialize_to_buffer(main_sel_resolve_ind_addr_c, Transcript::proof_data); + serialize_to_buffer(main_sel_resolve_ind_addr_d, Transcript::proof_data); serialize_to_buffer(main_sel_rng_16, Transcript::proof_data); serialize_to_buffer(main_sel_rng_8, Transcript::proof_data); serialize_to_buffer(main_space_id, Transcript::proof_data); @@ -4220,24 +4220,24 @@ class AvmFlavor { serialize_to_buffer(mem_diff_lo, Transcript::proof_data); serialize_to_buffer(mem_diff_mid, Transcript::proof_data); serialize_to_buffer(mem_glob_addr, Transcript::proof_data); - serialize_to_buffer(mem_ind_op_a, Transcript::proof_data); - serialize_to_buffer(mem_ind_op_b, Transcript::proof_data); - serialize_to_buffer(mem_ind_op_c, Transcript::proof_data); - serialize_to_buffer(mem_ind_op_d, Transcript::proof_data); serialize_to_buffer(mem_last, Transcript::proof_data); serialize_to_buffer(mem_lastAccess, Transcript::proof_data); - serialize_to_buffer(mem_mem_sel, Transcript::proof_data); serialize_to_buffer(mem_one_min_inv, Transcript::proof_data); - serialize_to_buffer(mem_op_a, Transcript::proof_data); - serialize_to_buffer(mem_op_b, Transcript::proof_data); - serialize_to_buffer(mem_op_c, Transcript::proof_data); - serialize_to_buffer(mem_op_d, Transcript::proof_data); serialize_to_buffer(mem_r_in_tag, Transcript::proof_data); - serialize_to_buffer(mem_rng_chk_sel, Transcript::proof_data); serialize_to_buffer(mem_rw, Transcript::proof_data); - serialize_to_buffer(mem_sel_cmov, Transcript::proof_data); - serialize_to_buffer(mem_sel_mov_a, Transcript::proof_data); - serialize_to_buffer(mem_sel_mov_b, Transcript::proof_data); + serialize_to_buffer(mem_sel_mem, Transcript::proof_data); + serialize_to_buffer(mem_sel_mov_ia_to_ic, Transcript::proof_data); + serialize_to_buffer(mem_sel_mov_ib_to_ic, Transcript::proof_data); + serialize_to_buffer(mem_sel_op_a, Transcript::proof_data); + serialize_to_buffer(mem_sel_op_b, Transcript::proof_data); + serialize_to_buffer(mem_sel_op_c, Transcript::proof_data); + serialize_to_buffer(mem_sel_op_cmov, Transcript::proof_data); + serialize_to_buffer(mem_sel_op_d, Transcript::proof_data); + serialize_to_buffer(mem_sel_resolve_ind_addr_a, Transcript::proof_data); + serialize_to_buffer(mem_sel_resolve_ind_addr_b, Transcript::proof_data); + serialize_to_buffer(mem_sel_resolve_ind_addr_c, Transcript::proof_data); + serialize_to_buffer(mem_sel_resolve_ind_addr_d, Transcript::proof_data); + serialize_to_buffer(mem_sel_rng_chk, Transcript::proof_data); serialize_to_buffer(mem_skip_check_tag, Transcript::proof_data); serialize_to_buffer(mem_space_id, Transcript::proof_data); serialize_to_buffer(mem_tag, Transcript::proof_data); @@ -4248,15 +4248,15 @@ class AvmFlavor { serialize_to_buffer(pedersen_clk, Transcript::proof_data); serialize_to_buffer(pedersen_input, Transcript::proof_data); serialize_to_buffer(pedersen_output, Transcript::proof_data); - serialize_to_buffer(pedersen_pedersen_sel, Transcript::proof_data); + serialize_to_buffer(pedersen_sel_pedersen, Transcript::proof_data); serialize_to_buffer(poseidon2_clk, Transcript::proof_data); serialize_to_buffer(poseidon2_input, Transcript::proof_data); serialize_to_buffer(poseidon2_output, Transcript::proof_data); - serialize_to_buffer(poseidon2_poseidon_perm_sel, Transcript::proof_data); + serialize_to_buffer(poseidon2_sel_poseidon_perm, Transcript::proof_data); serialize_to_buffer(sha256_clk, Transcript::proof_data); serialize_to_buffer(sha256_input, Transcript::proof_data); serialize_to_buffer(sha256_output, Transcript::proof_data); - serialize_to_buffer(sha256_sha256_compression_sel, Transcript::proof_data); + serialize_to_buffer(sha256_sel_sha256_compression, Transcript::proof_data); serialize_to_buffer(sha256_state, Transcript::proof_data); serialize_to_buffer(perm_main_alu, Transcript::proof_data); serialize_to_buffer(perm_main_bin, Transcript::proof_data); @@ -4267,10 +4267,10 @@ class AvmFlavor { serialize_to_buffer(perm_main_mem_b, Transcript::proof_data); serialize_to_buffer(perm_main_mem_c, Transcript::proof_data); serialize_to_buffer(perm_main_mem_d, Transcript::proof_data); - serialize_to_buffer(perm_main_mem_ind_a, Transcript::proof_data); - serialize_to_buffer(perm_main_mem_ind_b, Transcript::proof_data); - serialize_to_buffer(perm_main_mem_ind_c, Transcript::proof_data); - serialize_to_buffer(perm_main_mem_ind_d, Transcript::proof_data); + serialize_to_buffer(perm_main_mem_ind_addr_a, Transcript::proof_data); + serialize_to_buffer(perm_main_mem_ind_addr_b, Transcript::proof_data); + serialize_to_buffer(perm_main_mem_ind_addr_c, Transcript::proof_data); + serialize_to_buffer(perm_main_mem_ind_addr_d, Transcript::proof_data); serialize_to_buffer(lookup_byte_lengths, Transcript::proof_data); serialize_to_buffer(lookup_byte_operations, Transcript::proof_data); serialize_to_buffer(lookup_opcode_gas, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index e8b38b05911..2bdb385ef3f 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -61,15 +61,12 @@ void AvmProver::execute_wire_commitments_round() // logderivative phase) witness_commitments.alu_a_hi = commitment_key->commit(key->alu_a_hi); witness_commitments.alu_a_lo = commitment_key->commit(key->alu_a_lo); - witness_commitments.alu_alu_sel = commitment_key->commit(key->alu_alu_sel); witness_commitments.alu_b_hi = commitment_key->commit(key->alu_b_hi); witness_commitments.alu_b_lo = commitment_key->commit(key->alu_b_lo); witness_commitments.alu_borrow = commitment_key->commit(key->alu_borrow); witness_commitments.alu_cf = commitment_key->commit(key->alu_cf); witness_commitments.alu_clk = commitment_key->commit(key->alu_clk); witness_commitments.alu_cmp_rng_ctr = commitment_key->commit(key->alu_cmp_rng_ctr); - witness_commitments.alu_cmp_sel = commitment_key->commit(key->alu_cmp_sel); - witness_commitments.alu_div_rng_chk_selector = commitment_key->commit(key->alu_div_rng_chk_selector); witness_commitments.alu_div_u16_r0 = commitment_key->commit(key->alu_div_u16_r0); witness_commitments.alu_div_u16_r1 = commitment_key->commit(key->alu_div_u16_r1); witness_commitments.alu_div_u16_r2 = commitment_key->commit(key->alu_div_u16_r2); @@ -113,10 +110,13 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.alu_remainder = commitment_key->commit(key->alu_remainder); witness_commitments.alu_res_hi = commitment_key->commit(key->alu_res_hi); witness_commitments.alu_res_lo = commitment_key->commit(key->alu_res_lo); - witness_commitments.alu_rng_chk_lookup_selector = commitment_key->commit(key->alu_rng_chk_lookup_selector); - witness_commitments.alu_rng_chk_sel = commitment_key->commit(key->alu_rng_chk_sel); + witness_commitments.alu_sel_alu = commitment_key->commit(key->alu_sel_alu); + witness_commitments.alu_sel_cmp = commitment_key->commit(key->alu_sel_cmp); + witness_commitments.alu_sel_div_rng_chk = commitment_key->commit(key->alu_sel_div_rng_chk); + witness_commitments.alu_sel_rng_chk = commitment_key->commit(key->alu_sel_rng_chk); + witness_commitments.alu_sel_rng_chk_lookup = commitment_key->commit(key->alu_sel_rng_chk_lookup); + witness_commitments.alu_sel_shift_which = commitment_key->commit(key->alu_sel_shift_which); witness_commitments.alu_shift_lt_bit_len = commitment_key->commit(key->alu_shift_lt_bit_len); - witness_commitments.alu_shift_sel = commitment_key->commit(key->alu_shift_sel); witness_commitments.alu_t_sub_s_bits = commitment_key->commit(key->alu_t_sub_s_bits); witness_commitments.alu_two_pow_s = commitment_key->commit(key->alu_two_pow_s); witness_commitments.alu_two_pow_t_sub_s = commitment_key->commit(key->alu_two_pow_t_sub_s); @@ -145,7 +145,6 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.binary_acc_ia = commitment_key->commit(key->binary_acc_ia); witness_commitments.binary_acc_ib = commitment_key->commit(key->binary_acc_ib); witness_commitments.binary_acc_ic = commitment_key->commit(key->binary_acc_ic); - witness_commitments.binary_bin_sel = commitment_key->commit(key->binary_bin_sel); witness_commitments.binary_clk = commitment_key->commit(key->binary_clk); witness_commitments.binary_ia_bytes = commitment_key->commit(key->binary_ia_bytes); witness_commitments.binary_ib_bytes = commitment_key->commit(key->binary_ib_bytes); @@ -154,8 +153,9 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.binary_mem_tag_ctr = commitment_key->commit(key->binary_mem_tag_ctr); witness_commitments.binary_mem_tag_ctr_inv = commitment_key->commit(key->binary_mem_tag_ctr_inv); witness_commitments.binary_op_id = commitment_key->commit(key->binary_op_id); + witness_commitments.binary_sel_bin = commitment_key->commit(key->binary_sel_bin); witness_commitments.binary_start = commitment_key->commit(key->binary_start); - witness_commitments.byte_lookup_bin_sel = commitment_key->commit(key->byte_lookup_bin_sel); + witness_commitments.byte_lookup_sel_bin = commitment_key->commit(key->byte_lookup_sel_bin); witness_commitments.byte_lookup_table_byte_lengths = commitment_key->commit(key->byte_lookup_table_byte_lengths); witness_commitments.byte_lookup_table_in_tags = commitment_key->commit(key->byte_lookup_table_in_tags); witness_commitments.byte_lookup_table_input_a = commitment_key->commit(key->byte_lookup_table_input_a); @@ -166,14 +166,14 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.conversion_input = commitment_key->commit(key->conversion_input); witness_commitments.conversion_num_limbs = commitment_key->commit(key->conversion_num_limbs); witness_commitments.conversion_radix = commitment_key->commit(key->conversion_radix); - witness_commitments.conversion_to_radix_le_sel = commitment_key->commit(key->conversion_to_radix_le_sel); + witness_commitments.conversion_sel_to_radix_le = commitment_key->commit(key->conversion_sel_to_radix_le); witness_commitments.gas_da_gas_fixed_table = commitment_key->commit(key->gas_da_gas_fixed_table); - witness_commitments.gas_gas_cost_sel = commitment_key->commit(key->gas_gas_cost_sel); witness_commitments.gas_l2_gas_fixed_table = commitment_key->commit(key->gas_l2_gas_fixed_table); + witness_commitments.gas_sel_gas_cost = commitment_key->commit(key->gas_sel_gas_cost); witness_commitments.keccakf1600_clk = commitment_key->commit(key->keccakf1600_clk); witness_commitments.keccakf1600_input = commitment_key->commit(key->keccakf1600_input); - witness_commitments.keccakf1600_keccakf1600_sel = commitment_key->commit(key->keccakf1600_keccakf1600_sel); witness_commitments.keccakf1600_output = commitment_key->commit(key->keccakf1600_output); + witness_commitments.keccakf1600_sel_keccakf1600 = commitment_key->commit(key->keccakf1600_sel_keccakf1600); witness_commitments.kernel_emit_l2_to_l1_msg_write_offset = commitment_key->commit(key->kernel_emit_l2_to_l1_msg_write_offset); witness_commitments.kernel_emit_note_hash_write_offset = @@ -208,68 +208,55 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.main_abs_l2_rem_gas_hi = commitment_key->commit(key->main_abs_l2_rem_gas_hi); witness_commitments.main_abs_l2_rem_gas_lo = commitment_key->commit(key->main_abs_l2_rem_gas_lo); witness_commitments.main_alu_in_tag = commitment_key->commit(key->main_alu_in_tag); - witness_commitments.main_alu_sel = commitment_key->commit(key->main_alu_sel); witness_commitments.main_bin_op_id = commitment_key->commit(key->main_bin_op_id); - witness_commitments.main_bin_sel = commitment_key->commit(key->main_bin_sel); witness_commitments.main_call_ptr = commitment_key->commit(key->main_call_ptr); - witness_commitments.main_da_gas_op = commitment_key->commit(key->main_da_gas_op); + witness_commitments.main_da_gas_op_cost = commitment_key->commit(key->main_da_gas_op_cost); witness_commitments.main_da_gas_remaining = commitment_key->commit(key->main_da_gas_remaining); witness_commitments.main_da_out_of_gas = commitment_key->commit(key->main_da_out_of_gas); - witness_commitments.main_gas_cost_active = commitment_key->commit(key->main_gas_cost_active); witness_commitments.main_ia = commitment_key->commit(key->main_ia); witness_commitments.main_ib = commitment_key->commit(key->main_ib); witness_commitments.main_ic = commitment_key->commit(key->main_ic); witness_commitments.main_id = commitment_key->commit(key->main_id); witness_commitments.main_id_zero = commitment_key->commit(key->main_id_zero); - witness_commitments.main_ind_a = commitment_key->commit(key->main_ind_a); - witness_commitments.main_ind_b = commitment_key->commit(key->main_ind_b); - witness_commitments.main_ind_c = commitment_key->commit(key->main_ind_c); - witness_commitments.main_ind_d = commitment_key->commit(key->main_ind_d); - witness_commitments.main_ind_op_a = commitment_key->commit(key->main_ind_op_a); - witness_commitments.main_ind_op_b = commitment_key->commit(key->main_ind_op_b); - witness_commitments.main_ind_op_c = commitment_key->commit(key->main_ind_op_c); - witness_commitments.main_ind_op_d = commitment_key->commit(key->main_ind_op_d); + witness_commitments.main_ind_addr_a = commitment_key->commit(key->main_ind_addr_a); + witness_commitments.main_ind_addr_b = commitment_key->commit(key->main_ind_addr_b); + witness_commitments.main_ind_addr_c = commitment_key->commit(key->main_ind_addr_c); + witness_commitments.main_ind_addr_d = commitment_key->commit(key->main_ind_addr_d); witness_commitments.main_internal_return_ptr = commitment_key->commit(key->main_internal_return_ptr); witness_commitments.main_inv = commitment_key->commit(key->main_inv); - witness_commitments.main_l2_gas_op = commitment_key->commit(key->main_l2_gas_op); + witness_commitments.main_l2_gas_op_cost = commitment_key->commit(key->main_l2_gas_op_cost); witness_commitments.main_l2_gas_remaining = commitment_key->commit(key->main_l2_gas_remaining); witness_commitments.main_l2_out_of_gas = commitment_key->commit(key->main_l2_out_of_gas); - witness_commitments.main_last = commitment_key->commit(key->main_last); - witness_commitments.main_mem_idx_a = commitment_key->commit(key->main_mem_idx_a); - witness_commitments.main_mem_idx_b = commitment_key->commit(key->main_mem_idx_b); - witness_commitments.main_mem_idx_c = commitment_key->commit(key->main_mem_idx_c); - witness_commitments.main_mem_idx_d = commitment_key->commit(key->main_mem_idx_d); - witness_commitments.main_mem_op_a = commitment_key->commit(key->main_mem_op_a); - witness_commitments.main_mem_op_activate_gas = commitment_key->commit(key->main_mem_op_activate_gas); - witness_commitments.main_mem_op_b = commitment_key->commit(key->main_mem_op_b); - witness_commitments.main_mem_op_c = commitment_key->commit(key->main_mem_op_c); - witness_commitments.main_mem_op_d = commitment_key->commit(key->main_mem_op_d); + witness_commitments.main_mem_addr_a = commitment_key->commit(key->main_mem_addr_a); + witness_commitments.main_mem_addr_b = commitment_key->commit(key->main_mem_addr_b); + witness_commitments.main_mem_addr_c = commitment_key->commit(key->main_mem_addr_c); + witness_commitments.main_mem_addr_d = commitment_key->commit(key->main_mem_addr_d); witness_commitments.main_op_err = commitment_key->commit(key->main_op_err); witness_commitments.main_opcode_val = commitment_key->commit(key->main_opcode_val); witness_commitments.main_pc = commitment_key->commit(key->main_pc); - witness_commitments.main_q_kernel_lookup = commitment_key->commit(key->main_q_kernel_lookup); - witness_commitments.main_q_kernel_output_lookup = commitment_key->commit(key->main_q_kernel_output_lookup); witness_commitments.main_r_in_tag = commitment_key->commit(key->main_r_in_tag); witness_commitments.main_rwa = commitment_key->commit(key->main_rwa); witness_commitments.main_rwb = commitment_key->commit(key->main_rwb); witness_commitments.main_rwc = commitment_key->commit(key->main_rwc); witness_commitments.main_rwd = commitment_key->commit(key->main_rwd); - witness_commitments.main_sel_cmov = commitment_key->commit(key->main_sel_cmov); - witness_commitments.main_sel_external_call = commitment_key->commit(key->main_sel_external_call); - witness_commitments.main_sel_halt = commitment_key->commit(key->main_sel_halt); - witness_commitments.main_sel_internal_call = commitment_key->commit(key->main_sel_internal_call); - witness_commitments.main_sel_internal_return = commitment_key->commit(key->main_sel_internal_return); - witness_commitments.main_sel_jump = commitment_key->commit(key->main_sel_jump); - witness_commitments.main_sel_jumpi = commitment_key->commit(key->main_sel_jumpi); - witness_commitments.main_sel_mov = commitment_key->commit(key->main_sel_mov); - witness_commitments.main_sel_mov_a = commitment_key->commit(key->main_sel_mov_a); - witness_commitments.main_sel_mov_b = commitment_key->commit(key->main_sel_mov_b); + witness_commitments.main_sel_alu = commitment_key->commit(key->main_sel_alu); + witness_commitments.main_sel_bin = commitment_key->commit(key->main_sel_bin); + witness_commitments.main_sel_gas_accounting_active = commitment_key->commit(key->main_sel_gas_accounting_active); + witness_commitments.main_sel_last = commitment_key->commit(key->main_sel_last); + witness_commitments.main_sel_mem_op_a = commitment_key->commit(key->main_sel_mem_op_a); + witness_commitments.main_sel_mem_op_activate_gas = commitment_key->commit(key->main_sel_mem_op_activate_gas); + witness_commitments.main_sel_mem_op_b = commitment_key->commit(key->main_sel_mem_op_b); + witness_commitments.main_sel_mem_op_c = commitment_key->commit(key->main_sel_mem_op_c); + witness_commitments.main_sel_mem_op_d = commitment_key->commit(key->main_sel_mem_op_d); + witness_commitments.main_sel_mov_ia_to_ic = commitment_key->commit(key->main_sel_mov_ia_to_ic); + witness_commitments.main_sel_mov_ib_to_ic = commitment_key->commit(key->main_sel_mov_ib_to_ic); witness_commitments.main_sel_op_add = commitment_key->commit(key->main_sel_op_add); witness_commitments.main_sel_op_address = commitment_key->commit(key->main_sel_op_address); witness_commitments.main_sel_op_and = commitment_key->commit(key->main_sel_op_and); witness_commitments.main_sel_op_block_number = commitment_key->commit(key->main_sel_op_block_number); witness_commitments.main_sel_op_cast = commitment_key->commit(key->main_sel_op_cast); witness_commitments.main_sel_op_chain_id = commitment_key->commit(key->main_sel_op_chain_id); + witness_commitments.main_sel_op_cmov = commitment_key->commit(key->main_sel_op_cmov); witness_commitments.main_sel_op_coinbase = commitment_key->commit(key->main_sel_op_coinbase); witness_commitments.main_sel_op_dagasleft = commitment_key->commit(key->main_sel_op_dagasleft); witness_commitments.main_sel_op_div = commitment_key->commit(key->main_sel_op_div); @@ -279,16 +266,23 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.main_sel_op_emit_unencrypted_log = commitment_key->commit(key->main_sel_op_emit_unencrypted_log); witness_commitments.main_sel_op_eq = commitment_key->commit(key->main_sel_op_eq); + witness_commitments.main_sel_op_external_call = commitment_key->commit(key->main_sel_op_external_call); witness_commitments.main_sel_op_fdiv = commitment_key->commit(key->main_sel_op_fdiv); witness_commitments.main_sel_op_fee_per_da_gas = commitment_key->commit(key->main_sel_op_fee_per_da_gas); witness_commitments.main_sel_op_fee_per_l2_gas = commitment_key->commit(key->main_sel_op_fee_per_l2_gas); witness_commitments.main_sel_op_get_contract_instance = commitment_key->commit(key->main_sel_op_get_contract_instance); + witness_commitments.main_sel_op_halt = commitment_key->commit(key->main_sel_op_halt); + witness_commitments.main_sel_op_internal_call = commitment_key->commit(key->main_sel_op_internal_call); + witness_commitments.main_sel_op_internal_return = commitment_key->commit(key->main_sel_op_internal_return); + witness_commitments.main_sel_op_jump = commitment_key->commit(key->main_sel_op_jump); + witness_commitments.main_sel_op_jumpi = commitment_key->commit(key->main_sel_op_jumpi); witness_commitments.main_sel_op_keccak = commitment_key->commit(key->main_sel_op_keccak); witness_commitments.main_sel_op_l1_to_l2_msg_exists = commitment_key->commit(key->main_sel_op_l1_to_l2_msg_exists); witness_commitments.main_sel_op_l2gasleft = commitment_key->commit(key->main_sel_op_l2gasleft); witness_commitments.main_sel_op_lt = commitment_key->commit(key->main_sel_op_lt); witness_commitments.main_sel_op_lte = commitment_key->commit(key->main_sel_op_lte); + witness_commitments.main_sel_op_mov = commitment_key->commit(key->main_sel_op_mov); witness_commitments.main_sel_op_mul = commitment_key->commit(key->main_sel_op_mul); witness_commitments.main_sel_op_not = commitment_key->commit(key->main_sel_op_not); witness_commitments.main_sel_op_note_hash_exists = commitment_key->commit(key->main_sel_op_note_hash_exists); @@ -309,6 +303,12 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.main_sel_op_transaction_fee = commitment_key->commit(key->main_sel_op_transaction_fee); witness_commitments.main_sel_op_version = commitment_key->commit(key->main_sel_op_version); witness_commitments.main_sel_op_xor = commitment_key->commit(key->main_sel_op_xor); + witness_commitments.main_sel_q_kernel_lookup = commitment_key->commit(key->main_sel_q_kernel_lookup); + witness_commitments.main_sel_q_kernel_output_lookup = commitment_key->commit(key->main_sel_q_kernel_output_lookup); + witness_commitments.main_sel_resolve_ind_addr_a = commitment_key->commit(key->main_sel_resolve_ind_addr_a); + witness_commitments.main_sel_resolve_ind_addr_b = commitment_key->commit(key->main_sel_resolve_ind_addr_b); + witness_commitments.main_sel_resolve_ind_addr_c = commitment_key->commit(key->main_sel_resolve_ind_addr_c); + witness_commitments.main_sel_resolve_ind_addr_d = commitment_key->commit(key->main_sel_resolve_ind_addr_d); witness_commitments.main_sel_rng_16 = commitment_key->commit(key->main_sel_rng_16); witness_commitments.main_sel_rng_8 = commitment_key->commit(key->main_sel_rng_8); witness_commitments.main_space_id = commitment_key->commit(key->main_space_id); @@ -321,24 +321,24 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.mem_diff_lo = commitment_key->commit(key->mem_diff_lo); witness_commitments.mem_diff_mid = commitment_key->commit(key->mem_diff_mid); witness_commitments.mem_glob_addr = commitment_key->commit(key->mem_glob_addr); - witness_commitments.mem_ind_op_a = commitment_key->commit(key->mem_ind_op_a); - witness_commitments.mem_ind_op_b = commitment_key->commit(key->mem_ind_op_b); - witness_commitments.mem_ind_op_c = commitment_key->commit(key->mem_ind_op_c); - witness_commitments.mem_ind_op_d = commitment_key->commit(key->mem_ind_op_d); witness_commitments.mem_last = commitment_key->commit(key->mem_last); witness_commitments.mem_lastAccess = commitment_key->commit(key->mem_lastAccess); - witness_commitments.mem_mem_sel = commitment_key->commit(key->mem_mem_sel); witness_commitments.mem_one_min_inv = commitment_key->commit(key->mem_one_min_inv); - witness_commitments.mem_op_a = commitment_key->commit(key->mem_op_a); - witness_commitments.mem_op_b = commitment_key->commit(key->mem_op_b); - witness_commitments.mem_op_c = commitment_key->commit(key->mem_op_c); - witness_commitments.mem_op_d = commitment_key->commit(key->mem_op_d); witness_commitments.mem_r_in_tag = commitment_key->commit(key->mem_r_in_tag); - witness_commitments.mem_rng_chk_sel = commitment_key->commit(key->mem_rng_chk_sel); witness_commitments.mem_rw = commitment_key->commit(key->mem_rw); - witness_commitments.mem_sel_cmov = commitment_key->commit(key->mem_sel_cmov); - witness_commitments.mem_sel_mov_a = commitment_key->commit(key->mem_sel_mov_a); - witness_commitments.mem_sel_mov_b = commitment_key->commit(key->mem_sel_mov_b); + witness_commitments.mem_sel_mem = commitment_key->commit(key->mem_sel_mem); + witness_commitments.mem_sel_mov_ia_to_ic = commitment_key->commit(key->mem_sel_mov_ia_to_ic); + witness_commitments.mem_sel_mov_ib_to_ic = commitment_key->commit(key->mem_sel_mov_ib_to_ic); + witness_commitments.mem_sel_op_a = commitment_key->commit(key->mem_sel_op_a); + witness_commitments.mem_sel_op_b = commitment_key->commit(key->mem_sel_op_b); + witness_commitments.mem_sel_op_c = commitment_key->commit(key->mem_sel_op_c); + witness_commitments.mem_sel_op_cmov = commitment_key->commit(key->mem_sel_op_cmov); + witness_commitments.mem_sel_op_d = commitment_key->commit(key->mem_sel_op_d); + witness_commitments.mem_sel_resolve_ind_addr_a = commitment_key->commit(key->mem_sel_resolve_ind_addr_a); + witness_commitments.mem_sel_resolve_ind_addr_b = commitment_key->commit(key->mem_sel_resolve_ind_addr_b); + witness_commitments.mem_sel_resolve_ind_addr_c = commitment_key->commit(key->mem_sel_resolve_ind_addr_c); + witness_commitments.mem_sel_resolve_ind_addr_d = commitment_key->commit(key->mem_sel_resolve_ind_addr_d); + witness_commitments.mem_sel_rng_chk = commitment_key->commit(key->mem_sel_rng_chk); witness_commitments.mem_skip_check_tag = commitment_key->commit(key->mem_skip_check_tag); witness_commitments.mem_space_id = commitment_key->commit(key->mem_space_id); witness_commitments.mem_tag = commitment_key->commit(key->mem_tag); @@ -349,15 +349,15 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.pedersen_clk = commitment_key->commit(key->pedersen_clk); witness_commitments.pedersen_input = commitment_key->commit(key->pedersen_input); witness_commitments.pedersen_output = commitment_key->commit(key->pedersen_output); - witness_commitments.pedersen_pedersen_sel = commitment_key->commit(key->pedersen_pedersen_sel); + witness_commitments.pedersen_sel_pedersen = commitment_key->commit(key->pedersen_sel_pedersen); witness_commitments.poseidon2_clk = commitment_key->commit(key->poseidon2_clk); witness_commitments.poseidon2_input = commitment_key->commit(key->poseidon2_input); witness_commitments.poseidon2_output = commitment_key->commit(key->poseidon2_output); - witness_commitments.poseidon2_poseidon_perm_sel = commitment_key->commit(key->poseidon2_poseidon_perm_sel); + witness_commitments.poseidon2_sel_poseidon_perm = commitment_key->commit(key->poseidon2_sel_poseidon_perm); witness_commitments.sha256_clk = commitment_key->commit(key->sha256_clk); witness_commitments.sha256_input = commitment_key->commit(key->sha256_input); witness_commitments.sha256_output = commitment_key->commit(key->sha256_output); - witness_commitments.sha256_sha256_compression_sel = commitment_key->commit(key->sha256_sha256_compression_sel); + witness_commitments.sha256_sel_sha256_compression = commitment_key->commit(key->sha256_sel_sha256_compression); witness_commitments.sha256_state = commitment_key->commit(key->sha256_state); witness_commitments.lookup_byte_lengths_counts = commitment_key->commit(key->lookup_byte_lengths_counts); witness_commitments.lookup_byte_operations_counts = commitment_key->commit(key->lookup_byte_operations_counts); @@ -404,16 +404,12 @@ void AvmProver::execute_wire_commitments_round() // Send all commitments to the verifier transcript->send_to_verifier(commitment_labels.alu_a_hi, witness_commitments.alu_a_hi); transcript->send_to_verifier(commitment_labels.alu_a_lo, witness_commitments.alu_a_lo); - transcript->send_to_verifier(commitment_labels.alu_alu_sel, witness_commitments.alu_alu_sel); transcript->send_to_verifier(commitment_labels.alu_b_hi, witness_commitments.alu_b_hi); transcript->send_to_verifier(commitment_labels.alu_b_lo, witness_commitments.alu_b_lo); transcript->send_to_verifier(commitment_labels.alu_borrow, witness_commitments.alu_borrow); transcript->send_to_verifier(commitment_labels.alu_cf, witness_commitments.alu_cf); transcript->send_to_verifier(commitment_labels.alu_clk, witness_commitments.alu_clk); transcript->send_to_verifier(commitment_labels.alu_cmp_rng_ctr, witness_commitments.alu_cmp_rng_ctr); - transcript->send_to_verifier(commitment_labels.alu_cmp_sel, witness_commitments.alu_cmp_sel); - transcript->send_to_verifier(commitment_labels.alu_div_rng_chk_selector, - witness_commitments.alu_div_rng_chk_selector); transcript->send_to_verifier(commitment_labels.alu_div_u16_r0, witness_commitments.alu_div_u16_r0); transcript->send_to_verifier(commitment_labels.alu_div_u16_r1, witness_commitments.alu_div_u16_r1); transcript->send_to_verifier(commitment_labels.alu_div_u16_r2, witness_commitments.alu_div_u16_r2); @@ -457,11 +453,13 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.alu_remainder, witness_commitments.alu_remainder); transcript->send_to_verifier(commitment_labels.alu_res_hi, witness_commitments.alu_res_hi); transcript->send_to_verifier(commitment_labels.alu_res_lo, witness_commitments.alu_res_lo); - transcript->send_to_verifier(commitment_labels.alu_rng_chk_lookup_selector, - witness_commitments.alu_rng_chk_lookup_selector); - transcript->send_to_verifier(commitment_labels.alu_rng_chk_sel, witness_commitments.alu_rng_chk_sel); + transcript->send_to_verifier(commitment_labels.alu_sel_alu, witness_commitments.alu_sel_alu); + transcript->send_to_verifier(commitment_labels.alu_sel_cmp, witness_commitments.alu_sel_cmp); + transcript->send_to_verifier(commitment_labels.alu_sel_div_rng_chk, witness_commitments.alu_sel_div_rng_chk); + transcript->send_to_verifier(commitment_labels.alu_sel_rng_chk, witness_commitments.alu_sel_rng_chk); + transcript->send_to_verifier(commitment_labels.alu_sel_rng_chk_lookup, witness_commitments.alu_sel_rng_chk_lookup); + transcript->send_to_verifier(commitment_labels.alu_sel_shift_which, witness_commitments.alu_sel_shift_which); transcript->send_to_verifier(commitment_labels.alu_shift_lt_bit_len, witness_commitments.alu_shift_lt_bit_len); - transcript->send_to_verifier(commitment_labels.alu_shift_sel, witness_commitments.alu_shift_sel); transcript->send_to_verifier(commitment_labels.alu_t_sub_s_bits, witness_commitments.alu_t_sub_s_bits); transcript->send_to_verifier(commitment_labels.alu_two_pow_s, witness_commitments.alu_two_pow_s); transcript->send_to_verifier(commitment_labels.alu_two_pow_t_sub_s, witness_commitments.alu_two_pow_t_sub_s); @@ -490,7 +488,6 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.binary_acc_ia, witness_commitments.binary_acc_ia); transcript->send_to_verifier(commitment_labels.binary_acc_ib, witness_commitments.binary_acc_ib); transcript->send_to_verifier(commitment_labels.binary_acc_ic, witness_commitments.binary_acc_ic); - transcript->send_to_verifier(commitment_labels.binary_bin_sel, witness_commitments.binary_bin_sel); transcript->send_to_verifier(commitment_labels.binary_clk, witness_commitments.binary_clk); transcript->send_to_verifier(commitment_labels.binary_ia_bytes, witness_commitments.binary_ia_bytes); transcript->send_to_verifier(commitment_labels.binary_ib_bytes, witness_commitments.binary_ib_bytes); @@ -499,8 +496,9 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.binary_mem_tag_ctr, witness_commitments.binary_mem_tag_ctr); transcript->send_to_verifier(commitment_labels.binary_mem_tag_ctr_inv, witness_commitments.binary_mem_tag_ctr_inv); transcript->send_to_verifier(commitment_labels.binary_op_id, witness_commitments.binary_op_id); + transcript->send_to_verifier(commitment_labels.binary_sel_bin, witness_commitments.binary_sel_bin); transcript->send_to_verifier(commitment_labels.binary_start, witness_commitments.binary_start); - transcript->send_to_verifier(commitment_labels.byte_lookup_bin_sel, witness_commitments.byte_lookup_bin_sel); + transcript->send_to_verifier(commitment_labels.byte_lookup_sel_bin, witness_commitments.byte_lookup_sel_bin); transcript->send_to_verifier(commitment_labels.byte_lookup_table_byte_lengths, witness_commitments.byte_lookup_table_byte_lengths); transcript->send_to_verifier(commitment_labels.byte_lookup_table_in_tags, @@ -517,16 +515,16 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.conversion_input, witness_commitments.conversion_input); transcript->send_to_verifier(commitment_labels.conversion_num_limbs, witness_commitments.conversion_num_limbs); transcript->send_to_verifier(commitment_labels.conversion_radix, witness_commitments.conversion_radix); - transcript->send_to_verifier(commitment_labels.conversion_to_radix_le_sel, - witness_commitments.conversion_to_radix_le_sel); + transcript->send_to_verifier(commitment_labels.conversion_sel_to_radix_le, + witness_commitments.conversion_sel_to_radix_le); transcript->send_to_verifier(commitment_labels.gas_da_gas_fixed_table, witness_commitments.gas_da_gas_fixed_table); - transcript->send_to_verifier(commitment_labels.gas_gas_cost_sel, witness_commitments.gas_gas_cost_sel); transcript->send_to_verifier(commitment_labels.gas_l2_gas_fixed_table, witness_commitments.gas_l2_gas_fixed_table); + transcript->send_to_verifier(commitment_labels.gas_sel_gas_cost, witness_commitments.gas_sel_gas_cost); transcript->send_to_verifier(commitment_labels.keccakf1600_clk, witness_commitments.keccakf1600_clk); transcript->send_to_verifier(commitment_labels.keccakf1600_input, witness_commitments.keccakf1600_input); - transcript->send_to_verifier(commitment_labels.keccakf1600_keccakf1600_sel, - witness_commitments.keccakf1600_keccakf1600_sel); transcript->send_to_verifier(commitment_labels.keccakf1600_output, witness_commitments.keccakf1600_output); + transcript->send_to_verifier(commitment_labels.keccakf1600_sel_keccakf1600, + witness_commitments.keccakf1600_sel_keccakf1600); transcript->send_to_verifier(commitment_labels.kernel_emit_l2_to_l1_msg_write_offset, witness_commitments.kernel_emit_l2_to_l1_msg_write_offset); transcript->send_to_verifier(commitment_labels.kernel_emit_note_hash_write_offset, @@ -569,66 +567,51 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.main_abs_l2_rem_gas_hi, witness_commitments.main_abs_l2_rem_gas_hi); transcript->send_to_verifier(commitment_labels.main_abs_l2_rem_gas_lo, witness_commitments.main_abs_l2_rem_gas_lo); transcript->send_to_verifier(commitment_labels.main_alu_in_tag, witness_commitments.main_alu_in_tag); - transcript->send_to_verifier(commitment_labels.main_alu_sel, witness_commitments.main_alu_sel); transcript->send_to_verifier(commitment_labels.main_bin_op_id, witness_commitments.main_bin_op_id); - transcript->send_to_verifier(commitment_labels.main_bin_sel, witness_commitments.main_bin_sel); transcript->send_to_verifier(commitment_labels.main_call_ptr, witness_commitments.main_call_ptr); - transcript->send_to_verifier(commitment_labels.main_da_gas_op, witness_commitments.main_da_gas_op); + transcript->send_to_verifier(commitment_labels.main_da_gas_op_cost, witness_commitments.main_da_gas_op_cost); transcript->send_to_verifier(commitment_labels.main_da_gas_remaining, witness_commitments.main_da_gas_remaining); transcript->send_to_verifier(commitment_labels.main_da_out_of_gas, witness_commitments.main_da_out_of_gas); - transcript->send_to_verifier(commitment_labels.main_gas_cost_active, witness_commitments.main_gas_cost_active); transcript->send_to_verifier(commitment_labels.main_ia, witness_commitments.main_ia); transcript->send_to_verifier(commitment_labels.main_ib, witness_commitments.main_ib); transcript->send_to_verifier(commitment_labels.main_ic, witness_commitments.main_ic); transcript->send_to_verifier(commitment_labels.main_id, witness_commitments.main_id); transcript->send_to_verifier(commitment_labels.main_id_zero, witness_commitments.main_id_zero); - transcript->send_to_verifier(commitment_labels.main_ind_a, witness_commitments.main_ind_a); - transcript->send_to_verifier(commitment_labels.main_ind_b, witness_commitments.main_ind_b); - transcript->send_to_verifier(commitment_labels.main_ind_c, witness_commitments.main_ind_c); - transcript->send_to_verifier(commitment_labels.main_ind_d, witness_commitments.main_ind_d); - transcript->send_to_verifier(commitment_labels.main_ind_op_a, witness_commitments.main_ind_op_a); - transcript->send_to_verifier(commitment_labels.main_ind_op_b, witness_commitments.main_ind_op_b); - transcript->send_to_verifier(commitment_labels.main_ind_op_c, witness_commitments.main_ind_op_c); - transcript->send_to_verifier(commitment_labels.main_ind_op_d, witness_commitments.main_ind_op_d); + transcript->send_to_verifier(commitment_labels.main_ind_addr_a, witness_commitments.main_ind_addr_a); + transcript->send_to_verifier(commitment_labels.main_ind_addr_b, witness_commitments.main_ind_addr_b); + transcript->send_to_verifier(commitment_labels.main_ind_addr_c, witness_commitments.main_ind_addr_c); + transcript->send_to_verifier(commitment_labels.main_ind_addr_d, witness_commitments.main_ind_addr_d); transcript->send_to_verifier(commitment_labels.main_internal_return_ptr, witness_commitments.main_internal_return_ptr); transcript->send_to_verifier(commitment_labels.main_inv, witness_commitments.main_inv); - transcript->send_to_verifier(commitment_labels.main_l2_gas_op, witness_commitments.main_l2_gas_op); + transcript->send_to_verifier(commitment_labels.main_l2_gas_op_cost, witness_commitments.main_l2_gas_op_cost); transcript->send_to_verifier(commitment_labels.main_l2_gas_remaining, witness_commitments.main_l2_gas_remaining); transcript->send_to_verifier(commitment_labels.main_l2_out_of_gas, witness_commitments.main_l2_out_of_gas); - transcript->send_to_verifier(commitment_labels.main_last, witness_commitments.main_last); - transcript->send_to_verifier(commitment_labels.main_mem_idx_a, witness_commitments.main_mem_idx_a); - transcript->send_to_verifier(commitment_labels.main_mem_idx_b, witness_commitments.main_mem_idx_b); - transcript->send_to_verifier(commitment_labels.main_mem_idx_c, witness_commitments.main_mem_idx_c); - transcript->send_to_verifier(commitment_labels.main_mem_idx_d, witness_commitments.main_mem_idx_d); - transcript->send_to_verifier(commitment_labels.main_mem_op_a, witness_commitments.main_mem_op_a); - transcript->send_to_verifier(commitment_labels.main_mem_op_activate_gas, - witness_commitments.main_mem_op_activate_gas); - transcript->send_to_verifier(commitment_labels.main_mem_op_b, witness_commitments.main_mem_op_b); - transcript->send_to_verifier(commitment_labels.main_mem_op_c, witness_commitments.main_mem_op_c); - transcript->send_to_verifier(commitment_labels.main_mem_op_d, witness_commitments.main_mem_op_d); + transcript->send_to_verifier(commitment_labels.main_mem_addr_a, witness_commitments.main_mem_addr_a); + transcript->send_to_verifier(commitment_labels.main_mem_addr_b, witness_commitments.main_mem_addr_b); + transcript->send_to_verifier(commitment_labels.main_mem_addr_c, witness_commitments.main_mem_addr_c); + transcript->send_to_verifier(commitment_labels.main_mem_addr_d, witness_commitments.main_mem_addr_d); transcript->send_to_verifier(commitment_labels.main_op_err, witness_commitments.main_op_err); transcript->send_to_verifier(commitment_labels.main_opcode_val, witness_commitments.main_opcode_val); transcript->send_to_verifier(commitment_labels.main_pc, witness_commitments.main_pc); - transcript->send_to_verifier(commitment_labels.main_q_kernel_lookup, witness_commitments.main_q_kernel_lookup); - transcript->send_to_verifier(commitment_labels.main_q_kernel_output_lookup, - witness_commitments.main_q_kernel_output_lookup); transcript->send_to_verifier(commitment_labels.main_r_in_tag, witness_commitments.main_r_in_tag); transcript->send_to_verifier(commitment_labels.main_rwa, witness_commitments.main_rwa); transcript->send_to_verifier(commitment_labels.main_rwb, witness_commitments.main_rwb); transcript->send_to_verifier(commitment_labels.main_rwc, witness_commitments.main_rwc); transcript->send_to_verifier(commitment_labels.main_rwd, witness_commitments.main_rwd); - transcript->send_to_verifier(commitment_labels.main_sel_cmov, witness_commitments.main_sel_cmov); - transcript->send_to_verifier(commitment_labels.main_sel_external_call, witness_commitments.main_sel_external_call); - transcript->send_to_verifier(commitment_labels.main_sel_halt, witness_commitments.main_sel_halt); - transcript->send_to_verifier(commitment_labels.main_sel_internal_call, witness_commitments.main_sel_internal_call); - transcript->send_to_verifier(commitment_labels.main_sel_internal_return, - witness_commitments.main_sel_internal_return); - transcript->send_to_verifier(commitment_labels.main_sel_jump, witness_commitments.main_sel_jump); - transcript->send_to_verifier(commitment_labels.main_sel_jumpi, witness_commitments.main_sel_jumpi); - transcript->send_to_verifier(commitment_labels.main_sel_mov, witness_commitments.main_sel_mov); - transcript->send_to_verifier(commitment_labels.main_sel_mov_a, witness_commitments.main_sel_mov_a); - transcript->send_to_verifier(commitment_labels.main_sel_mov_b, witness_commitments.main_sel_mov_b); + transcript->send_to_verifier(commitment_labels.main_sel_alu, witness_commitments.main_sel_alu); + transcript->send_to_verifier(commitment_labels.main_sel_bin, witness_commitments.main_sel_bin); + transcript->send_to_verifier(commitment_labels.main_sel_gas_accounting_active, + witness_commitments.main_sel_gas_accounting_active); + transcript->send_to_verifier(commitment_labels.main_sel_last, witness_commitments.main_sel_last); + transcript->send_to_verifier(commitment_labels.main_sel_mem_op_a, witness_commitments.main_sel_mem_op_a); + transcript->send_to_verifier(commitment_labels.main_sel_mem_op_activate_gas, + witness_commitments.main_sel_mem_op_activate_gas); + transcript->send_to_verifier(commitment_labels.main_sel_mem_op_b, witness_commitments.main_sel_mem_op_b); + transcript->send_to_verifier(commitment_labels.main_sel_mem_op_c, witness_commitments.main_sel_mem_op_c); + transcript->send_to_verifier(commitment_labels.main_sel_mem_op_d, witness_commitments.main_sel_mem_op_d); + transcript->send_to_verifier(commitment_labels.main_sel_mov_ia_to_ic, witness_commitments.main_sel_mov_ia_to_ic); + transcript->send_to_verifier(commitment_labels.main_sel_mov_ib_to_ic, witness_commitments.main_sel_mov_ib_to_ic); transcript->send_to_verifier(commitment_labels.main_sel_op_add, witness_commitments.main_sel_op_add); transcript->send_to_verifier(commitment_labels.main_sel_op_address, witness_commitments.main_sel_op_address); transcript->send_to_verifier(commitment_labels.main_sel_op_and, witness_commitments.main_sel_op_and); @@ -636,6 +619,7 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.main_sel_op_block_number); transcript->send_to_verifier(commitment_labels.main_sel_op_cast, witness_commitments.main_sel_op_cast); transcript->send_to_verifier(commitment_labels.main_sel_op_chain_id, witness_commitments.main_sel_op_chain_id); + transcript->send_to_verifier(commitment_labels.main_sel_op_cmov, witness_commitments.main_sel_op_cmov); transcript->send_to_verifier(commitment_labels.main_sel_op_coinbase, witness_commitments.main_sel_op_coinbase); transcript->send_to_verifier(commitment_labels.main_sel_op_dagasleft, witness_commitments.main_sel_op_dagasleft); transcript->send_to_verifier(commitment_labels.main_sel_op_div, witness_commitments.main_sel_op_div); @@ -648,6 +632,8 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.main_sel_op_emit_unencrypted_log, witness_commitments.main_sel_op_emit_unencrypted_log); transcript->send_to_verifier(commitment_labels.main_sel_op_eq, witness_commitments.main_sel_op_eq); + transcript->send_to_verifier(commitment_labels.main_sel_op_external_call, + witness_commitments.main_sel_op_external_call); transcript->send_to_verifier(commitment_labels.main_sel_op_fdiv, witness_commitments.main_sel_op_fdiv); transcript->send_to_verifier(commitment_labels.main_sel_op_fee_per_da_gas, witness_commitments.main_sel_op_fee_per_da_gas); @@ -655,12 +641,20 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.main_sel_op_fee_per_l2_gas); transcript->send_to_verifier(commitment_labels.main_sel_op_get_contract_instance, witness_commitments.main_sel_op_get_contract_instance); + transcript->send_to_verifier(commitment_labels.main_sel_op_halt, witness_commitments.main_sel_op_halt); + transcript->send_to_verifier(commitment_labels.main_sel_op_internal_call, + witness_commitments.main_sel_op_internal_call); + transcript->send_to_verifier(commitment_labels.main_sel_op_internal_return, + witness_commitments.main_sel_op_internal_return); + transcript->send_to_verifier(commitment_labels.main_sel_op_jump, witness_commitments.main_sel_op_jump); + transcript->send_to_verifier(commitment_labels.main_sel_op_jumpi, witness_commitments.main_sel_op_jumpi); transcript->send_to_verifier(commitment_labels.main_sel_op_keccak, witness_commitments.main_sel_op_keccak); transcript->send_to_verifier(commitment_labels.main_sel_op_l1_to_l2_msg_exists, witness_commitments.main_sel_op_l1_to_l2_msg_exists); transcript->send_to_verifier(commitment_labels.main_sel_op_l2gasleft, witness_commitments.main_sel_op_l2gasleft); transcript->send_to_verifier(commitment_labels.main_sel_op_lt, witness_commitments.main_sel_op_lt); transcript->send_to_verifier(commitment_labels.main_sel_op_lte, witness_commitments.main_sel_op_lte); + transcript->send_to_verifier(commitment_labels.main_sel_op_mov, witness_commitments.main_sel_op_mov); transcript->send_to_verifier(commitment_labels.main_sel_op_mul, witness_commitments.main_sel_op_mul); transcript->send_to_verifier(commitment_labels.main_sel_op_not, witness_commitments.main_sel_op_not); transcript->send_to_verifier(commitment_labels.main_sel_op_note_hash_exists, @@ -685,6 +679,18 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.main_sel_op_transaction_fee); transcript->send_to_verifier(commitment_labels.main_sel_op_version, witness_commitments.main_sel_op_version); transcript->send_to_verifier(commitment_labels.main_sel_op_xor, witness_commitments.main_sel_op_xor); + transcript->send_to_verifier(commitment_labels.main_sel_q_kernel_lookup, + witness_commitments.main_sel_q_kernel_lookup); + transcript->send_to_verifier(commitment_labels.main_sel_q_kernel_output_lookup, + witness_commitments.main_sel_q_kernel_output_lookup); + transcript->send_to_verifier(commitment_labels.main_sel_resolve_ind_addr_a, + witness_commitments.main_sel_resolve_ind_addr_a); + transcript->send_to_verifier(commitment_labels.main_sel_resolve_ind_addr_b, + witness_commitments.main_sel_resolve_ind_addr_b); + transcript->send_to_verifier(commitment_labels.main_sel_resolve_ind_addr_c, + witness_commitments.main_sel_resolve_ind_addr_c); + transcript->send_to_verifier(commitment_labels.main_sel_resolve_ind_addr_d, + witness_commitments.main_sel_resolve_ind_addr_d); transcript->send_to_verifier(commitment_labels.main_sel_rng_16, witness_commitments.main_sel_rng_16); transcript->send_to_verifier(commitment_labels.main_sel_rng_8, witness_commitments.main_sel_rng_8); transcript->send_to_verifier(commitment_labels.main_space_id, witness_commitments.main_space_id); @@ -697,24 +703,28 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.mem_diff_lo, witness_commitments.mem_diff_lo); transcript->send_to_verifier(commitment_labels.mem_diff_mid, witness_commitments.mem_diff_mid); transcript->send_to_verifier(commitment_labels.mem_glob_addr, witness_commitments.mem_glob_addr); - transcript->send_to_verifier(commitment_labels.mem_ind_op_a, witness_commitments.mem_ind_op_a); - transcript->send_to_verifier(commitment_labels.mem_ind_op_b, witness_commitments.mem_ind_op_b); - transcript->send_to_verifier(commitment_labels.mem_ind_op_c, witness_commitments.mem_ind_op_c); - transcript->send_to_verifier(commitment_labels.mem_ind_op_d, witness_commitments.mem_ind_op_d); transcript->send_to_verifier(commitment_labels.mem_last, witness_commitments.mem_last); transcript->send_to_verifier(commitment_labels.mem_lastAccess, witness_commitments.mem_lastAccess); - transcript->send_to_verifier(commitment_labels.mem_mem_sel, witness_commitments.mem_mem_sel); transcript->send_to_verifier(commitment_labels.mem_one_min_inv, witness_commitments.mem_one_min_inv); - transcript->send_to_verifier(commitment_labels.mem_op_a, witness_commitments.mem_op_a); - transcript->send_to_verifier(commitment_labels.mem_op_b, witness_commitments.mem_op_b); - transcript->send_to_verifier(commitment_labels.mem_op_c, witness_commitments.mem_op_c); - transcript->send_to_verifier(commitment_labels.mem_op_d, witness_commitments.mem_op_d); transcript->send_to_verifier(commitment_labels.mem_r_in_tag, witness_commitments.mem_r_in_tag); - transcript->send_to_verifier(commitment_labels.mem_rng_chk_sel, witness_commitments.mem_rng_chk_sel); transcript->send_to_verifier(commitment_labels.mem_rw, witness_commitments.mem_rw); - transcript->send_to_verifier(commitment_labels.mem_sel_cmov, witness_commitments.mem_sel_cmov); - transcript->send_to_verifier(commitment_labels.mem_sel_mov_a, witness_commitments.mem_sel_mov_a); - transcript->send_to_verifier(commitment_labels.mem_sel_mov_b, witness_commitments.mem_sel_mov_b); + transcript->send_to_verifier(commitment_labels.mem_sel_mem, witness_commitments.mem_sel_mem); + transcript->send_to_verifier(commitment_labels.mem_sel_mov_ia_to_ic, witness_commitments.mem_sel_mov_ia_to_ic); + transcript->send_to_verifier(commitment_labels.mem_sel_mov_ib_to_ic, witness_commitments.mem_sel_mov_ib_to_ic); + transcript->send_to_verifier(commitment_labels.mem_sel_op_a, witness_commitments.mem_sel_op_a); + transcript->send_to_verifier(commitment_labels.mem_sel_op_b, witness_commitments.mem_sel_op_b); + transcript->send_to_verifier(commitment_labels.mem_sel_op_c, witness_commitments.mem_sel_op_c); + transcript->send_to_verifier(commitment_labels.mem_sel_op_cmov, witness_commitments.mem_sel_op_cmov); + transcript->send_to_verifier(commitment_labels.mem_sel_op_d, witness_commitments.mem_sel_op_d); + transcript->send_to_verifier(commitment_labels.mem_sel_resolve_ind_addr_a, + witness_commitments.mem_sel_resolve_ind_addr_a); + transcript->send_to_verifier(commitment_labels.mem_sel_resolve_ind_addr_b, + witness_commitments.mem_sel_resolve_ind_addr_b); + transcript->send_to_verifier(commitment_labels.mem_sel_resolve_ind_addr_c, + witness_commitments.mem_sel_resolve_ind_addr_c); + transcript->send_to_verifier(commitment_labels.mem_sel_resolve_ind_addr_d, + witness_commitments.mem_sel_resolve_ind_addr_d); + transcript->send_to_verifier(commitment_labels.mem_sel_rng_chk, witness_commitments.mem_sel_rng_chk); transcript->send_to_verifier(commitment_labels.mem_skip_check_tag, witness_commitments.mem_skip_check_tag); transcript->send_to_verifier(commitment_labels.mem_space_id, witness_commitments.mem_space_id); transcript->send_to_verifier(commitment_labels.mem_tag, witness_commitments.mem_tag); @@ -725,17 +735,17 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.pedersen_clk, witness_commitments.pedersen_clk); transcript->send_to_verifier(commitment_labels.pedersen_input, witness_commitments.pedersen_input); transcript->send_to_verifier(commitment_labels.pedersen_output, witness_commitments.pedersen_output); - transcript->send_to_verifier(commitment_labels.pedersen_pedersen_sel, witness_commitments.pedersen_pedersen_sel); + transcript->send_to_verifier(commitment_labels.pedersen_sel_pedersen, witness_commitments.pedersen_sel_pedersen); transcript->send_to_verifier(commitment_labels.poseidon2_clk, witness_commitments.poseidon2_clk); transcript->send_to_verifier(commitment_labels.poseidon2_input, witness_commitments.poseidon2_input); transcript->send_to_verifier(commitment_labels.poseidon2_output, witness_commitments.poseidon2_output); - transcript->send_to_verifier(commitment_labels.poseidon2_poseidon_perm_sel, - witness_commitments.poseidon2_poseidon_perm_sel); + transcript->send_to_verifier(commitment_labels.poseidon2_sel_poseidon_perm, + witness_commitments.poseidon2_sel_poseidon_perm); transcript->send_to_verifier(commitment_labels.sha256_clk, witness_commitments.sha256_clk); transcript->send_to_verifier(commitment_labels.sha256_input, witness_commitments.sha256_input); transcript->send_to_verifier(commitment_labels.sha256_output, witness_commitments.sha256_output); - transcript->send_to_verifier(commitment_labels.sha256_sha256_compression_sel, - witness_commitments.sha256_sha256_compression_sel); + transcript->send_to_verifier(commitment_labels.sha256_sel_sha256_compression, + witness_commitments.sha256_sel_sha256_compression); transcript->send_to_verifier(commitment_labels.sha256_state, witness_commitments.sha256_state); transcript->send_to_verifier(commitment_labels.lookup_byte_lengths_counts, witness_commitments.lookup_byte_lengths_counts); @@ -821,10 +831,10 @@ void AvmProver::execute_log_derivative_inverse_round() witness_commitments.perm_main_mem_b = commitment_key->commit(key->perm_main_mem_b); witness_commitments.perm_main_mem_c = commitment_key->commit(key->perm_main_mem_c); witness_commitments.perm_main_mem_d = commitment_key->commit(key->perm_main_mem_d); - witness_commitments.perm_main_mem_ind_a = commitment_key->commit(key->perm_main_mem_ind_a); - witness_commitments.perm_main_mem_ind_b = commitment_key->commit(key->perm_main_mem_ind_b); - witness_commitments.perm_main_mem_ind_c = commitment_key->commit(key->perm_main_mem_ind_c); - witness_commitments.perm_main_mem_ind_d = commitment_key->commit(key->perm_main_mem_ind_d); + witness_commitments.perm_main_mem_ind_addr_a = commitment_key->commit(key->perm_main_mem_ind_addr_a); + witness_commitments.perm_main_mem_ind_addr_b = commitment_key->commit(key->perm_main_mem_ind_addr_b); + witness_commitments.perm_main_mem_ind_addr_c = commitment_key->commit(key->perm_main_mem_ind_addr_c); + witness_commitments.perm_main_mem_ind_addr_d = commitment_key->commit(key->perm_main_mem_ind_addr_d); witness_commitments.lookup_byte_lengths = commitment_key->commit(key->lookup_byte_lengths); witness_commitments.lookup_byte_operations = commitment_key->commit(key->lookup_byte_operations); witness_commitments.lookup_opcode_gas = commitment_key->commit(key->lookup_opcode_gas); @@ -877,10 +887,14 @@ void AvmProver::execute_log_derivative_inverse_round() transcript->send_to_verifier(commitment_labels.perm_main_mem_b, witness_commitments.perm_main_mem_b); transcript->send_to_verifier(commitment_labels.perm_main_mem_c, witness_commitments.perm_main_mem_c); transcript->send_to_verifier(commitment_labels.perm_main_mem_d, witness_commitments.perm_main_mem_d); - transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_a, witness_commitments.perm_main_mem_ind_a); - transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_b, witness_commitments.perm_main_mem_ind_b); - transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_c, witness_commitments.perm_main_mem_ind_c); - transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_d, witness_commitments.perm_main_mem_ind_d); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_addr_a, + witness_commitments.perm_main_mem_ind_addr_a); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_addr_b, + witness_commitments.perm_main_mem_ind_addr_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_addr_c, + witness_commitments.perm_main_mem_ind_addr_c); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_addr_d, + witness_commitments.perm_main_mem_ind_addr_d); transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); transcript->send_to_verifier(commitment_labels.lookup_opcode_gas, witness_commitments.lookup_opcode_gas); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 0f459049f34..32cb192f93a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -72,7 +72,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.alu_a_hi); commitments.alu_a_lo = transcript->template receive_from_prover(commitment_labels.alu_a_lo); - commitments.alu_alu_sel = transcript->template receive_from_prover(commitment_labels.alu_alu_sel); commitments.alu_b_hi = transcript->template receive_from_prover(commitment_labels.alu_b_hi); commitments.alu_b_lo = transcript->template receive_from_prover(commitment_labels.alu_b_lo); commitments.alu_borrow = transcript->template receive_from_prover(commitment_labels.alu_borrow); @@ -80,9 +79,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.alu_clk); commitments.alu_cmp_rng_ctr = transcript->template receive_from_prover(commitment_labels.alu_cmp_rng_ctr); - commitments.alu_cmp_sel = transcript->template receive_from_prover(commitment_labels.alu_cmp_sel); - commitments.alu_div_rng_chk_selector = - transcript->template receive_from_prover(commitment_labels.alu_div_rng_chk_selector); commitments.alu_div_u16_r0 = transcript->template receive_from_prover(commitment_labels.alu_div_u16_r0); commitments.alu_div_u16_r1 = transcript->template receive_from_prover(commitment_labels.alu_div_u16_r1); commitments.alu_div_u16_r2 = transcript->template receive_from_prover(commitment_labels.alu_div_u16_r2); @@ -133,13 +129,18 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.alu_remainder); commitments.alu_res_hi = transcript->template receive_from_prover(commitment_labels.alu_res_hi); commitments.alu_res_lo = transcript->template receive_from_prover(commitment_labels.alu_res_lo); - commitments.alu_rng_chk_lookup_selector = - transcript->template receive_from_prover(commitment_labels.alu_rng_chk_lookup_selector); - commitments.alu_rng_chk_sel = - transcript->template receive_from_prover(commitment_labels.alu_rng_chk_sel); + commitments.alu_sel_alu = transcript->template receive_from_prover(commitment_labels.alu_sel_alu); + commitments.alu_sel_cmp = transcript->template receive_from_prover(commitment_labels.alu_sel_cmp); + commitments.alu_sel_div_rng_chk = + transcript->template receive_from_prover(commitment_labels.alu_sel_div_rng_chk); + commitments.alu_sel_rng_chk = + transcript->template receive_from_prover(commitment_labels.alu_sel_rng_chk); + commitments.alu_sel_rng_chk_lookup = + transcript->template receive_from_prover(commitment_labels.alu_sel_rng_chk_lookup); + commitments.alu_sel_shift_which = + transcript->template receive_from_prover(commitment_labels.alu_sel_shift_which); commitments.alu_shift_lt_bit_len = transcript->template receive_from_prover(commitment_labels.alu_shift_lt_bit_len); - commitments.alu_shift_sel = transcript->template receive_from_prover(commitment_labels.alu_shift_sel); commitments.alu_t_sub_s_bits = transcript->template receive_from_prover(commitment_labels.alu_t_sub_s_bits); commitments.alu_two_pow_s = transcript->template receive_from_prover(commitment_labels.alu_two_pow_s); @@ -170,7 +171,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.binary_acc_ia); commitments.binary_acc_ib = transcript->template receive_from_prover(commitment_labels.binary_acc_ib); commitments.binary_acc_ic = transcript->template receive_from_prover(commitment_labels.binary_acc_ic); - commitments.binary_bin_sel = transcript->template receive_from_prover(commitment_labels.binary_bin_sel); commitments.binary_clk = transcript->template receive_from_prover(commitment_labels.binary_clk); commitments.binary_ia_bytes = transcript->template receive_from_prover(commitment_labels.binary_ia_bytes); @@ -184,9 +184,10 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.binary_mem_tag_ctr_inv); commitments.binary_op_id = transcript->template receive_from_prover(commitment_labels.binary_op_id); + commitments.binary_sel_bin = transcript->template receive_from_prover(commitment_labels.binary_sel_bin); commitments.binary_start = transcript->template receive_from_prover(commitment_labels.binary_start); - commitments.byte_lookup_bin_sel = - transcript->template receive_from_prover(commitment_labels.byte_lookup_bin_sel); + commitments.byte_lookup_sel_bin = + transcript->template receive_from_prover(commitment_labels.byte_lookup_sel_bin); commitments.byte_lookup_table_byte_lengths = transcript->template receive_from_prover(commitment_labels.byte_lookup_table_byte_lengths); commitments.byte_lookup_table_in_tags = @@ -206,22 +207,22 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.conversion_num_limbs); commitments.conversion_radix = transcript->template receive_from_prover(commitment_labels.conversion_radix); - commitments.conversion_to_radix_le_sel = - transcript->template receive_from_prover(commitment_labels.conversion_to_radix_le_sel); + commitments.conversion_sel_to_radix_le = + transcript->template receive_from_prover(commitment_labels.conversion_sel_to_radix_le); commitments.gas_da_gas_fixed_table = transcript->template receive_from_prover(commitment_labels.gas_da_gas_fixed_table); - commitments.gas_gas_cost_sel = - transcript->template receive_from_prover(commitment_labels.gas_gas_cost_sel); commitments.gas_l2_gas_fixed_table = transcript->template receive_from_prover(commitment_labels.gas_l2_gas_fixed_table); + commitments.gas_sel_gas_cost = + transcript->template receive_from_prover(commitment_labels.gas_sel_gas_cost); commitments.keccakf1600_clk = transcript->template receive_from_prover(commitment_labels.keccakf1600_clk); commitments.keccakf1600_input = transcript->template receive_from_prover(commitment_labels.keccakf1600_input); - commitments.keccakf1600_keccakf1600_sel = - transcript->template receive_from_prover(commitment_labels.keccakf1600_keccakf1600_sel); commitments.keccakf1600_output = transcript->template receive_from_prover(commitment_labels.keccakf1600_output); + commitments.keccakf1600_sel_keccakf1600 = + transcript->template receive_from_prover(commitment_labels.keccakf1600_sel_keccakf1600); commitments.kernel_emit_l2_to_l1_msg_write_offset = transcript->template receive_from_prover(commitment_labels.kernel_emit_l2_to_l1_msg_write_offset); commitments.kernel_emit_note_hash_write_offset = @@ -270,75 +271,72 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.main_abs_l2_rem_gas_lo); commitments.main_alu_in_tag = transcript->template receive_from_prover(commitment_labels.main_alu_in_tag); - commitments.main_alu_sel = transcript->template receive_from_prover(commitment_labels.main_alu_sel); commitments.main_bin_op_id = transcript->template receive_from_prover(commitment_labels.main_bin_op_id); - commitments.main_bin_sel = transcript->template receive_from_prover(commitment_labels.main_bin_sel); commitments.main_call_ptr = transcript->template receive_from_prover(commitment_labels.main_call_ptr); - commitments.main_da_gas_op = transcript->template receive_from_prover(commitment_labels.main_da_gas_op); + commitments.main_da_gas_op_cost = + transcript->template receive_from_prover(commitment_labels.main_da_gas_op_cost); commitments.main_da_gas_remaining = transcript->template receive_from_prover(commitment_labels.main_da_gas_remaining); commitments.main_da_out_of_gas = transcript->template receive_from_prover(commitment_labels.main_da_out_of_gas); - commitments.main_gas_cost_active = - transcript->template receive_from_prover(commitment_labels.main_gas_cost_active); commitments.main_ia = transcript->template receive_from_prover(commitment_labels.main_ia); commitments.main_ib = transcript->template receive_from_prover(commitment_labels.main_ib); commitments.main_ic = transcript->template receive_from_prover(commitment_labels.main_ic); commitments.main_id = transcript->template receive_from_prover(commitment_labels.main_id); commitments.main_id_zero = transcript->template receive_from_prover(commitment_labels.main_id_zero); - commitments.main_ind_a = transcript->template receive_from_prover(commitment_labels.main_ind_a); - commitments.main_ind_b = transcript->template receive_from_prover(commitment_labels.main_ind_b); - commitments.main_ind_c = transcript->template receive_from_prover(commitment_labels.main_ind_c); - commitments.main_ind_d = transcript->template receive_from_prover(commitment_labels.main_ind_d); - commitments.main_ind_op_a = transcript->template receive_from_prover(commitment_labels.main_ind_op_a); - commitments.main_ind_op_b = transcript->template receive_from_prover(commitment_labels.main_ind_op_b); - commitments.main_ind_op_c = transcript->template receive_from_prover(commitment_labels.main_ind_op_c); - commitments.main_ind_op_d = transcript->template receive_from_prover(commitment_labels.main_ind_op_d); + commitments.main_ind_addr_a = + transcript->template receive_from_prover(commitment_labels.main_ind_addr_a); + commitments.main_ind_addr_b = + transcript->template receive_from_prover(commitment_labels.main_ind_addr_b); + commitments.main_ind_addr_c = + transcript->template receive_from_prover(commitment_labels.main_ind_addr_c); + commitments.main_ind_addr_d = + transcript->template receive_from_prover(commitment_labels.main_ind_addr_d); commitments.main_internal_return_ptr = transcript->template receive_from_prover(commitment_labels.main_internal_return_ptr); commitments.main_inv = transcript->template receive_from_prover(commitment_labels.main_inv); - commitments.main_l2_gas_op = transcript->template receive_from_prover(commitment_labels.main_l2_gas_op); + commitments.main_l2_gas_op_cost = + transcript->template receive_from_prover(commitment_labels.main_l2_gas_op_cost); commitments.main_l2_gas_remaining = transcript->template receive_from_prover(commitment_labels.main_l2_gas_remaining); commitments.main_l2_out_of_gas = transcript->template receive_from_prover(commitment_labels.main_l2_out_of_gas); - commitments.main_last = transcript->template receive_from_prover(commitment_labels.main_last); - commitments.main_mem_idx_a = transcript->template receive_from_prover(commitment_labels.main_mem_idx_a); - commitments.main_mem_idx_b = transcript->template receive_from_prover(commitment_labels.main_mem_idx_b); - commitments.main_mem_idx_c = transcript->template receive_from_prover(commitment_labels.main_mem_idx_c); - commitments.main_mem_idx_d = transcript->template receive_from_prover(commitment_labels.main_mem_idx_d); - commitments.main_mem_op_a = transcript->template receive_from_prover(commitment_labels.main_mem_op_a); - commitments.main_mem_op_activate_gas = - transcript->template receive_from_prover(commitment_labels.main_mem_op_activate_gas); - commitments.main_mem_op_b = transcript->template receive_from_prover(commitment_labels.main_mem_op_b); - commitments.main_mem_op_c = transcript->template receive_from_prover(commitment_labels.main_mem_op_c); - commitments.main_mem_op_d = transcript->template receive_from_prover(commitment_labels.main_mem_op_d); + commitments.main_mem_addr_a = + transcript->template receive_from_prover(commitment_labels.main_mem_addr_a); + commitments.main_mem_addr_b = + transcript->template receive_from_prover(commitment_labels.main_mem_addr_b); + commitments.main_mem_addr_c = + transcript->template receive_from_prover(commitment_labels.main_mem_addr_c); + commitments.main_mem_addr_d = + transcript->template receive_from_prover(commitment_labels.main_mem_addr_d); commitments.main_op_err = transcript->template receive_from_prover(commitment_labels.main_op_err); commitments.main_opcode_val = transcript->template receive_from_prover(commitment_labels.main_opcode_val); commitments.main_pc = transcript->template receive_from_prover(commitment_labels.main_pc); - commitments.main_q_kernel_lookup = - transcript->template receive_from_prover(commitment_labels.main_q_kernel_lookup); - commitments.main_q_kernel_output_lookup = - transcript->template receive_from_prover(commitment_labels.main_q_kernel_output_lookup); commitments.main_r_in_tag = transcript->template receive_from_prover(commitment_labels.main_r_in_tag); commitments.main_rwa = transcript->template receive_from_prover(commitment_labels.main_rwa); commitments.main_rwb = transcript->template receive_from_prover(commitment_labels.main_rwb); commitments.main_rwc = transcript->template receive_from_prover(commitment_labels.main_rwc); commitments.main_rwd = transcript->template receive_from_prover(commitment_labels.main_rwd); - commitments.main_sel_cmov = transcript->template receive_from_prover(commitment_labels.main_sel_cmov); - commitments.main_sel_external_call = - transcript->template receive_from_prover(commitment_labels.main_sel_external_call); - commitments.main_sel_halt = transcript->template receive_from_prover(commitment_labels.main_sel_halt); - commitments.main_sel_internal_call = - transcript->template receive_from_prover(commitment_labels.main_sel_internal_call); - commitments.main_sel_internal_return = - transcript->template receive_from_prover(commitment_labels.main_sel_internal_return); - commitments.main_sel_jump = transcript->template receive_from_prover(commitment_labels.main_sel_jump); - commitments.main_sel_jumpi = transcript->template receive_from_prover(commitment_labels.main_sel_jumpi); - commitments.main_sel_mov = transcript->template receive_from_prover(commitment_labels.main_sel_mov); - commitments.main_sel_mov_a = transcript->template receive_from_prover(commitment_labels.main_sel_mov_a); - commitments.main_sel_mov_b = transcript->template receive_from_prover(commitment_labels.main_sel_mov_b); + commitments.main_sel_alu = transcript->template receive_from_prover(commitment_labels.main_sel_alu); + commitments.main_sel_bin = transcript->template receive_from_prover(commitment_labels.main_sel_bin); + commitments.main_sel_gas_accounting_active = + transcript->template receive_from_prover(commitment_labels.main_sel_gas_accounting_active); + commitments.main_sel_last = transcript->template receive_from_prover(commitment_labels.main_sel_last); + commitments.main_sel_mem_op_a = + transcript->template receive_from_prover(commitment_labels.main_sel_mem_op_a); + commitments.main_sel_mem_op_activate_gas = + transcript->template receive_from_prover(commitment_labels.main_sel_mem_op_activate_gas); + commitments.main_sel_mem_op_b = + transcript->template receive_from_prover(commitment_labels.main_sel_mem_op_b); + commitments.main_sel_mem_op_c = + transcript->template receive_from_prover(commitment_labels.main_sel_mem_op_c); + commitments.main_sel_mem_op_d = + transcript->template receive_from_prover(commitment_labels.main_sel_mem_op_d); + commitments.main_sel_mov_ia_to_ic = + transcript->template receive_from_prover(commitment_labels.main_sel_mov_ia_to_ic); + commitments.main_sel_mov_ib_to_ic = + transcript->template receive_from_prover(commitment_labels.main_sel_mov_ib_to_ic); commitments.main_sel_op_add = transcript->template receive_from_prover(commitment_labels.main_sel_op_add); commitments.main_sel_op_address = @@ -351,6 +349,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.main_sel_op_cast); commitments.main_sel_op_chain_id = transcript->template receive_from_prover(commitment_labels.main_sel_op_chain_id); + commitments.main_sel_op_cmov = + transcript->template receive_from_prover(commitment_labels.main_sel_op_cmov); commitments.main_sel_op_coinbase = transcript->template receive_from_prover(commitment_labels.main_sel_op_coinbase); commitments.main_sel_op_dagasleft = @@ -366,6 +366,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.main_sel_op_emit_unencrypted_log); commitments.main_sel_op_eq = transcript->template receive_from_prover(commitment_labels.main_sel_op_eq); + commitments.main_sel_op_external_call = + transcript->template receive_from_prover(commitment_labels.main_sel_op_external_call); commitments.main_sel_op_fdiv = transcript->template receive_from_prover(commitment_labels.main_sel_op_fdiv); commitments.main_sel_op_fee_per_da_gas = @@ -374,6 +376,16 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.main_sel_op_fee_per_l2_gas); commitments.main_sel_op_get_contract_instance = transcript->template receive_from_prover(commitment_labels.main_sel_op_get_contract_instance); + commitments.main_sel_op_halt = + transcript->template receive_from_prover(commitment_labels.main_sel_op_halt); + commitments.main_sel_op_internal_call = + transcript->template receive_from_prover(commitment_labels.main_sel_op_internal_call); + commitments.main_sel_op_internal_return = + transcript->template receive_from_prover(commitment_labels.main_sel_op_internal_return); + commitments.main_sel_op_jump = + transcript->template receive_from_prover(commitment_labels.main_sel_op_jump); + commitments.main_sel_op_jumpi = + transcript->template receive_from_prover(commitment_labels.main_sel_op_jumpi); commitments.main_sel_op_keccak = transcript->template receive_from_prover(commitment_labels.main_sel_op_keccak); commitments.main_sel_op_l1_to_l2_msg_exists = @@ -383,6 +395,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.main_sel_op_lt); commitments.main_sel_op_lte = transcript->template receive_from_prover(commitment_labels.main_sel_op_lte); + commitments.main_sel_op_mov = + transcript->template receive_from_prover(commitment_labels.main_sel_op_mov); commitments.main_sel_op_mul = transcript->template receive_from_prover(commitment_labels.main_sel_op_mul); commitments.main_sel_op_not = @@ -422,6 +436,18 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.main_sel_op_version); commitments.main_sel_op_xor = transcript->template receive_from_prover(commitment_labels.main_sel_op_xor); + commitments.main_sel_q_kernel_lookup = + transcript->template receive_from_prover(commitment_labels.main_sel_q_kernel_lookup); + commitments.main_sel_q_kernel_output_lookup = + transcript->template receive_from_prover(commitment_labels.main_sel_q_kernel_output_lookup); + commitments.main_sel_resolve_ind_addr_a = + transcript->template receive_from_prover(commitment_labels.main_sel_resolve_ind_addr_a); + commitments.main_sel_resolve_ind_addr_b = + transcript->template receive_from_prover(commitment_labels.main_sel_resolve_ind_addr_b); + commitments.main_sel_resolve_ind_addr_c = + transcript->template receive_from_prover(commitment_labels.main_sel_resolve_ind_addr_c); + commitments.main_sel_resolve_ind_addr_d = + transcript->template receive_from_prover(commitment_labels.main_sel_resolve_ind_addr_d); commitments.main_sel_rng_16 = transcript->template receive_from_prover(commitment_labels.main_sel_rng_16); commitments.main_sel_rng_8 = transcript->template receive_from_prover(commitment_labels.main_sel_rng_8); @@ -436,26 +462,33 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.mem_diff_lo); commitments.mem_diff_mid = transcript->template receive_from_prover(commitment_labels.mem_diff_mid); commitments.mem_glob_addr = transcript->template receive_from_prover(commitment_labels.mem_glob_addr); - commitments.mem_ind_op_a = transcript->template receive_from_prover(commitment_labels.mem_ind_op_a); - commitments.mem_ind_op_b = transcript->template receive_from_prover(commitment_labels.mem_ind_op_b); - commitments.mem_ind_op_c = transcript->template receive_from_prover(commitment_labels.mem_ind_op_c); - commitments.mem_ind_op_d = transcript->template receive_from_prover(commitment_labels.mem_ind_op_d); commitments.mem_last = transcript->template receive_from_prover(commitment_labels.mem_last); commitments.mem_lastAccess = transcript->template receive_from_prover(commitment_labels.mem_lastAccess); - commitments.mem_mem_sel = transcript->template receive_from_prover(commitment_labels.mem_mem_sel); commitments.mem_one_min_inv = transcript->template receive_from_prover(commitment_labels.mem_one_min_inv); - commitments.mem_op_a = transcript->template receive_from_prover(commitment_labels.mem_op_a); - commitments.mem_op_b = transcript->template receive_from_prover(commitment_labels.mem_op_b); - commitments.mem_op_c = transcript->template receive_from_prover(commitment_labels.mem_op_c); - commitments.mem_op_d = transcript->template receive_from_prover(commitment_labels.mem_op_d); commitments.mem_r_in_tag = transcript->template receive_from_prover(commitment_labels.mem_r_in_tag); - commitments.mem_rng_chk_sel = - transcript->template receive_from_prover(commitment_labels.mem_rng_chk_sel); commitments.mem_rw = transcript->template receive_from_prover(commitment_labels.mem_rw); - commitments.mem_sel_cmov = transcript->template receive_from_prover(commitment_labels.mem_sel_cmov); - commitments.mem_sel_mov_a = transcript->template receive_from_prover(commitment_labels.mem_sel_mov_a); - commitments.mem_sel_mov_b = transcript->template receive_from_prover(commitment_labels.mem_sel_mov_b); + commitments.mem_sel_mem = transcript->template receive_from_prover(commitment_labels.mem_sel_mem); + commitments.mem_sel_mov_ia_to_ic = + transcript->template receive_from_prover(commitment_labels.mem_sel_mov_ia_to_ic); + commitments.mem_sel_mov_ib_to_ic = + transcript->template receive_from_prover(commitment_labels.mem_sel_mov_ib_to_ic); + commitments.mem_sel_op_a = transcript->template receive_from_prover(commitment_labels.mem_sel_op_a); + commitments.mem_sel_op_b = transcript->template receive_from_prover(commitment_labels.mem_sel_op_b); + commitments.mem_sel_op_c = transcript->template receive_from_prover(commitment_labels.mem_sel_op_c); + commitments.mem_sel_op_cmov = + transcript->template receive_from_prover(commitment_labels.mem_sel_op_cmov); + commitments.mem_sel_op_d = transcript->template receive_from_prover(commitment_labels.mem_sel_op_d); + commitments.mem_sel_resolve_ind_addr_a = + transcript->template receive_from_prover(commitment_labels.mem_sel_resolve_ind_addr_a); + commitments.mem_sel_resolve_ind_addr_b = + transcript->template receive_from_prover(commitment_labels.mem_sel_resolve_ind_addr_b); + commitments.mem_sel_resolve_ind_addr_c = + transcript->template receive_from_prover(commitment_labels.mem_sel_resolve_ind_addr_c); + commitments.mem_sel_resolve_ind_addr_d = + transcript->template receive_from_prover(commitment_labels.mem_sel_resolve_ind_addr_d); + commitments.mem_sel_rng_chk = + transcript->template receive_from_prover(commitment_labels.mem_sel_rng_chk); commitments.mem_skip_check_tag = transcript->template receive_from_prover(commitment_labels.mem_skip_check_tag); commitments.mem_space_id = transcript->template receive_from_prover(commitment_labels.mem_space_id); @@ -468,20 +501,20 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.pedersen_input); commitments.pedersen_output = transcript->template receive_from_prover(commitment_labels.pedersen_output); - commitments.pedersen_pedersen_sel = - transcript->template receive_from_prover(commitment_labels.pedersen_pedersen_sel); + commitments.pedersen_sel_pedersen = + transcript->template receive_from_prover(commitment_labels.pedersen_sel_pedersen); commitments.poseidon2_clk = transcript->template receive_from_prover(commitment_labels.poseidon2_clk); commitments.poseidon2_input = transcript->template receive_from_prover(commitment_labels.poseidon2_input); commitments.poseidon2_output = transcript->template receive_from_prover(commitment_labels.poseidon2_output); - commitments.poseidon2_poseidon_perm_sel = - transcript->template receive_from_prover(commitment_labels.poseidon2_poseidon_perm_sel); + commitments.poseidon2_sel_poseidon_perm = + transcript->template receive_from_prover(commitment_labels.poseidon2_sel_poseidon_perm); commitments.sha256_clk = transcript->template receive_from_prover(commitment_labels.sha256_clk); commitments.sha256_input = transcript->template receive_from_prover(commitment_labels.sha256_input); commitments.sha256_output = transcript->template receive_from_prover(commitment_labels.sha256_output); - commitments.sha256_sha256_compression_sel = - transcript->template receive_from_prover(commitment_labels.sha256_sha256_compression_sel); + commitments.sha256_sel_sha256_compression = + transcript->template receive_from_prover(commitment_labels.sha256_sel_sha256_compression); commitments.sha256_state = transcript->template receive_from_prover(commitment_labels.sha256_state); commitments.lookup_byte_lengths_counts = transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); @@ -586,14 +619,14 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vectortemplate receive_from_prover(commitment_labels.perm_main_mem_c); commitments.perm_main_mem_d = transcript->template receive_from_prover(commitment_labels.perm_main_mem_d); - commitments.perm_main_mem_ind_a = - transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_a); - commitments.perm_main_mem_ind_b = - transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_b); - commitments.perm_main_mem_ind_c = - transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_c); - commitments.perm_main_mem_ind_d = - transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_d); + commitments.perm_main_mem_ind_addr_a = + transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_addr_a); + commitments.perm_main_mem_ind_addr_b = + transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_addr_b); + commitments.perm_main_mem_ind_addr_c = + transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_addr_c); + commitments.perm_main_mem_ind_addr_d = + transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_addr_d); commitments.lookup_byte_lengths = transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths); commitments.lookup_byte_operations = diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp index 7445a5c2dca..0db934ed1ed 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp @@ -8,6 +8,7 @@ #include namespace tests_avm { + using namespace bb; using namespace bb::avm_trace; @@ -25,18 +26,18 @@ void common_validate_arithmetic_op(Row const& main_row, { // Check that the correct result is stored at the expected memory location. EXPECT_EQ(main_row.main_ic, c); - EXPECT_EQ(main_row.main_mem_idx_c, addr_c); - EXPECT_EQ(main_row.main_mem_op_c, FF(1)); + EXPECT_EQ(main_row.main_mem_addr_c, addr_c); + EXPECT_EQ(main_row.main_sel_mem_op_c, FF(1)); EXPECT_EQ(main_row.main_rwc, FF(1)); // Check that ia and ib registers are correctly set with memory load operations. EXPECT_EQ(main_row.main_ia, a); - EXPECT_EQ(main_row.main_mem_idx_a, addr_a); - EXPECT_EQ(main_row.main_mem_op_a, FF(1)); + EXPECT_EQ(main_row.main_mem_addr_a, addr_a); + EXPECT_EQ(main_row.main_sel_mem_op_a, FF(1)); EXPECT_EQ(main_row.main_rwa, FF(0)); EXPECT_EQ(main_row.main_ib, b); - EXPECT_EQ(main_row.main_mem_idx_b, addr_b); - EXPECT_EQ(main_row.main_mem_op_b, FF(1)); + EXPECT_EQ(main_row.main_mem_addr_b, addr_b); + EXPECT_EQ(main_row.main_sel_mem_op_b, FF(1)); EXPECT_EQ(main_row.main_rwb, FF(0)); // Check the read instruction tag @@ -463,8 +464,8 @@ TEST_F(AvmArithmeticTestsFF, fDivision) // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(row != trace.end()); EXPECT_EQ(row->main_ic, FF(21)); - EXPECT_EQ(row->main_mem_idx_c, FF(2)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, FF(2)); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); validate_trace(std::move(trace), public_inputs); @@ -486,8 +487,8 @@ TEST_F(AvmArithmeticTestsFF, fDivisionNumeratorZero) // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(row != trace.end()); EXPECT_EQ(row->main_ic, FF(0)); - EXPECT_EQ(row->main_mem_idx_c, FF(0)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, FF(0)); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); validate_trace(std::move(trace), public_inputs); @@ -510,8 +511,8 @@ TEST_F(AvmArithmeticTestsFF, fDivisionByZeroError) // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(row != trace.end()); EXPECT_EQ(row->main_ic, FF(0)); - EXPECT_EQ(row->main_mem_idx_c, FF(2)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, FF(2)); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); EXPECT_EQ(row->main_op_err, FF(1)); @@ -533,8 +534,8 @@ TEST_F(AvmArithmeticTestsFF, fDivisionZeroByZeroError) // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(row != trace.end()); EXPECT_EQ(row->main_ic, FF(0)); - EXPECT_EQ(row->main_mem_idx_c, FF(2)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, FF(2)); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); EXPECT_EQ(row->main_op_err, FF(1)); @@ -635,8 +636,8 @@ TEST_F(AvmArithmeticTests, DivisionByZeroError) // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(row != trace.end()); EXPECT_EQ(row->main_ic, FF(0)); - EXPECT_EQ(row->main_mem_idx_c, FF(2)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, FF(2)); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); EXPECT_EQ(row->main_op_err, FF(1)); @@ -2314,7 +2315,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, multiplicationSecondRowNoOp) auto alu_row_index = common_validate_mul(trace, FF(3), FF(4), FF(12), FF(0), FF(1), FF(2), AvmMemoryTag::U128); // We have to enable alu_sel otherwise another relation will fail. - trace.at(alu_row_index + 1).alu_alu_sel = 1; + trace.at(alu_row_index + 1).alu_sel_alu = 1; // Add an LTE selector in the next row (second part of U128 multiplication) auto trace_lte = trace; @@ -2325,13 +2326,13 @@ TEST_F(AvmArithmeticNegativeTestsU128, multiplicationSecondRowNoOp) auto trace_sub = trace; trace_sub.at(alu_row_index + 1).alu_op_sub = 1; // Adjust to not violate #[RNG_CHK_LOOKUP_SELECTOR] - trace_sub.at(alu_row_index + 1).alu_rng_chk_lookup_selector = 2; + trace_sub.at(alu_row_index + 1).alu_sel_rng_chk_lookup = 2; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace_sub)), "TWO_LINE_OP_NO_OVERLAP"); // Try with another MUL selector. trace.at(alu_row_index + 1).alu_op_mul = 1; // Adjust to not violate #[RNG_CHK_LOOKUP_SELECTOR] - trace.at(alu_row_index + 1).alu_rng_chk_lookup_selector = 2; + trace.at(alu_row_index + 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_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index 3bdef33f39f..ff1c4168616 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -12,6 +12,7 @@ #include namespace tests_avm { + using namespace bb; using namespace bb::avm_trace; @@ -38,14 +39,14 @@ void common_validate_op_not(std::vector const& trace, // Check that the correct result is stored at the expected memory location. EXPECT_EQ(row->main_ic, c); - EXPECT_EQ(row->main_mem_idx_c, addr_c); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, addr_c); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); // Check that ia register is correctly set with memory load operations. EXPECT_EQ(row->main_ia, a); - EXPECT_EQ(row->main_mem_idx_a, addr_a); - EXPECT_EQ(row->main_mem_op_a, FF(1)); + EXPECT_EQ(row->main_mem_addr_a, addr_a); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); EXPECT_EQ(row->main_rwa, FF(0)); // Check the instruction tags @@ -106,20 +107,20 @@ void common_validate_shift_op(std::vector const& trace, // Check that the correct result is stored at the expected memory location. EXPECT_EQ(row->main_ic, c); - EXPECT_EQ(row->main_mem_idx_c, addr_c); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, addr_c); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); // Check that ia register is correctly set with memory load operations. EXPECT_EQ(row->main_ia, a); - EXPECT_EQ(row->main_mem_idx_a, addr_a); - EXPECT_EQ(row->main_mem_op_a, FF(1)); + EXPECT_EQ(row->main_mem_addr_a, addr_a); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); EXPECT_EQ(row->main_rwa, FF(0)); // Check that ib register is correctly set with memory load operations. EXPECT_EQ(row->main_ib, b); - EXPECT_EQ(row->main_mem_idx_b, addr_b); - EXPECT_EQ(row->main_mem_op_b, FF(1)); + EXPECT_EQ(row->main_mem_addr_b, addr_b); + EXPECT_EQ(row->main_sel_mem_op_b, FF(1)); EXPECT_EQ(row->main_rwb, FF(0)); // Check the instruction tags @@ -161,20 +162,20 @@ void common_validate_bit_op(std::vector const& trace, // Check that the correct result is stored at the expected memory location. EXPECT_EQ(row->main_ic, c); - EXPECT_EQ(row->main_mem_idx_c, addr_c); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_mem_addr_c, addr_c); + EXPECT_EQ(row->main_sel_mem_op_c, FF(1)); EXPECT_EQ(row->main_rwc, FF(1)); // Check that ia register is correctly set with memory load operations. EXPECT_EQ(row->main_ia, a); - EXPECT_EQ(row->main_mem_idx_a, addr_a); - EXPECT_EQ(row->main_mem_op_a, FF(1)); + EXPECT_EQ(row->main_mem_addr_a, addr_a); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); EXPECT_EQ(row->main_rwa, FF(0)); // Check that ia register is correctly set with memory load operations. EXPECT_EQ(row->main_ib, b); - EXPECT_EQ(row->main_mem_idx_b, addr_b); - EXPECT_EQ(row->main_mem_op_b, FF(1)); + EXPECT_EQ(row->main_mem_addr_b, addr_b); + EXPECT_EQ(row->main_sel_mem_op_b, FF(1)); EXPECT_EQ(row->main_rwb, FF(0)); // Check the instruction tags @@ -187,7 +188,7 @@ void common_validate_bit_op(std::vector const& trace, EXPECT_EQ(bin_row_start->binary_acc_ic, c); EXPECT_EQ(bin_row_start->binary_op_id, op_id); - EXPECT_EQ(bin_row_start->binary_bin_sel, FF(1)); + EXPECT_EQ(bin_row_start->binary_sel_bin, FF(1)); EXPECT_EQ(bin_row_start->binary_in_tag, static_cast(tag)); } @@ -320,7 +321,7 @@ std::vector gen_mutated_trace_bit(std::vector trace, FF ctr = trace.at(i).binary_mem_tag_ctr; if (ctr == FF::one()) { // If the tag is currently 1, it will be set to 0 which means we need to set bin_sel to 0. - trace.at(i).binary_bin_sel = FF(0); + trace.at(i).binary_sel_bin = FF(0); trace.at(i).binary_mem_tag_ctr = FF(0); trace.at(i).binary_mem_tag_ctr_inv = FF(0); } else if (ctr == FF::zero()) { @@ -330,13 +331,13 @@ std::vector gen_mutated_trace_bit(std::vector trace, // Replace the values with the next row's values trace.at(i).binary_mem_tag_ctr = trace.at(i + 1).binary_mem_tag_ctr; trace.at(i).binary_mem_tag_ctr_inv = trace.at(i + 1).binary_mem_tag_ctr_inv; - trace.at(i).binary_bin_sel = trace.at(i + 1).binary_bin_sel; + trace.at(i).binary_sel_bin = trace.at(i + 1).binary_sel_bin; } } break; } case IncorrectBinSelector: - binary_row->binary_bin_sel = FF(0); + binary_row->binary_sel_bin = FF(0); break; } return trace; @@ -604,7 +605,7 @@ std::vector> bit_failures = { { "LOOKUP_BYTE_LENGTHS", BIT_FAILURES::ByteLengthError }, { "LOOKUP_BYTE_OPERATIONS", BIT_FAILURES::ByteLookupError }, { "OP_ID_REL", BIT_FAILURES::InconsistentOpId }, - { "BIN_SEL_CTR_REL", BIT_FAILURES::IncorrectBinSelector }, + { "SEL_BIN_CTR_REL", BIT_FAILURES::IncorrectBinSelector }, }; std::vector shift_failures = { SHIFT_FAILURES::IncorrectShiftPastBitLength, SHIFT_FAILURES::IncorrectInputDecomposition, 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 ba933285f11..040a1937688 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_cast.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_cast.test.cpp @@ -4,7 +4,10 @@ #include #include +#define ALU_ROW_FIELD_EQ(field_name, expression) Field(#field_name, &Row::alu_##field_name, expression) + namespace tests_avm { + using namespace bb; using namespace bb::avm_trace; using namespace testing; @@ -14,9 +17,9 @@ class AvmCastTests : public ::testing::Test { VmPublicInputs public_inputs{}; AvmTraceBuilder trace_builder; std::vector trace; - size_t main_idx; - size_t alu_idx; - size_t mem_idx_c; + size_t main_addr; + size_t alu_addr; + size_t mem_addr_c; // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. void SetUp() override @@ -43,20 +46,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_idx = static_cast(row - trace.begin()); + main_addr = 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_idx = static_cast(alu_row - trace.begin()); + alu_addr = 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_idx_c = static_cast(mem_row_c - trace.begin()); + mem_addr_c = static_cast(mem_row_c - trace.begin()); } void validate_cast_trace(FF const& a, @@ -69,47 +72,46 @@ class AvmCastTests : public ::testing::Test { ) { - auto const& row = trace.at(main_idx); + auto const& row = trace.at(main_addr); EXPECT_THAT(row, - AllOf(Field("sel_op_cast", &Row::main_sel_op_cast, 1), - Field("ia", &Row::main_ia, a), - Field("ib", &Row::main_ib, 0), - Field("ic", &Row::main_ic, cast_val), - Field("r_in_tag", &Row::main_r_in_tag, static_cast(src_tag)), - Field("w_in_tag", &Row::main_w_in_tag, static_cast(dst_tag)), - Field("alu_in_tag", &Row::main_alu_in_tag, static_cast(dst_tag)), - Field("op_a", &Row::main_mem_op_a, 1), - Field("op_c", &Row::main_mem_op_c, 1), - Field("rwa", &Row::main_rwa, 0), - Field("rwc", &Row::main_rwc, 1), - Field("mem_idx_a", &Row::main_mem_idx_a, src_address), - Field("mem_idx_c", &Row::main_mem_idx_c, dst_address), - Field("tag_err", &Row::main_tag_err, 0), - Field("alu_sel", &Row::main_alu_sel, 1), - Field("sel_rng_8", &Row::main_sel_rng_8, 1), - Field("sel_rng_16", &Row::main_sel_rng_16, 1))); - - auto const& alu_row = trace.at(alu_idx); + AllOf(MAIN_ROW_FIELD_EQ(sel_op_cast, 1), + MAIN_ROW_FIELD_EQ(ia, a), + MAIN_ROW_FIELD_EQ(ib, 0), + MAIN_ROW_FIELD_EQ(ic, cast_val), + MAIN_ROW_FIELD_EQ(r_in_tag, static_cast(src_tag)), + MAIN_ROW_FIELD_EQ(w_in_tag, static_cast(dst_tag)), + MAIN_ROW_FIELD_EQ(alu_in_tag, static_cast(dst_tag)), + MAIN_ROW_FIELD_EQ(sel_mem_op_a, 1), + MAIN_ROW_FIELD_EQ(sel_mem_op_c, 1), + MAIN_ROW_FIELD_EQ(rwa, 0), + MAIN_ROW_FIELD_EQ(rwc, 1), + MAIN_ROW_FIELD_EQ(mem_addr_a, src_address), + MAIN_ROW_FIELD_EQ(mem_addr_c, dst_address), + MAIN_ROW_FIELD_EQ(tag_err, 0), + MAIN_ROW_FIELD_EQ(sel_alu, 1), + MAIN_ROW_FIELD_EQ(sel_rng_8, 1), + MAIN_ROW_FIELD_EQ(sel_rng_16, 1))); + + auto const& alu_row = trace.at(alu_addr); EXPECT_THAT(alu_row, - AllOf(Field("op_cast", &Row::alu_op_cast, 1), - Field("alu_ia", &Row::alu_ia, a), - Field("alu_ib", &Row::alu_ib, 0), - Field("alu_ic", &Row::alu_ic, cast_val), - Field("u8_tag", &Row::alu_u8_tag, dst_tag == AvmMemoryTag::U8), - Field("u16_tag", &Row::alu_u16_tag, dst_tag == AvmMemoryTag::U16), - Field("u32_tag", &Row::alu_u32_tag, dst_tag == AvmMemoryTag::U32), - Field("u64_tag", &Row::alu_u64_tag, dst_tag == AvmMemoryTag::U64), - Field("u128_tag", &Row::alu_u128_tag, dst_tag == AvmMemoryTag::U128), - Field("ff_tag", &Row::alu_ff_tag, dst_tag == AvmMemoryTag::FF), - Field("in_tag", &Row::alu_in_tag, static_cast(dst_tag)), - Field("op_cast_prev", &Row::alu_op_cast_prev, 0), - Field("lookup_selector", &Row::alu_rng_chk_lookup_selector, 1), - Field("alu_sel", &Row::alu_alu_sel, 1))); + AllOf(ALU_ROW_FIELD_EQ(op_cast, 1), + ALU_ROW_FIELD_EQ(ia, a), + ALU_ROW_FIELD_EQ(ib, 0), + ALU_ROW_FIELD_EQ(ic, cast_val), + ALU_ROW_FIELD_EQ(u8_tag, dst_tag == AvmMemoryTag::U8), + ALU_ROW_FIELD_EQ(u16_tag, dst_tag == AvmMemoryTag::U16), + ALU_ROW_FIELD_EQ(u32_tag, dst_tag == AvmMemoryTag::U32), + ALU_ROW_FIELD_EQ(u64_tag, dst_tag == AvmMemoryTag::U64), + ALU_ROW_FIELD_EQ(u128_tag, dst_tag == AvmMemoryTag::U128), + ALU_ROW_FIELD_EQ(ff_tag, dst_tag == AvmMemoryTag::FF), + ALU_ROW_FIELD_EQ(in_tag, static_cast(dst_tag)), + ALU_ROW_FIELD_EQ(op_cast_prev, 0), + ALU_ROW_FIELD_EQ(sel_rng_chk_lookup, 1), + ALU_ROW_FIELD_EQ(sel_alu, 1))); // Check that there is a second ALU row - auto alu_row_next = trace.at(alu_idx + 1); - EXPECT_THAT(alu_row_next, - AllOf(Field("op_cast", &Row::alu_op_cast, 0), Field("op_cast_prev", &Row::alu_op_cast_prev, 1))); + auto alu_row_next = trace.at(alu_addr + 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. @@ -231,20 +233,20 @@ TEST_F(AvmCastTests, indirectAddrWrongResolutionU64ToU8) ASSERT_TRUE(row != trace.end()); EXPECT_THAT(*row, - AllOf(Field("sel_op_cast", &Row::main_sel_op_cast, 1), - Field("r_in_tag", &Row::main_r_in_tag, static_cast(AvmMemoryTag::U64)), - Field("w_in_tag", &Row::main_w_in_tag, static_cast(AvmMemoryTag::U8)), - Field("alu_in_tag", &Row::main_alu_in_tag, static_cast(AvmMemoryTag::U8)), - Field("op_a", &Row::main_mem_op_a, 1), - Field("op_c", &Row::main_mem_op_c, 1), - Field("ind_op_a", &Row::main_ind_op_a, 1), - Field("ind_op_c", &Row::main_ind_op_c, 1), - Field("ind_a", &Row::main_ind_a, 5), - Field("ind_c", &Row::main_ind_c, 6), - Field("rwa", &Row::main_rwa, 0), - Field("rwc", &Row::main_rwc, 1), - Field("alu_sel", &Row::main_alu_sel, 0), // ALU trace not activated - Field("tag_err", &Row::main_tag_err, 1))); // Error activated + AllOf(MAIN_ROW_FIELD_EQ(sel_op_cast, 1), + MAIN_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U64)), + MAIN_ROW_FIELD_EQ(w_in_tag, static_cast(AvmMemoryTag::U8)), + MAIN_ROW_FIELD_EQ(alu_in_tag, static_cast(AvmMemoryTag::U8)), + MAIN_ROW_FIELD_EQ(sel_mem_op_a, 1), + MAIN_ROW_FIELD_EQ(sel_mem_op_c, 1), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_a, 1), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1), + MAIN_ROW_FIELD_EQ(ind_addr_a, 5), + MAIN_ROW_FIELD_EQ(ind_addr_c, 6), + MAIN_ROW_FIELD_EQ(rwa, 0), + MAIN_ROW_FIELD_EQ(rwc, 1), + MAIN_ROW_FIELD_EQ(sel_alu, 0), // ALU trace not activated + MAIN_ROW_FIELD_EQ(tag_err, 1))); // Error activated validate_trace(std::move(trace), public_inputs); } @@ -252,13 +254,13 @@ TEST_F(AvmCastTests, indirectAddrWrongResolutionU64ToU8) TEST_F(AvmCastNegativeTests, nonTruncatedOutputMainIc) { gen_trace(300, 0, 1, AvmMemoryTag::U16, AvmMemoryTag::U8); - ASSERT_EQ(trace.at(main_idx).main_ic, 44); + ASSERT_EQ(trace.at(main_addr).main_ic, 44); // Replace the output in main trace with the non-truncated value - trace.at(main_idx).main_ic = 300; + trace.at(main_addr).main_ic = 300; // Adapt the memory trace entry - trace.at(mem_idx_c).mem_val = 300; + trace.at(mem_addr_c).mem_val = 300; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -266,13 +268,13 @@ TEST_F(AvmCastNegativeTests, nonTruncatedOutputMainIc) TEST_F(AvmCastNegativeTests, wrongOutputMainIc) { gen_trace(151515, 0, 1, AvmMemoryTag::U32, AvmMemoryTag::FF); - ASSERT_EQ(trace.at(main_idx).main_ic, 151515); + ASSERT_EQ(trace.at(main_addr).main_ic, 151515); // Replace the output in main trace with a wrong value - trace.at(main_idx).main_ic = 151516; + trace.at(main_addr).main_ic = 151516; // Adapt the memory trace entry - trace.at(mem_idx_c).mem_val = 151516; + trace.at(mem_addr_c).mem_val = 151516; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -280,12 +282,12 @@ TEST_F(AvmCastNegativeTests, wrongOutputMainIc) TEST_F(AvmCastNegativeTests, wrongOutputAluIc) { gen_trace(6582736, 0, 1, AvmMemoryTag::U128, AvmMemoryTag::U16); - ASSERT_EQ(trace.at(alu_idx).alu_ic, 29136); + ASSERT_EQ(trace.at(alu_addr).alu_ic, 29136); // Replace output in ALU, MAIN, and MEM trace - trace.at(alu_idx).alu_ic = 33; - trace.at(main_idx).main_ic = 33; - trace.at(mem_idx_c).mem_val = 33; + trace.at(alu_addr).alu_ic = 33; + trace.at(main_addr).main_ic = 33; + trace.at(mem_addr_c).mem_val = 33; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_CAST"); } @@ -298,7 +300,7 @@ TEST_F(AvmCastNegativeTests, wrongLimbDecompositionInput) trace = trace_builder.finalize(); gen_indices(); - trace.at(alu_idx).alu_a_lo -= 23; + trace.at(alu_addr).alu_a_lo -= 23; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INPUT_DECOMP_1"); } @@ -306,9 +308,9 @@ TEST_F(AvmCastNegativeTests, wrongLimbDecompositionInput) TEST_F(AvmCastNegativeTests, wrongPSubALo) { gen_trace(12345, 0, 1, AvmMemoryTag::U32, AvmMemoryTag::U16); - ASSERT_EQ(trace.at(alu_idx).alu_ic, 12345); + ASSERT_EQ(trace.at(alu_addr).alu_ic, 12345); - trace.at(alu_idx).alu_p_sub_a_lo += 3; + trace.at(alu_addr).alu_p_sub_a_lo += 3; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUB_LO_1"); } @@ -321,7 +323,7 @@ TEST_F(AvmCastNegativeTests, wrongPSubAHi) trace = trace_builder.finalize(); gen_indices(); - trace.at(alu_idx).alu_p_sub_a_hi += 3; + trace.at(alu_addr).alu_p_sub_a_hi += 3; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUB_HI_1"); } @@ -330,7 +332,7 @@ TEST_F(AvmCastNegativeTests, disableRangecheck) { gen_trace(123, 23, 43, AvmMemoryTag::U8, AvmMemoryTag::U8); - trace.at(alu_idx).alu_rng_chk_lookup_selector = 0; + trace.at(alu_addr).alu_sel_rng_chk_lookup = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "RNG_CHK_LOOKUP_SELECTOR"); } @@ -338,16 +340,16 @@ TEST_F(AvmCastNegativeTests, disableRangecheckSub) { gen_trace(123, 23, 43, AvmMemoryTag::U8, AvmMemoryTag::U8); - trace.at(alu_idx + 1).alu_rng_chk_lookup_selector = 0; + trace.at(alu_addr + 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_idx).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); - trace.at(alu_idx).alu_u16_r0 = 5555; + trace.at(alu_addr).alu_u16_r0 = 5555; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "LOWER_CMP_RNG_CHK"); } @@ -359,17 +361,17 @@ TEST_F(AvmCastNegativeTests, wrongRangeCheckDecompositionHi) trace = trace_builder.finalize(); gen_indices(); - trace.at(alu_idx).alu_u16_r9 = 5555; + trace.at(alu_addr).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_idx).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); - trace.at(alu_idx).alu_u8_r0 += 256; - trace.at(alu_idx).alu_u8_r1 -= 1; // Adjust so that the decomposition is correct. + trace.at(alu_addr).alu_u8_r0 += 256; + trace.at(alu_addr).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"); } @@ -377,10 +379,10 @@ TEST_F(AvmCastNegativeTests, outOfRangeU8Registers) TEST_F(AvmCastNegativeTests, outOfRangeU16Registers) { gen_trace(987344323, 23, 43, AvmMemoryTag::FF, AvmMemoryTag::U128); - ASSERT_EQ(trace.at(alu_idx).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); - trace.at(alu_idx).alu_u16_r0 += 65536; - trace.at(alu_idx).alu_u16_r1 -= 1; // Adjust so that the decomposition is correct. + trace.at(alu_addr).alu_u16_r0 += 65536; + trace.at(alu_addr).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"); } @@ -388,10 +390,10 @@ TEST_F(AvmCastNegativeTests, outOfRangeU16Registers) TEST_F(AvmCastNegativeTests, wrongCopySubLoForRangeCheck) { gen_trace(987344323, 23, 43, AvmMemoryTag::U64, AvmMemoryTag::U128); - ASSERT_EQ(trace.at(alu_idx).alu_ic, 987344323); + ASSERT_EQ(trace.at(alu_addr).alu_ic, 987344323); - ASSERT_EQ(trace.at(alu_idx + 1).alu_a_lo, trace.at(alu_idx).alu_p_sub_a_lo); - trace.at(alu_idx + 1).alu_a_lo -= 1; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OP_CAST_RNG_CHECK_P_SUB_A_LOW"); } @@ -403,33 +405,33 @@ TEST_F(AvmCastNegativeTests, wrongCopySubHiForRangeCheck) trace = trace_builder.finalize(); gen_indices(); - ASSERT_EQ(trace.at(alu_idx + 1).alu_a_hi, trace.at(alu_idx).alu_p_sub_a_hi); - trace.at(alu_idx + 1).alu_a_hi += 2; + 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; 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_idx).alu_ic, 183); + ASSERT_EQ(trace.at(alu_addr).alu_ic, 183); // We have to enable alu_sel otherwise another relation will fail. - trace.at(alu_idx + 1).alu_alu_sel = 1; + trace.at(alu_addr + 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_idx + 1).alu_op_lt = 1; + trace_lt.at(alu_addr + 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_idx + 1).alu_op_eq = 1; + trace_eq.at(alu_addr + 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_idx + 1).alu_op_cast = 1; + trace.at(alu_addr + 1).alu_op_cast = 1; // Adjust to not violate #[RNG_CHK_LOOKUP_SELECTOR] - trace.at(alu_idx + 1).alu_rng_chk_lookup_selector = 2; + trace.at(alu_addr + 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_comparison.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_comparison.test.cpp index 1bf44438e5e..38b028306f7 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_comparison.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_comparison.test.cpp @@ -14,6 +14,7 @@ #include namespace tests_avm { + using namespace bb; using namespace bb::avm_trace; namespace { @@ -32,20 +33,20 @@ void common_validate_cmp(Row const& row, // Use the row in the main trace to find the same operation in the alu trace. // Check that the correct result is stored at the expected memory location. EXPECT_EQ(row.main_ic, c); - EXPECT_EQ(row.main_mem_idx_c, addr_c); - EXPECT_EQ(row.main_mem_op_c, FF(1)); + EXPECT_EQ(row.main_mem_addr_c, addr_c); + EXPECT_EQ(row.main_sel_mem_op_c, FF(1)); EXPECT_EQ(row.main_rwc, FF(1)); // Check that ia register is correctly set with memory load operations. EXPECT_EQ(row.main_ia, a); - EXPECT_EQ(row.main_mem_idx_a, addr_a); - EXPECT_EQ(row.main_mem_op_a, FF(1)); + EXPECT_EQ(row.main_mem_addr_a, addr_a); + EXPECT_EQ(row.main_sel_mem_op_a, FF(1)); EXPECT_EQ(row.main_rwa, FF(0)); // Check that ib register is correctly set with memory load operations. EXPECT_EQ(row.main_ib, b); - EXPECT_EQ(row.main_mem_idx_b, addr_b); - EXPECT_EQ(row.main_mem_op_b, FF(1)); + EXPECT_EQ(row.main_mem_addr_b, addr_b); + EXPECT_EQ(row.main_sel_mem_op_b, FF(1)); EXPECT_EQ(row.main_rwb, FF(0)); // Check the instruction tags @@ -224,8 +225,8 @@ std::vector gen_mutated_trace_cmp( range_check_row->alu_cmp_rng_ctr = FF(0); break; case CounterNonZeroCheckFailed: - range_check_row->alu_rng_chk_sel = FF(0); - range_check_row->alu_rng_chk_lookup_selector = FF(0); + range_check_row->alu_sel_rng_chk = FF(0); + range_check_row->alu_sel_rng_chk_lookup = FF(0); break; case ShiftRelationFailed: range_check_row->alu_a_lo = range_check_row->alu_res_lo; 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 bf68433369e..eb2b13781d1 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 @@ -1,6 +1,7 @@ #include "avm_common.test.hpp" namespace tests_avm { + using namespace bb; using namespace bb::avm_trace; @@ -8,27 +9,27 @@ namespace { void validate_internal_call(Row const& row, uint32_t current_pc, uint32_t target_pc, uint32_t stack_ptr) { - EXPECT_EQ(row.main_sel_internal_call, FF(1)); + EXPECT_EQ(row.main_sel_op_internal_call, FF(1)); EXPECT_EQ(row.main_pc, FF(current_pc)); EXPECT_EQ(row.main_ia, FF(target_pc)); EXPECT_EQ(row.main_internal_return_ptr, FF(stack_ptr)); - EXPECT_EQ(row.main_mem_op_b, FF(1)); + EXPECT_EQ(row.main_sel_mem_op_b, FF(1)); EXPECT_EQ(row.main_rwb, FF(1)); EXPECT_EQ(row.main_ib, FF(current_pc + 1)); - EXPECT_EQ(row.main_mem_idx_b, FF(stack_ptr)); + EXPECT_EQ(row.main_mem_addr_b, FF(stack_ptr)); EXPECT_EQ(row.main_w_in_tag, FF(static_cast(AvmMemoryTag::U32))); EXPECT_EQ(row.main_space_id, FF(INTERNAL_CALL_SPACE_ID)); }; void validate_internal_return(Row const& row, uint32_t current_pc, uint32_t return_pc, uint32_t stack_ptr) { - EXPECT_EQ(row.main_sel_internal_return, FF(1)); + EXPECT_EQ(row.main_sel_op_internal_return, FF(1)); EXPECT_EQ(row.main_pc, FF(current_pc)); EXPECT_EQ(row.main_ia, FF(return_pc)); EXPECT_EQ(row.main_internal_return_ptr, FF(stack_ptr)); - EXPECT_EQ(row.main_mem_op_a, FF(1)); + EXPECT_EQ(row.main_sel_mem_op_a, FF(1)); EXPECT_EQ(row.main_rwa, FF(0)); - EXPECT_EQ(row.main_mem_idx_a, FF(stack_ptr - 1)); + EXPECT_EQ(row.main_mem_addr_a, FF(stack_ptr - 1)); EXPECT_EQ(row.main_r_in_tag, FF(static_cast(AvmMemoryTag::U32))); EXPECT_EQ(row.main_space_id, FF(INTERNAL_CALL_SPACE_ID)); }; @@ -74,8 +75,8 @@ TEST_F(AvmControlFlowTests, simpleCall) // Check call { - auto call_row_iter = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_internal_call == FF(1); }); + auto call_row_iter = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_internal_call == FF(1); }); EXPECT_TRUE(call_row_iter != trace.end()); auto& call_row = trace.at(static_cast(call_row_iter - trace.begin())); validate_internal_call(call_row, 0, CALL_PC, 0); @@ -84,7 +85,7 @@ TEST_F(AvmControlFlowTests, simpleCall) // Check halt { auto halt_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_halt == FF(1); }); + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_halt == FF(1); }); // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(halt_row != trace.end()); @@ -110,7 +111,7 @@ TEST_F(AvmControlFlowTests, simpleJump) // Check jump { auto call_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_jump == FF(1); }); + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_jump == FF(1); }); EXPECT_TRUE(call_row != trace.end()); EXPECT_EQ(call_row->main_pc, FF(0)); EXPECT_EQ(call_row->main_ia, FF(JUMP_PC)); @@ -119,7 +120,7 @@ TEST_F(AvmControlFlowTests, simpleJump) // Check halt { auto halt_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_halt == FF(1); }); + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_halt == FF(1); }); EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->main_pc, FF(JUMP_PC)); @@ -144,8 +145,8 @@ TEST_F(AvmControlFlowTests, simpleCallAndReturn) // Check call { - auto call_row_iter = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_internal_call == FF(1); }); + auto call_row_iter = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_internal_call == FF(1); }); EXPECT_TRUE(call_row_iter != trace.end()); auto& call_row = trace.at(static_cast(call_row_iter - trace.begin())); validate_internal_call(call_row, 0, CALL_PC, 0); @@ -153,8 +154,8 @@ TEST_F(AvmControlFlowTests, simpleCallAndReturn) // Check return { - auto return_row_iter = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_internal_return == FF(1); }); + auto return_row_iter = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_internal_return == FF(1); }); // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(return_row_iter != trace.end()); @@ -165,7 +166,7 @@ TEST_F(AvmControlFlowTests, simpleCallAndReturn) // Check halt { auto halt_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_halt == FF(1); }); + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_halt == FF(1); }); EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->main_pc, FF(RETURN_PC)); @@ -210,8 +211,9 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Check call 1 { - auto call_1 = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.main_sel_internal_call == FF(1) && r.main_ib == FF(1); }); + auto call_1 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.main_sel_op_internal_call == FF(1) && r.main_ib == FF(1); + }); EXPECT_TRUE(call_1 != trace.end()); auto& call_1_row = trace.at(static_cast(call_1 - trace.begin())); validate_internal_call(call_1_row, 0, CALL_PC_1, 0); @@ -220,7 +222,7 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Call 2 { auto call_2 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.main_sel_internal_call == FF(1) && r.main_pc == FF(CALL_PC_1); + return r.main_sel_op_internal_call == FF(1) && r.main_pc == FF(CALL_PC_1); }); EXPECT_TRUE(call_2 != trace.end()); auto& call_2_row = trace.at(static_cast(call_2 - trace.begin())); @@ -230,7 +232,7 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Call 3 { auto call_3 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.main_sel_internal_call == FF(1) && r.main_pc == FF(CALL_PC_2); + return r.main_sel_op_internal_call == FF(1) && r.main_pc == FF(CALL_PC_2); }); EXPECT_TRUE(call_3 != trace.end()); auto& call_3_row = trace.at(static_cast(call_3 - trace.begin())); @@ -239,8 +241,8 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Return 1 { - auto return_1 = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_internal_return == FF(1); }); + auto return_1 = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_internal_return == FF(1); }); EXPECT_TRUE(return_1 != trace.end()); auto& return_1_row = trace.at(static_cast(return_1 - trace.begin())); validate_internal_return(return_1_row, CALL_PC_3, CALL_PC_2 + 1, 3); @@ -249,7 +251,7 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Call 4 { auto call_4 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.main_sel_internal_call == FF(1) && r.main_pc == FF(CALL_PC_2 + 1); + return r.main_sel_op_internal_call == FF(1) && r.main_pc == FF(CALL_PC_2 + 1); }); EXPECT_TRUE(call_4 != trace.end()); auto& call_4_row = trace.at(static_cast(call_4 - trace.begin())); @@ -259,7 +261,7 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Return 2 { auto return_2 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.main_sel_internal_return == FF(1) && r.main_pc == FF(CALL_PC_4); + return r.main_sel_op_internal_return == FF(1) && r.main_pc == FF(CALL_PC_4); }); EXPECT_TRUE(return_2 != trace.end()); auto& return_2_row = trace.at(static_cast(return_2 - trace.begin())); @@ -269,7 +271,7 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Jump 1 { auto jump_1 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.main_sel_jump == FF(1) && r.main_pc == FF(CALL_PC_2 + 2); + return r.main_sel_op_jump == FF(1) && r.main_pc == FF(CALL_PC_2 + 2); }); EXPECT_TRUE(jump_1 != trace.end()); EXPECT_EQ(jump_1->main_ia, FF(JUMP_PC_1)); @@ -279,7 +281,7 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Return 3 { auto return_3 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.main_sel_internal_return == FF(1) && r.main_pc == FF(JUMP_PC_1); + return r.main_sel_op_internal_return == FF(1) && r.main_pc == FF(JUMP_PC_1); }); EXPECT_TRUE(return_3 != trace.end()); auto& return_3_row = trace.at(static_cast(return_3 - trace.begin())); @@ -289,7 +291,7 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) // Return 4 { auto return_4 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.main_sel_internal_return == FF(1) && r.main_pc == FF(CALL_PC_1 + 1); + return r.main_sel_op_internal_return == FF(1) && r.main_pc == FF(CALL_PC_1 + 1); }); EXPECT_TRUE(return_4 != trace.end()); auto& return_4_row = trace.at(static_cast(return_4 - trace.begin())); @@ -297,11 +299,12 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) } // Halt row - auto halt_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_halt == FF(1); }); + auto halt_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_halt == FF(1); }); EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->main_pc, FF(1)); validate_trace(std::move(trace), public_inputs); } + } // namespace tests_avm \ No newline at end of file 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 dd5839c603a..696d0641ba3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_execution.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_execution.test.cpp @@ -600,7 +600,7 @@ TEST_F(AvmExecutionTests, movOpcode) auto trace = gen_trace_from_instr(instructions); // Find the first row enabling the MOV selector - auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_mov == 1; }); + auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_mov == 1; }); EXPECT_EQ(row->main_ia, 19); EXPECT_EQ(row->main_ic, 19); @@ -654,7 +654,7 @@ TEST_F(AvmExecutionTests, cmovOpcode) auto trace = gen_trace_from_instr(instructions); // Find the first row enabling the CMOV selector - auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_cmov == 1; }); + auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_cmov == 1; }); EXPECT_EQ(row->main_ia, 3); EXPECT_EQ(row->main_ib, 4); EXPECT_EQ(row->main_ic, 3); @@ -704,7 +704,7 @@ TEST_F(AvmExecutionTests, indMovOpcode) auto trace = gen_trace_from_instr(instructions); // Find the first row enabling the MOV selector - auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_mov == 1; }); + auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_mov == 1; }); EXPECT_EQ(row->main_ia, 255); EXPECT_EQ(row->main_ic, 255); @@ -803,10 +803,10 @@ TEST_F(AvmExecutionTests, toRadixLeOpcode) // Find the first row enabling the TORADIXLE selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_radix_le == 1; }); - EXPECT_EQ(row->main_ind_a, 17); - EXPECT_EQ(row->main_ind_b, 21); - EXPECT_EQ(row->main_mem_idx_a, 1); // Indirect(17) -> 1 - EXPECT_EQ(row->main_mem_idx_b, 5); // Indirect(21) -> 5 + EXPECT_EQ(row->main_ind_addr_a, 17); + EXPECT_EQ(row->main_ind_addr_b, 21); + EXPECT_EQ(row->main_mem_addr_a, 1); // Indirect(17) -> 1 + EXPECT_EQ(row->main_mem_addr_b, 5); // Indirect(21) -> 5 EXPECT_EQ(row->main_ia, FF(FF::modulus - FF(1))); // Indirect(17) -> Direct(1) -> FF::modulus - FF(1) EXPECT_EQ(row->main_ib, 0); // Indirect(21) -> 5 -> Unintialized memory EXPECT_EQ(row->main_ic, 2); @@ -902,15 +902,15 @@ TEST_F(AvmExecutionTests, sha256CompressionOpcode) // Find the first row enabling the Sha256Compression selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_sha256 == 1; }); - EXPECT_EQ(row->main_ind_a, 34); - EXPECT_EQ(row->main_ind_b, 35); - EXPECT_EQ(row->main_ind_c, 36); - EXPECT_EQ(row->main_mem_idx_a, 1); // Indirect(34) -> 9 - EXPECT_EQ(row->main_mem_idx_b, 9); // Indirect(35) -> 9 - EXPECT_EQ(row->main_mem_idx_c, 256); // Indirect(36) -> 256 - EXPECT_EQ(row->main_ia, 1); // Trivially contains 0. (See avm_trace for explanation why) - EXPECT_EQ(row->main_ib, 1); // Contains first element of the state - EXPECT_EQ(row->main_ic, 0); // Contains first element of the input + EXPECT_EQ(row->main_ind_addr_a, 34); + EXPECT_EQ(row->main_ind_addr_b, 35); + EXPECT_EQ(row->main_ind_addr_c, 36); + EXPECT_EQ(row->main_mem_addr_a, 1); // Indirect(34) -> 9 + EXPECT_EQ(row->main_mem_addr_b, 9); // Indirect(35) -> 9 + EXPECT_EQ(row->main_mem_addr_c, 256); // Indirect(36) -> 256 + EXPECT_EQ(row->main_ia, 1); // Trivially contains 0. (See avm_trace for explanation why) + EXPECT_EQ(row->main_ib, 1); // Contains first element of the state + EXPECT_EQ(row->main_ic, 0); // Contains first element of the input EXPECT_EQ(returndata, expected_output); @@ -993,17 +993,17 @@ TEST_F(AvmExecutionTests, sha256Opcode) // Find the first row enabling the sha256 selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_sha256 == 1; }); - EXPECT_EQ(row->main_ind_a, 36); // Register A is indirect - EXPECT_EQ(row->main_ind_c, 35); // Register C is indirect - EXPECT_EQ(row->main_mem_idx_a, 1); // Indirect(36) -> 1 - EXPECT_EQ(row->main_mem_idx_c, 256); // Indirect(35) -> 256 + EXPECT_EQ(row->main_ind_addr_a, 36); // Register A is indirect + EXPECT_EQ(row->main_ind_addr_c, 35); // Register C is indirect + EXPECT_EQ(row->main_mem_addr_a, 1); // Indirect(36) -> 1 + EXPECT_EQ(row->main_mem_addr_c, 256); // Indirect(35) -> 256 EXPECT_EQ(row->main_ia, 97); EXPECT_EQ(row->main_ic, 0); // Register b checks are done in the next row due to the difference in the memory tag std::advance(row, 1); - EXPECT_EQ(row->main_ind_b, 0); // Register B is not - EXPECT_EQ(row->main_mem_idx_b, 37); // Load(37) -> input length - EXPECT_EQ(row->main_ib, 3); // Input length + EXPECT_EQ(row->main_ind_addr_b, 0); // Register B is not + EXPECT_EQ(row->main_mem_addr_b, 37); // Load(37) -> input length + EXPECT_EQ(row->main_ib, 3); // Input length EXPECT_EQ(returndata, expected_output); @@ -1069,10 +1069,10 @@ TEST_F(AvmExecutionTests, poseidon2PermutationOpCode) // Find the first row enabling the poseidon2 selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_poseidon2 == 1; }); - EXPECT_EQ(row->main_ind_a, 36); - EXPECT_EQ(row->main_ind_b, 35); - EXPECT_EQ(row->main_mem_idx_a, 1); // Indirect(36) -> 1 - EXPECT_EQ(row->main_mem_idx_b, 9); // Indirect(34) -> 9 + EXPECT_EQ(row->main_ind_addr_a, 36); + EXPECT_EQ(row->main_ind_addr_b, 35); + EXPECT_EQ(row->main_mem_addr_a, 1); // Indirect(36) -> 1 + EXPECT_EQ(row->main_mem_addr_b, 9); // Indirect(34) -> 9 EXPECT_EQ(row->main_ia, FF(std::string("9a807b615c4d3e2fa0b1c2d3e4f56789fedcba9876543210abcdef0123456789"))); EXPECT_EQ(row->main_ib, 0); // Contains first element of the output (trivially 0) @@ -1164,17 +1164,17 @@ TEST_F(AvmExecutionTests, keccakf1600OpCode) // Find the first row enabling the keccak selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_keccak == 1; }); - EXPECT_EQ(row->main_ind_a, 36); // Register A is indirect - EXPECT_EQ(row->main_ind_c, 35); // Register C is indirect - EXPECT_EQ(row->main_mem_idx_a, 1); // Indirect(36) -> 1 - EXPECT_EQ(row->main_mem_idx_c, 256); // Indirect(35) -> 256 + EXPECT_EQ(row->main_ind_addr_a, 36); // Register A is indirect + EXPECT_EQ(row->main_ind_addr_c, 35); // Register C is indirect + EXPECT_EQ(row->main_mem_addr_a, 1); // Indirect(36) -> 1 + EXPECT_EQ(row->main_mem_addr_c, 256); // Indirect(35) -> 256 EXPECT_EQ(row->main_ia, (0xF1258F7940E1DDE7LLU)); EXPECT_EQ(row->main_ic, 0); std::advance(row, 1); - EXPECT_EQ(row->main_ind_b, 0); // Register B is not - EXPECT_EQ(row->main_mem_idx_b, 37); // Load(37) -> input length - EXPECT_EQ(row->main_ib, 25); // Input length + EXPECT_EQ(row->main_ind_addr_b, 0); // Register B is not + EXPECT_EQ(row->main_mem_addr_b, 37); // Load(37) -> input length + EXPECT_EQ(row->main_ib, 25); // Input length EXPECT_EQ(returndata, expected_output); validate_trace(std::move(trace), public_inputs); @@ -1246,17 +1246,17 @@ TEST_F(AvmExecutionTests, keccakOpCode) // Find the first row enabling the keccak selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_keccak == 1; }); - EXPECT_EQ(row->main_ind_a, 36); // Register A is indirect - EXPECT_EQ(row->main_ind_c, 35); // Register C is indirect - EXPECT_EQ(row->main_mem_idx_a, 1); // Indirect(36) -> 1 - EXPECT_EQ(row->main_mem_idx_c, 256); // Indirect(35) -> 256 + EXPECT_EQ(row->main_ind_addr_a, 36); // Register A is indirect + EXPECT_EQ(row->main_ind_addr_c, 35); // Register C is indirect + EXPECT_EQ(row->main_mem_addr_a, 1); // Indirect(36) -> 1 + EXPECT_EQ(row->main_mem_addr_c, 256); // Indirect(35) -> 256 EXPECT_EQ(row->main_ia, 189); EXPECT_EQ(row->main_ic, 0); // Register b checks are done in the next row due to the difference in the memory tag std::advance(row, 1); - EXPECT_EQ(row->main_ind_b, 0); // Register B is not - EXPECT_EQ(row->main_mem_idx_b, 37); // Load(37) -> input length - EXPECT_EQ(row->main_ib, 1); // Input length + EXPECT_EQ(row->main_ind_addr_b, 0); // Register B is not + EXPECT_EQ(row->main_mem_addr_b, 37); // Load(37) -> input length + EXPECT_EQ(row->main_ib, 1); // Input length EXPECT_EQ(returndata, expected_output); @@ -1324,9 +1324,9 @@ TEST_F(AvmExecutionTests, pedersenHashOpCode) // Find the first row enabling the pedersen selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_pedersen == 1; }); - EXPECT_EQ(row->main_ind_a, 4); // Register A is indirect - EXPECT_EQ(row->main_mem_idx_a, 0); // Indirect(4) -> 1 - EXPECT_EQ(row->main_ia, 1); // The first input + EXPECT_EQ(row->main_ind_addr_a, 4); // Register A is indirect + EXPECT_EQ(row->main_mem_addr_a, 0); // Indirect(4) -> 1 + EXPECT_EQ(row->main_ia, 1); // The first input // The second row loads the U32 values std::advance(row, 1); EXPECT_EQ(row->main_ia, 2); // Input length is 2 @@ -1718,7 +1718,7 @@ TEST_F(AvmExecutionTests, l2GasLeft) GAS_COST_TABLE.at(OpCode::L2GASLEFT).l2_fixed_gas_cost; EXPECT_EQ(row->main_ia, expected_rem_gas); - EXPECT_EQ(row->main_mem_idx_a, 257); // Resolved direct address: 257 + EXPECT_EQ(row->main_mem_addr_a, 257); // Resolved direct address: 257 validate_trace(std::move(trace), public_inputs); } @@ -1759,7 +1759,7 @@ TEST_F(AvmExecutionTests, daGasLeft) GAS_COST_TABLE.at(OpCode::DAGASLEFT).da_fixed_gas_cost; EXPECT_EQ(row->main_ia, expected_rem_gas); - EXPECT_EQ(row->main_mem_idx_a, 39); + EXPECT_EQ(row->main_mem_addr_a, 39); validate_trace(std::move(trace), public_inputs); } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_gas.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_gas.test.cpp index 92de4348951..75ebab12270 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_gas.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_gas.test.cpp @@ -47,7 +47,7 @@ void test_gas(StartGas startGas, OpcodesFunc apply_opcodes, CheckFunc check_trac check_trace(trace); - log_avm_trace(trace, 0, 10); + // log_avm_trace(trace, 0, 10); validate_trace(std::move(trace), public_inputs); } 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 eccca07ae99..d75c53f49eb 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 @@ -58,20 +58,20 @@ TEST_F(AvmIndirectMemTests, allIndirectAdd) EXPECT_EQ(row->main_ia, FF(100)); EXPECT_EQ(row->main_ib, FF(101)); EXPECT_EQ(row->main_ic, FF(201)); - EXPECT_EQ(row->main_ind_a, FF(0)); - EXPECT_EQ(row->main_ind_b, FF(1)); - EXPECT_EQ(row->main_ind_c, FF(2)); - EXPECT_EQ(row->main_mem_idx_a, FF(10)); - EXPECT_EQ(row->main_mem_idx_b, FF(11)); - EXPECT_EQ(row->main_mem_idx_c, FF(12)); + EXPECT_EQ(row->main_ind_addr_a, FF(0)); + EXPECT_EQ(row->main_ind_addr_b, FF(1)); + EXPECT_EQ(row->main_ind_addr_c, FF(2)); + EXPECT_EQ(row->main_mem_addr_a, FF(10)); + EXPECT_EQ(row->main_mem_addr_b, FF(11)); + EXPECT_EQ(row->main_mem_addr_c, FF(12)); // Check memory operation tags - EXPECT_EQ(row->main_ind_op_a, FF(1)); - EXPECT_EQ(row->main_ind_op_b, FF(1)); - EXPECT_EQ(row->main_ind_op_c, FF(1)); - EXPECT_EQ(row->main_mem_op_a, FF(1)); - EXPECT_EQ(row->main_mem_op_b, FF(1)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_a, FF(1)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_b, FF(1)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_c, FF(1)); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); + 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); } @@ -104,20 +104,20 @@ TEST_F(AvmIndirectMemTests, indirectOutputSub) EXPECT_EQ(row->main_ia, FF(600)); EXPECT_EQ(row->main_ib, FF(500)); EXPECT_EQ(row->main_ic, FF(100)); - EXPECT_EQ(row->main_ind_a, FF(0)); - EXPECT_EQ(row->main_ind_b, FF(0)); - EXPECT_EQ(row->main_ind_c, FF(5)); - EXPECT_EQ(row->main_mem_idx_a, FF(50)); - EXPECT_EQ(row->main_mem_idx_b, FF(51)); - EXPECT_EQ(row->main_mem_idx_c, FF(52)); + EXPECT_EQ(row->main_ind_addr_a, FF(0)); + EXPECT_EQ(row->main_ind_addr_b, FF(0)); + EXPECT_EQ(row->main_ind_addr_c, FF(5)); + EXPECT_EQ(row->main_mem_addr_a, FF(50)); + EXPECT_EQ(row->main_mem_addr_b, FF(51)); + EXPECT_EQ(row->main_mem_addr_c, FF(52)); // Check memory operation tags - EXPECT_EQ(row->main_ind_op_a, FF(0)); - EXPECT_EQ(row->main_ind_op_b, FF(0)); - EXPECT_EQ(row->main_ind_op_c, FF(1)); - EXPECT_EQ(row->main_mem_op_a, FF(1)); - EXPECT_EQ(row->main_mem_op_b, FF(1)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_a, FF(0)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_b, FF(0)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_c, FF(1)); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); + 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); } @@ -150,20 +150,20 @@ TEST_F(AvmIndirectMemTests, indirectInputAMul) EXPECT_EQ(row->main_ia, FF(4)); EXPECT_EQ(row->main_ib, FF(7)); EXPECT_EQ(row->main_ic, FF(28)); - EXPECT_EQ(row->main_ind_a, FF(1000)); - EXPECT_EQ(row->main_ind_b, FF(0)); - EXPECT_EQ(row->main_ind_c, FF(0)); - EXPECT_EQ(row->main_mem_idx_a, FF(100)); - EXPECT_EQ(row->main_mem_idx_b, FF(101)); - EXPECT_EQ(row->main_mem_idx_c, FF(102)); + EXPECT_EQ(row->main_ind_addr_a, FF(1000)); + EXPECT_EQ(row->main_ind_addr_b, FF(0)); + EXPECT_EQ(row->main_ind_addr_c, FF(0)); + EXPECT_EQ(row->main_mem_addr_a, FF(100)); + EXPECT_EQ(row->main_mem_addr_b, FF(101)); + EXPECT_EQ(row->main_mem_addr_c, FF(102)); // Check memory operation tags - EXPECT_EQ(row->main_ind_op_a, FF(1)); - EXPECT_EQ(row->main_ind_op_b, FF(0)); - EXPECT_EQ(row->main_ind_op_c, FF(0)); - EXPECT_EQ(row->main_mem_op_a, FF(1)); - EXPECT_EQ(row->main_mem_op_b, FF(1)); - EXPECT_EQ(row->main_mem_op_c, FF(1)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_a, FF(1)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_b, FF(0)); + EXPECT_EQ(row->main_sel_resolve_ind_addr_c, FF(0)); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); + 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); } 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 d0522bbb391..9a4855892e5 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 @@ -49,9 +49,9 @@ class AvmInterTableTests : public ::testing::Test { class AvmPermMainAluNegativeTests : public AvmInterTableTests { protected: std::vector trace; - size_t main_idx; - size_t mem_idx; - size_t alu_idx; + size_t main_addr; + size_t mem_addr; + size_t alu_addr; void SetUp() override { @@ -79,13 +79,13 @@ class AvmPermMainAluNegativeTests : public AvmInterTableTests { // Find memory trace entry related to storing output (intermediate register Ic) in memory. auto mem_row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.mem_clk == clk && r.mem_op_c == FF(1) && r.mem_rw == FF(1); + return r.mem_clk == clk && r.mem_sel_op_c == FF(1) && r.mem_rw == FF(1); }); ASSERT_TRUE(mem_row != trace.end()); - main_idx = static_cast(row - trace.begin()); - alu_idx = static_cast(alu_row - trace.begin()); - mem_idx = static_cast(mem_row - trace.begin()); + main_addr = static_cast(row - trace.begin()); + alu_addr = static_cast(alu_row - trace.begin()); + mem_addr = static_cast(mem_row - trace.begin()); } }; @@ -93,8 +93,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_idx).main_ic = 1008; - trace.at(mem_idx).mem_val = 1008; + trace.at(main_addr).main_ic = 1008; + trace.at(mem_addr).mem_val = 1008; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -102,10 +102,10 @@ TEST_F(AvmPermMainAluNegativeTests, wrongAluOutputCopyInMain) TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) { // Mutate the input of alu_ia and adapt the output ic accordingly. - trace.at(alu_idx).alu_ia = 20; - trace.at(alu_idx).alu_ic = 1060; // 20 * 53; required to pass the alu mul relation - trace.at(alu_idx).alu_u8_r0 = 36; // 1060 % 256 = 36 - trace.at(alu_idx).alu_u8_r1 = 4; // 4 * 256 = 1024 + 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 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -113,30 +113,30 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIbInput) { // Mutate the input of alu_ia and adapt the output ic accordingly. - trace.at(alu_idx).alu_ib = 10; - trace.at(alu_idx).alu_ic = 190; // 19 * 10; required to pass the alu mul relation - trace.at(alu_idx).alu_u8_r0 = 190; - trace.at(alu_idx).alu_u8_r1 = 0; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluOpSelector) { - trace.at(alu_idx).alu_op_mul = 0; - trace.at(alu_idx).alu_op_add = 1; - trace.at(alu_idx).alu_ic = 72; // 19 + 53 - trace.at(alu_idx).alu_u8_r0 = 72; - trace.at(alu_idx).alu_u8_r1 = 0; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) { - trace.at(alu_idx).alu_alu_sel = 0; - trace.at(alu_idx).alu_op_mul = 0; - trace.at(alu_idx).alu_rng_chk_lookup_selector = 0; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } @@ -147,9 +147,9 @@ TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) class AvmRangeCheckNegativeTests : public AvmInterTableTests { protected: std::vector trace; - size_t main_idx; - size_t mem_idx; - size_t alu_idx; + size_t main_addr; + size_t mem_addr; + size_t alu_addr; void genTraceAdd( uint128_t const& a, uint128_t const& b, uint128_t const& c, AvmMemoryTag tag, uint32_t min_trace_size = 0) @@ -175,13 +175,13 @@ class AvmRangeCheckNegativeTests : public AvmInterTableTests { // Find memory trace entry related to storing output (intermediate register Ic) in memory. auto mem_row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.mem_clk == clk && r.mem_op_c == FF(1) && r.mem_rw == FF(1); + return r.mem_clk == clk && r.mem_sel_op_c == FF(1) && r.mem_rw == FF(1); }); ASSERT_TRUE(mem_row != trace.end()); - main_idx = static_cast(row - trace.begin()); - alu_idx = static_cast(alu_row - trace.begin()); - mem_idx = static_cast(mem_row - trace.begin()); + main_addr = static_cast(row - trace.begin()); + alu_addr = static_cast(alu_row - trace.begin()); + mem_addr = static_cast(mem_row - trace.begin()); }; }; @@ -196,9 +196,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_idx); - auto& mem_row = trace.at(mem_idx); - auto& alu_row = trace.at(alu_idx); + auto& row = trace.at(main_addr); + auto& mem_row = trace.at(mem_addr); + auto& alu_row = trace.at(alu_addr); row.main_ic = fake_c; mem_row.mem_val = fake_c; @@ -226,9 +226,9 @@ TEST_F(AvmRangeCheckNegativeTests, additionU8Reg0) TEST_F(AvmRangeCheckNegativeTests, additionU8Reg1) { genTraceAdd(19, 20, 39, AvmMemoryTag::U8); - auto& row = trace.at(main_idx); - auto& mem_row = trace.at(mem_idx); - auto& alu_row = trace.at(alu_idx); + auto& row = trace.at(main_addr); + auto& mem_row = trace.at(mem_addr); + auto& alu_row = trace.at(alu_addr); // a + b = u8_r0 + 2^8 * u8_r1 (mod p) // We recall that p-1 is a multiple of a large power of two. @@ -264,9 +264,9 @@ TEST_F(AvmRangeCheckNegativeTests, additionU8Reg1) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg0) { genTraceAdd(1200, 2000, 3200, AvmMemoryTag::U16, 130); - auto& row = trace.at(main_idx); - auto& mem_row = trace.at(mem_idx); - auto& alu_row = trace.at(alu_idx); + auto& row = trace.at(main_addr); + auto& mem_row = trace.at(mem_addr); + auto& alu_row = trace.at(alu_addr); // 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. @@ -311,7 +311,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg7) genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); auto trace_original = trace; - auto& alu_row = trace.at(alu_idx); + auto& alu_row = trace.at(alu_addr); alu_row.alu_u16_r7 = FF(235655); auto trace_same_cnt = trace; @@ -328,7 +328,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg7) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg8) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_idx).alu_u16_r8 = FF(235655); + trace.at(alu_addr).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"); } @@ -337,7 +337,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg8) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg9) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_idx).alu_u16_r9 = FF(235655); + trace.at(alu_addr).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"); } @@ -346,7 +346,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg9) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg10) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_idx).alu_u16_r10 = FF(235655); + trace.at(alu_addr).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"); } @@ -355,7 +355,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg10) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg11) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_idx).alu_u16_r11 = FF(235655); + trace.at(alu_addr).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"); } @@ -364,7 +364,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg11) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg12) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_idx).alu_u16_r12 = FF(235655); + trace.at(alu_addr).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"); } @@ -373,7 +373,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg12) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg13) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_idx).alu_u16_r13 = FF(235655); + trace.at(alu_addr).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"); } @@ -382,7 +382,7 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg13) TEST_F(AvmRangeCheckNegativeTests, additionU16Reg14) { genTraceAdd(4500, 45, 4545, AvmMemoryTag::U16); - trace.at(alu_idx).alu_u16_r14 = FF(235655); + trace.at(alu_addr).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"); } @@ -393,11 +393,11 @@ TEST_F(AvmRangeCheckNegativeTests, additionU16Reg14) class AvmPermMainMemNegativeTests : public AvmInterTableTests { protected: std::vector trace; - size_t main_idx; - size_t mem_idx_a; - size_t mem_idx_b; - size_t mem_idx_c; - size_t alu_idx; + size_t main_addr; + size_t mem_addr_a; + size_t mem_addr_b; + size_t mem_addr_c; + size_t alu_addr; // Helper function to generate a trace with a subtraction // for c = a - b at arbitray chosen addresses 52 (a), 11 (b), 55 (c). @@ -422,27 +422,27 @@ class AvmPermMainMemNegativeTests : public AvmInterTableTests { // Find memory trace entry related to storing output (intermediate register Ic) in memory. auto mem_row_c = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.mem_clk == clk && r.mem_op_c == FF(1) && r.mem_rw == FF(1); + return r.mem_clk == clk && r.mem_sel_op_c == FF(1) && r.mem_rw == FF(1); }); ASSERT_TRUE(mem_row_c != trace.end()); // Find memory trace entry related to loading first input (intermediate register Ia) in memory. auto mem_row_a = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.mem_clk == clk && r.mem_op_a == FF(1) && r.mem_rw == FF(0); + return r.mem_clk == clk && r.mem_sel_op_a == FF(1) && r.mem_rw == FF(0); }); ASSERT_TRUE(mem_row_a != trace.end()); // Find memory trace entry related to loading second input (intermediate register Ib) in memory. auto mem_row_b = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.mem_clk == clk && r.mem_op_b == FF(1) && r.mem_rw == FF(0); + return r.mem_clk == clk && r.mem_sel_op_b == FF(1) && r.mem_rw == FF(0); }); ASSERT_TRUE(mem_row_b != trace.end()); - main_idx = static_cast(row - trace.begin()); - alu_idx = static_cast(alu_row - trace.begin()); - mem_idx_a = static_cast(mem_row_a - trace.begin()); - mem_idx_b = static_cast(mem_row_b - trace.begin()); - mem_idx_c = static_cast(mem_row_c - trace.begin()); + 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()); } }; // Error tag propagation from memory trace back to the main trace. @@ -459,13 +459,13 @@ TEST_F(AvmPermMainMemNegativeTests, tagErrNotCopiedInMain) auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_eq == 1; }); ASSERT_EQ(row->main_tag_err, FF(1)); // Sanity check that the error tag is set. row->main_tag_err = 0; - row->main_alu_sel = 1; // We have to activate ALU trace if no error tag is present. + row->main_sel_alu = 1; // We have to activate ALU trace if no error tag is present. auto const clk = row->main_clk; // Create a valid ALU entry for this equality operation. auto& alu_row = trace.at(1); alu_row.alu_clk = clk; - alu_row.alu_alu_sel = 1; + alu_row.alu_sel_alu = 1; alu_row.alu_ia = 32; alu_row.alu_ib = 32; alu_row.alu_ic = 1; @@ -488,8 +488,8 @@ TEST_F(AvmPermMainMemNegativeTests, tagErrNotCopiedInMain) TEST_F(AvmPermMainMemNegativeTests, wrongValueIaInMem) { executeSub(21, 3); - trace.at(mem_idx_a).mem_val = 26; // Correct value: 21 - trace.at(mem_idx_a - 1).mem_val = 26; // We need to adjust the write operation beforehand (set opcode). + 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). EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -497,8 +497,8 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIaInMem) TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) { executeSub(21, 3); - trace.at(mem_idx_b).mem_val = 7; // Correct value: 3 - trace.at(mem_idx_b - 1).mem_val = 7; // We need to adjust the write operation beforehand (set opcode). + 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). EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -506,7 +506,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) { executeSub(21, 3); - trace.at(mem_idx_c).mem_val = 17; // Correct value: 18 = 21 - 3 + trace.at(mem_addr_c).mem_val = 17; // Correct value: 18 = 21 - 3 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -514,7 +514,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) { executeSub(21, 3); - trace.at(main_idx).main_mem_idx_a = 28; // Correct address: 52 + trace.at(main_addr).main_mem_addr_a = 28; // Correct address: 52 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -522,7 +522,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) { executeSub(21, 3); - trace.at(main_idx).main_mem_idx_b = 2; // Correct address: 11 + trace.at(main_addr).main_mem_addr_b = 2; // Correct address: 11 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -530,7 +530,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) TEST_F(AvmPermMainMemNegativeTests, wrongAddressIcInMain) { executeSub(21, 3); - trace.at(main_idx).main_mem_idx_c = 75; // Correct address: 55 + trace.at(main_addr).main_mem_addr_c = 75; // Correct address: 55 EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -539,13 +539,13 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIaInMem) { executeSub(21, 3); auto wrong_in_tag = static_cast(AvmMemoryTag::U32); - trace.at(mem_idx_a).mem_r_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 - trace.at(mem_idx_a).mem_tag = wrong_in_tag; + 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; // We need to adjust the write operation beforehand (set opcode). - trace.at(mem_idx_a - 1).mem_r_in_tag = wrong_in_tag; - trace.at(mem_idx_a - 1).mem_w_in_tag = wrong_in_tag; - trace.at(mem_idx_a - 1).mem_tag = wrong_in_tag; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -554,13 +554,13 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIbInMem) { executeSub(21, 3); auto wrong_in_tag = static_cast(AvmMemoryTag::U16); - trace.at(mem_idx_b).mem_r_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 - trace.at(mem_idx_b).mem_tag = wrong_in_tag; + 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; // We need to adjust the write operation beforehand (set opcode). - trace.at(mem_idx_b - 1).mem_r_in_tag = wrong_in_tag; - trace.at(mem_idx_b - 1).mem_w_in_tag = wrong_in_tag; - trace.at(mem_idx_b - 1).mem_tag = wrong_in_tag; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -569,8 +569,8 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) { executeSub(21, 3); auto wrong_in_tag = static_cast(AvmMemoryTag::U128); - trace.at(mem_idx_c).mem_w_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 - trace.at(mem_idx_c).mem_tag = wrong_in_tag; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -578,15 +578,15 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) { executeSub(21, 3); - trace.at(mem_idx_a).mem_rw = 1; // Write instead of read. + trace.at(mem_addr_a).mem_rw = 1; // Write instead of read. // Adjust timestamp value - trace.at(mem_idx_a).mem_tsp += FF(AvmMemTraceBuilder::SUB_CLK_STORE_A - AvmMemTraceBuilder::SUB_CLK_LOAD_A); + trace.at(mem_addr_a).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_idx_a - 1).mem_diff_lo + trace.at(mem_idx_a - 1).mem_diff_mid * FF(1 << 16) + + FF diff = trace.at(mem_addr_a - 1).mem_diff_lo + trace.at(mem_addr_a - 1).mem_diff_mid * FF(1 << 16) + FF(AvmMemTraceBuilder::SUB_CLK_STORE_A - AvmMemTraceBuilder::SUB_CLK_LOAD_A); - trace.at(mem_idx_a - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_idx_a - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + 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); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -594,15 +594,15 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) TEST_F(AvmPermMainMemNegativeTests, wrongRwIbInMem) { executeSub(21, 3); - trace.at(mem_idx_b).mem_rw = 1; // Write instead of read. + trace.at(mem_addr_b).mem_rw = 1; // Write instead of read. // Adjust timestamp value - trace.at(mem_idx_b).mem_tsp += FF(AvmMemTraceBuilder::SUB_CLK_STORE_B - AvmMemTraceBuilder::SUB_CLK_LOAD_B); + trace.at(mem_addr_b).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_idx_b - 1).mem_diff_lo + trace.at(mem_idx_b - 1).mem_diff_mid * FF(1 << 16) + + FF diff = trace.at(mem_addr_b - 1).mem_diff_lo + trace.at(mem_addr_b - 1).mem_diff_mid * FF(1 << 16) + FF(AvmMemTraceBuilder::SUB_CLK_STORE_B - AvmMemTraceBuilder::SUB_CLK_LOAD_B); - trace.at(mem_idx_b - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_idx_b - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + 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); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -613,10 +613,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_idx_c).mem_rw = 0; // Read instead of write. + trace.at(mem_addr_c).mem_rw = 0; // Read instead of write. // Adjust timestamp value. - trace.at(mem_idx_c).mem_tsp -= FF(AvmMemTraceBuilder::SUB_CLK_STORE_C - AvmMemTraceBuilder::SUB_CLK_LOAD_C); + trace.at(mem_addr_c).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"); } @@ -624,13 +624,13 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIcInMem) TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) { executeSub(87, 23); - trace.at(mem_idx_a).mem_clk += 3; - trace.at(mem_idx_a).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 3; + trace.at(mem_addr_a).mem_clk += 3; + trace.at(mem_addr_a).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 3; // Adjust diff value of previous row as well - FF diff = trace.at(mem_idx_a - 1).mem_diff_lo + trace.at(mem_idx_a - 1).mem_diff_mid * FF(1 << 16) + + FF diff = trace.at(mem_addr_a - 1).mem_diff_lo + trace.at(mem_addr_a - 1).mem_diff_mid * FF(1 << 16) + FF(AvmMemTraceBuilder::NUM_SUB_CLK * 3); - trace.at(mem_idx_a - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_idx_a - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + 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); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -638,12 +638,12 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) { executeSub(87, 23); - trace.at(mem_idx_b).mem_clk += 5; - trace.at(mem_idx_b).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 5; - FF diff = trace.at(mem_idx_b - 1).mem_diff_lo + trace.at(mem_idx_b - 1).mem_diff_mid * FF(1 << 16) + + 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) + FF(AvmMemTraceBuilder::NUM_SUB_CLK * 5); - trace.at(mem_idx_b - 1).mem_diff_mid = FF(uint32_t(diff) >> 16); - trace.at(mem_idx_b - 1).mem_diff_lo = FF(uint32_t(diff) & UINT16_MAX); + 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); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } @@ -651,8 +651,8 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) TEST_F(AvmPermMainMemNegativeTests, wrongClkIcInMem) { executeSub(87, 23); - trace.at(mem_idx_c).mem_clk += 7; - trace.at(mem_idx_c).mem_tsp += AvmMemTraceBuilder::NUM_SUB_CLK * 7; + trace.at(mem_addr_c).mem_clk += 7; + trace.at(mem_addr_c).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_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index c898d9d07ba..a985bb45a63 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -79,26 +79,26 @@ void test_kernel_lookup(bool indirect, /* * Helper function to assert row values for a kernel lookup opcode */ -void expect_row(auto row, FF selector, FF ia, FF ind_a, FF mem_idx_a, AvmMemoryTag w_in_tag) +void expect_row(auto row, FF selector, FF ia, FF ind_a, FF mem_addr_a, AvmMemoryTag w_in_tag) { // Checks dependent on the opcode EXPECT_EQ(row->kernel_kernel_in_offset, selector); EXPECT_EQ(row->main_ia, ia); - EXPECT_EQ(row->main_mem_idx_a, mem_idx_a); + EXPECT_EQ(row->main_mem_addr_a, mem_addr_a); // Checks that are fixed for kernel inputs EXPECT_EQ(row->main_rwa, FF(1)); - EXPECT_EQ(row->main_ind_a, ind_a); - EXPECT_EQ(row->main_ind_op_a, FF(ind_a != 0)); - EXPECT_EQ(row->main_mem_op_a, FF(1)); + EXPECT_EQ(row->main_ind_addr_a, ind_a); + EXPECT_EQ(row->main_sel_resolve_ind_addr_a, FF(ind_a != 0)); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); EXPECT_EQ(row->main_w_in_tag, static_cast(w_in_tag)); - EXPECT_EQ(row->main_q_kernel_lookup, FF(1)); + EXPECT_EQ(row->main_sel_q_kernel_lookup, FF(1)); } void expect_output_table_row(auto row, FF selector, FF ia, - FF mem_idx_a, + FF mem_addr_a, FF ind_a, AvmMemoryTag r_in_tag, uint32_t side_effect_counter, @@ -107,15 +107,15 @@ void expect_output_table_row(auto row, // Checks dependent on the opcode EXPECT_EQ(row->kernel_kernel_out_offset, selector); EXPECT_EQ(row->main_ia, ia); - EXPECT_EQ(row->main_mem_idx_a, mem_idx_a); + EXPECT_EQ(row->main_mem_addr_a, mem_addr_a); // Checks that are fixed for kernel inputs EXPECT_EQ(row->main_rwa, FF(rwa)); - EXPECT_EQ(row->main_ind_a, ind_a); - EXPECT_EQ(row->main_ind_op_a, FF(ind_a != 0)); - EXPECT_EQ(row->main_mem_op_a, FF(1)); + EXPECT_EQ(row->main_ind_addr_a, ind_a); + EXPECT_EQ(row->main_sel_resolve_ind_addr_a, FF(ind_a != 0)); + EXPECT_EQ(row->main_sel_mem_op_a, FF(1)); EXPECT_EQ(row->main_r_in_tag, static_cast(r_in_tag)); - EXPECT_EQ(row->main_q_kernel_output_lookup, FF(1)); + EXPECT_EQ(row->main_sel_q_kernel_output_lookup, FF(1)); EXPECT_EQ(row->kernel_side_effect_counter, FF(side_effect_counter)); } @@ -123,52 +123,52 @@ void expect_output_table_row(auto row, void expect_output_table_row_with_metadata(auto row, FF selector, FF ia, - FF mem_idx_a, + FF mem_addr_a, FF ind_a, FF ib, - FF mem_idx_b, + FF mem_addr_b, FF ind_b, AvmMemoryTag r_in_tag, uint32_t side_effect_counter, uint32_t rwa = 0, bool no_b = false) { - expect_output_table_row(row, selector, ia, mem_idx_a, ind_a, r_in_tag, side_effect_counter, rwa); + expect_output_table_row(row, selector, ia, mem_addr_a, ind_a, r_in_tag, side_effect_counter, rwa); EXPECT_EQ(row->main_ib, ib); - EXPECT_EQ(row->main_mem_idx_b, mem_idx_b); + EXPECT_EQ(row->main_mem_addr_b, mem_addr_b); // Checks that are fixed for kernel inputs EXPECT_EQ(row->main_rwb, FF(0)); if (!no_b) { - EXPECT_EQ(row->main_ind_b, ind_b); - EXPECT_EQ(row->main_ind_op_b, FF(ind_b != 0)); - EXPECT_EQ(row->main_mem_op_b, FF(1)); + EXPECT_EQ(row->main_ind_addr_b, ind_b); + EXPECT_EQ(row->main_sel_resolve_ind_addr_b, FF(ind_b != 0)); + EXPECT_EQ(row->main_sel_mem_op_b, FF(1)); } } void expect_output_table_row_with_exists_metadata(auto row, FF selector, FF ia, - FF mem_idx_a, + FF mem_addr_a, FF ind_a, FF ib, - FF mem_idx_b, + FF mem_addr_b, FF ind_b, AvmMemoryTag w_in_tag, uint32_t side_effect_counter) { - expect_output_table_row(row, selector, ia, mem_idx_a, ind_a, w_in_tag, side_effect_counter); + expect_output_table_row(row, selector, ia, mem_addr_a, ind_a, w_in_tag, side_effect_counter); EXPECT_EQ(row->main_ib, ib); - EXPECT_EQ(row->main_mem_idx_b, mem_idx_b); + EXPECT_EQ(row->main_mem_addr_b, mem_addr_b); // Checks that are fixed for kernel inputs EXPECT_EQ(row->main_rwb, FF(1)); - EXPECT_EQ(row->main_ind_b, ind_b); - EXPECT_EQ(row->main_ind_op_b, FF(ind_b != 0)); - EXPECT_EQ(row->main_mem_op_b, FF(1)); + EXPECT_EQ(row->main_ind_addr_b, ind_b); + EXPECT_EQ(row->main_sel_resolve_ind_addr_b, FF(ind_b != 0)); + EXPECT_EQ(row->main_sel_mem_op_b, FF(1)); } void check_kernel_outputs(const Row& row, FF value, FF side_effect_counter, FF metadata) @@ -206,7 +206,7 @@ TEST_F(AvmKernelPositiveTests, kernelSender) /*ia=*/SENDER_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -240,7 +240,7 @@ TEST_F(AvmKernelPositiveTests, kernelAddress) /*ia=*/ADDRESS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(false, direct_apply_opcodes, checks); @@ -273,7 +273,7 @@ TEST_F(AvmKernelPositiveTests, kernelStorageAddress) /*ia=*/STORAGE_ADDRESS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -307,7 +307,7 @@ TEST_F(AvmKernelPositiveTests, kernelFeePerDa) /*ia=*/FEE_PER_DA_GAS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -341,7 +341,7 @@ TEST_F(AvmKernelPositiveTests, kernelFeePerL2) /*ia=*/FEE_PER_L2_GAS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -375,7 +375,7 @@ TEST_F(AvmKernelPositiveTests, kernelTransactionFee) /*ia=*/TRANSACTION_FEE_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -409,7 +409,7 @@ TEST_F(AvmKernelPositiveTests, kernelChainId) /*ia=*/CHAIN_ID_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -443,7 +443,7 @@ TEST_F(AvmKernelPositiveTests, kernelVersion) /*ia=*/VERSION_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -477,7 +477,7 @@ TEST_F(AvmKernelPositiveTests, kernelBlockNumber) /*ia=*/BLOCK_NUMBER_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -511,7 +511,7 @@ TEST_F(AvmKernelPositiveTests, kernelCoinbase) /*ia=*/COINBASE_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a*/ dst_offset, + /*mem_addr_a*/ dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -545,7 +545,7 @@ TEST_F(AvmKernelPositiveTests, kernelTimestamp) /*ia=*/TIMESTAMP_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect ? indirect_dst_offset : 0, - /*mem_idx_a*/ dst_offset, + /*mem_addr_a*/ dst_offset, /*w_in_tag=*/AvmMemoryTag::U64); }; @@ -604,7 +604,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaSender) /*kernel_in_offset=*/SENDER_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -630,7 +630,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaAddress) /*kernel_in_offset=*/ADDRESS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -656,7 +656,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaStorageAddress) /*kernel_in_offset=*/STORAGE_ADDRESS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -682,7 +682,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaDaGas) /*kernel_in_offset=*/FEE_PER_DA_GAS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -708,7 +708,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIal2Gas) /*kernel_in_offset=*/FEE_PER_L2_GAS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -734,7 +734,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaTransactionFee) /*kernel_in_offset=*/TRANSACTION_FEE_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -760,7 +760,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaChainId) /*kernel_in_offset=*/CHAIN_ID_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -786,7 +786,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaVersion) /*kernel_in_offset=*/VERSION_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -812,7 +812,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaBlockNumber) /*kernel_in_offset=*/BLOCK_NUMBER_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -838,7 +838,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaTimestamp) /*kernel_in_offset=*/TIMESTAMP_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a*/ dst_offset, + /*mem_addr_a*/ dst_offset, /*w_in_tag=*/AvmMemoryTag::U64); }; @@ -864,7 +864,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaCoinbase) /*kernel_in_offset=*/COINBASE_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*ind_a*/ indirect, - /*mem_idx_a=*/dst_offset, + /*mem_addr_a=*/dst_offset, /*w_in_tag=*/AvmMemoryTag::FF); }; @@ -903,7 +903,7 @@ TEST_F(AvmKernelOutputPositiveTests, kernelEmitNoteHash) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/direct_offset, + /*mem_addr_a=*/direct_offset, /*ind_a*/ indirect ? indirect_offset : 0, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); @@ -945,7 +945,7 @@ TEST_F(AvmKernelOutputPositiveTests, kernelEmitNullifier) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/direct_offset, + /*mem_addr_a=*/direct_offset, /*ind_a*/ indirect ? indirect_offset : 0, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); @@ -995,10 +995,10 @@ TEST_F(AvmKernelOutputPositiveTests, kernelEmitL2ToL1Msg) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/msg_offset, + /*mem_addr_a=*/msg_offset, /*ind_a*/ indirect ? indirect_msg_offset : 0, /*ib=*/recipient, - /*mem_idx_b=*/recipient_offset, + /*mem_addr_b=*/recipient_offset, /*ind_a*/ indirect ? indirect_recipient_offset : 0, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); @@ -1040,7 +1040,7 @@ TEST_F(AvmKernelOutputPositiveTests, kernelEmitUnencryptedLog) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/direct_offset, + /*mem_addr_a=*/direct_offset, /*ind_a*/ indirect ? indirect_offset : 0, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); @@ -1079,10 +1079,10 @@ TEST_F(AvmKernelOutputPositiveTests, kernelSload) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/dest_offset, + /*mem_addr_a=*/dest_offset, /*ind_a=*/false, /*ib=*/slot, - /*mem_idx_b=*/0, + /*mem_addr_b=*/0, /*ind_b=*/false, /*r_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0, @@ -1121,10 +1121,10 @@ TEST_F(AvmKernelOutputPositiveTests, kernelSstore) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/value_offset, + /*mem_addr_a=*/value_offset, /*ind_a*/ false, /*ib=*/slot, - /*mem_idx_b=*/0, + /*mem_addr_b=*/0, /*ind_b*/ false, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0, @@ -1170,10 +1170,10 @@ TEST_F(AvmKernelOutputPositiveTests, kernelNoteHashExists) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/value_offset, + /*mem_addr_a=*/value_offset, /*ind_a*/ indirect ? FF(indirect_value_offset) : FF(0), /*ib=*/exists, - /*mem_idx_b=*/metadata_offset, + /*mem_addr_b=*/metadata_offset, /*ind_b*/ indirect ? FF(indirect_metadata_offset) : FF(0), /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); @@ -1210,10 +1210,10 @@ TEST_F(AvmKernelOutputPositiveTests, kernelNullifierExists) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/value_offset, + /*mem_addr_a=*/value_offset, /*ind_a*/ indirect, /*ib=*/exists, - /*mem_idx_b=*/metadata_offset, + /*mem_addr_b=*/metadata_offset, /*ind_b*/ indirect, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); @@ -1249,10 +1249,10 @@ TEST_F(AvmKernelOutputPositiveTests, kernelNullifierNonExists) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/value_offset, + /*mem_addr_a=*/value_offset, /*ind_a*/ indirect, /*ib=*/exists, - /*mem_idx_b=*/metadata_offset, + /*mem_addr_b=*/metadata_offset, /*ind_b*/ indirect, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); @@ -1289,10 +1289,10 @@ TEST_F(AvmKernelOutputPositiveTests, kernelL1ToL2MsgExists) row, /*kernel_in_offset=*/output_offset, /*ia=*/value, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a=*/value_offset, + /*mem_addr_a=*/value_offset, /*ind_a*/ indirect, /*ib=*/exists, - /*mem_idx_b=*/metadata_offset, + /*mem_addr_b=*/metadata_offset, /*ind_b*/ indirect, /*w_in_tag=*/AvmMemoryTag::FF, /*side_effect_counter=*/0); 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 3ebcb8cfa44..3f0538411a2 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,7 +7,10 @@ #include #include +#define MEM_ROW_FIELD_EQ(field_name, expression) Field(#field_name, &Row::mem_##field_name, expression) + namespace tests_avm { + using namespace bb; using namespace bb::avm_trace; using namespace testing; @@ -19,15 +22,15 @@ class AvmMemOpcodeTests : public ::testing::Test { protected: std::vector trace; - size_t main_idx; - size_t mem_a_idx; - size_t mem_b_idx; - size_t mem_c_idx; - size_t mem_d_idx; - size_t mem_ind_a_idx; - size_t mem_ind_b_idx; - size_t mem_ind_c_idx; - size_t mem_ind_d_idx; + 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; // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. void SetUp() override @@ -85,14 +88,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_idx = static_cast(row - trace.begin()); + mem_a_addr = 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_idx = static_cast(row - trace.begin()); + mem_ind_a_addr = static_cast(row - trace.begin()); } } @@ -102,23 +105,23 @@ 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_idx = static_cast(row - trace.begin()); + mem_c_addr = 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_idx = static_cast(row - trace.begin()); + mem_ind_c_addr = static_cast(row - trace.begin()); } } void compute_mov_indices(bool indirect) { // Find the first row enabling the MOV selector - auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_mov == FF(1); }); + 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_idx = static_cast(row - trace.begin()); + main_addr = static_cast(row - trace.begin()); auto clk = row->main_clk; @@ -129,9 +132,9 @@ class AvmMemOpcodeTests : public ::testing::Test { void compute_cmov_indices(uint8_t indirect) { // Find the first row enabling the CMOV selector - auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_cmov == FF(1); }); + 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_idx = static_cast(row - trace.begin()); + main_addr = static_cast(row - trace.begin()); auto clk = row->main_clk; compute_index_a(clk, is_operand_indirect(indirect, 0)); @@ -140,27 +143,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_idx = static_cast(row - trace.begin()); + mem_b_addr = 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_idx = static_cast(row - trace.begin()); + mem_ind_b_addr = 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_idx = static_cast(row - trace.begin()); + mem_d_addr = 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_idx = static_cast(row - trace.begin()); + mem_ind_d_addr = static_cast(row - trace.begin()); } } @@ -174,62 +177,62 @@ 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_idx); + auto const& main_row = trace.at(main_addr); if (indirect) { EXPECT_THAT( main_row, - AllOf(Field(&Row::main_mem_idx_a, dir_src_offset), Field(&Row::main_mem_idx_c, dir_dst_offset))); + AllOf(MAIN_ROW_FIELD_EQ(mem_addr_a, dir_src_offset), MAIN_ROW_FIELD_EQ(mem_addr_c, dir_dst_offset))); } EXPECT_THAT(main_row, - AllOf(Field(&Row::main_sel_mov, 1), - Field(&Row::main_sel_mov_a, 1), - Field(&Row::main_ia, val_ff), - Field(&Row::main_ib, 0), - Field(&Row::main_ic, val_ff), - Field(&Row::main_r_in_tag, static_cast(tag)), - Field(&Row::main_w_in_tag, static_cast(tag)))); + AllOf(MAIN_ROW_FIELD_EQ(sel_op_mov, 1), + MAIN_ROW_FIELD_EQ(sel_mov_ia_to_ic, 1), + MAIN_ROW_FIELD_EQ(ia, val_ff), + MAIN_ROW_FIELD_EQ(ib, 0), + MAIN_ROW_FIELD_EQ(ic, val_ff), + 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_idx); + auto const& mem_a_row = trace.at(mem_a_addr); EXPECT_THAT(mem_a_row, - AllOf(Field(&Row::mem_tag_err, 0), - Field(&Row::mem_r_in_tag, static_cast(tag)), - Field(&Row::mem_tag, static_cast(tag)), - Field(&Row::mem_sel_mov_a, 1), - Field(&Row::mem_addr, indirect ? dir_src_offset : src_offset), - Field(&Row::mem_val, val_ff), - Field(&Row::mem_rw, 0), - Field(&Row::mem_op_a, 1))); + AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), + MEM_ROW_FIELD_EQ(r_in_tag, static_cast(tag)), + MEM_ROW_FIELD_EQ(tag, static_cast(tag)), + MEM_ROW_FIELD_EQ(sel_mov_ia_to_ic, 1), + MEM_ROW_FIELD_EQ(addr, indirect ? dir_src_offset : src_offset), + MEM_ROW_FIELD_EQ(val, val_ff), + MEM_ROW_FIELD_EQ(rw, 0), + MEM_ROW_FIELD_EQ(sel_op_a, 1))); - auto const& mem_c_row = trace.at(mem_c_idx); + auto const& mem_c_row = trace.at(mem_c_addr); EXPECT_THAT(mem_c_row, - AllOf(Field(&Row::mem_tag_err, 0), - Field(&Row::mem_w_in_tag, static_cast(tag)), - Field(&Row::mem_tag, static_cast(tag)), - Field(&Row::mem_addr, indirect ? dir_dst_offset : dst_offset), - Field(&Row::mem_val, val_ff), - Field(&Row::mem_op_c, 1))); + AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), + MEM_ROW_FIELD_EQ(w_in_tag, static_cast(tag)), + MEM_ROW_FIELD_EQ(tag, static_cast(tag)), + MEM_ROW_FIELD_EQ(addr, indirect ? dir_dst_offset : dst_offset), + MEM_ROW_FIELD_EQ(val, val_ff), + MEM_ROW_FIELD_EQ(sel_op_c, 1))); if (indirect) { - auto const& mem_ind_a_row = trace.at(mem_ind_a_idx); + auto const& mem_ind_a_row = trace.at(mem_ind_a_addr); EXPECT_THAT(mem_ind_a_row, - AllOf(Field(&Row::mem_tag_err, 0), - Field(&Row::mem_r_in_tag, static_cast(AvmMemoryTag::U32)), - Field(&Row::mem_tag, static_cast(AvmMemoryTag::U32)), - Field(&Row::mem_addr, src_offset), - Field(&Row::mem_val, dir_src_offset), - Field(&Row::mem_ind_op_a, 1))); - - auto const& mem_ind_c_row = trace.at(mem_ind_c_idx); + AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), + MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U32)), + MEM_ROW_FIELD_EQ(tag, static_cast(AvmMemoryTag::U32)), + MEM_ROW_FIELD_EQ(addr, src_offset), + 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); EXPECT_THAT(mem_ind_c_row, - AllOf(Field(&Row::mem_tag_err, 0), - Field(&Row::mem_r_in_tag, static_cast(AvmMemoryTag::U32)), - Field(&Row::mem_tag, static_cast(AvmMemoryTag::U32)), - Field(&Row::mem_addr, dst_offset), - Field(&Row::mem_val, dir_dst_offset), - Field(&Row::mem_ind_op_c, 1))); + AllOf(MEM_ROW_FIELD_EQ(tag_err, 0), + MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U32)), + MEM_ROW_FIELD_EQ(tag, static_cast(AvmMemoryTag::U32)), + MEM_ROW_FIELD_EQ(addr, dst_offset), + MEM_ROW_FIELD_EQ(val, dir_dst_offset), + MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1))); } validate_trace(std::move(trace), public_inputs); @@ -252,82 +255,82 @@ 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_idx), - AllOf(Field("ia", &Row::main_ia, a), - Field("ib", &Row::main_ib, b), - Field("ic", &Row::main_ic, mov_val), - Field("id", &Row::main_id, d), - Field("op_a", &Row::main_mem_op_a, 1), - Field("op_b", &Row::main_mem_op_b, 1), - Field("op_c", &Row::main_mem_op_c, 1), - Field("op_d", &Row::main_mem_op_d, 1), - Field("rwa", &Row::main_rwa, 0), - Field("rwb", &Row::main_rwb, 0), - Field("rwc", &Row::main_rwc, 1), - Field("rwd", &Row::main_rwd, 0), - Field("mem_idx_a", &Row::main_mem_idx_a, addr_a), - Field("mem_idx_b", &Row::main_mem_idx_b, addr_b), - Field("mem_idx_c", &Row::main_mem_idx_c, addr_c), - Field("mem_idx_d", &Row::main_mem_idx_d, addr_d), - Field("ind_op_a", &Row::main_ind_op_a, static_cast(indirect)), - Field("ind_op_b", &Row::main_ind_op_b, static_cast(indirect)), - Field("ind_op_c", &Row::main_ind_op_c, static_cast(indirect)), - Field("ind_op_d", &Row::main_ind_op_d, static_cast(indirect)), - Field("sel_cmov", &Row::main_sel_cmov, 1), - Field("sel_mov_a", &Row::main_sel_mov_a, mov_a), - Field("sel_mov_b", &Row::main_sel_mov_b, !mov_a), - Field("r_in_tag", &Row::main_r_in_tag, static_cast(mov_tag)), - Field("w_in_tag", &Row::main_w_in_tag, static_cast(mov_tag)), - Field("inv", &Row::main_inv, inv))); - - EXPECT_THAT(trace.at(mem_a_idx), - AllOf(Field("r_in_tag", &Row::mem_r_in_tag, static_cast(mov_tag)), - Field("w_in_tag", &Row::mem_w_in_tag, static_cast(mov_tag)), - Field("tag", &Row::mem_tag, static_cast(tag_a)), - Field("sel_mov_a", &Row::mem_sel_mov_a, mov_a), - Field("mem_addr", &Row::mem_addr, addr_a), - Field("val", &Row::mem_val, a), - Field("rw", &Row::mem_rw, 0), - Field("skip_check_tag", &Row::mem_skip_check_tag, mov_a ? 0 : 1), - Field("op_a", &Row::mem_op_a, 1), - Field("ind_op_a", &Row::mem_ind_op_a, 0))); - - EXPECT_THAT(trace.at(mem_b_idx), - AllOf(Field("r_in_tag", &Row::mem_r_in_tag, static_cast(mov_tag)), - Field("w_in_tag", &Row::mem_w_in_tag, static_cast(mov_tag)), - Field("tag", &Row::mem_tag, static_cast(tag_b)), - Field("tag_err", &Row::mem_tag_err, 0), - Field("sel_mov_b", &Row::mem_sel_mov_b, !mov_a), - Field("mem_addr", &Row::mem_addr, addr_b), - Field("val", &Row::mem_val, b), - Field("rw", &Row::mem_rw, 0), - Field("skip_check_tag", &Row::mem_skip_check_tag, mov_a ? 1 : 0), - Field("op_b", &Row::mem_op_b, 1), - Field("ind_op_b", &Row::mem_ind_op_b, 0))); - - EXPECT_THAT(trace.at(mem_c_idx), - AllOf(Field("r_in_tag", &Row::mem_r_in_tag, static_cast(mov_tag)), - Field("w_in_tag", &Row::mem_w_in_tag, static_cast(mov_tag)), - Field("tag", &Row::mem_tag, static_cast(mov_tag)), - Field("tag_err", &Row::mem_tag_err, 0), - Field("mem_addr", &Row::mem_addr, addr_c), - Field("val", &Row::mem_val, mov_a ? a : b), - Field("rw", &Row::mem_rw, 1), - Field("skip_check_tag", &Row::mem_skip_check_tag, 0), - Field("op_c", &Row::mem_op_c, 1), - Field("ind_op_c", &Row::mem_ind_op_c, 0))); - - EXPECT_THAT(trace.at(mem_d_idx), - AllOf(Field("r_in_tag", &Row::mem_r_in_tag, static_cast(mov_tag)), - Field("w_in_tag", &Row::mem_w_in_tag, static_cast(mov_tag)), - Field("tag", &Row::mem_tag, static_cast(tag_d)), - Field("tag_err", &Row::mem_tag_err, 0), - Field("mem_addr", &Row::mem_addr, addr_d), - Field("val", &Row::mem_val, d), - Field("rw", &Row::mem_rw, 0), - Field("skip_check_tag", &Row::mem_skip_check_tag, 1), - Field("op_d", &Row::mem_op_d, 1), - Field("ind_op_d", &Row::mem_ind_op_d, 0))); + EXPECT_THAT(trace.at(main_addr), + AllOf(MAIN_ROW_FIELD_EQ(ia, a), + MAIN_ROW_FIELD_EQ(ib, b), + MAIN_ROW_FIELD_EQ(ic, mov_val), + MAIN_ROW_FIELD_EQ(id, d), + MAIN_ROW_FIELD_EQ(sel_mem_op_a, 1), + MAIN_ROW_FIELD_EQ(sel_mem_op_b, 1), + MAIN_ROW_FIELD_EQ(sel_mem_op_c, 1), + MAIN_ROW_FIELD_EQ(sel_mem_op_d, 1), + MAIN_ROW_FIELD_EQ(rwa, 0), + MAIN_ROW_FIELD_EQ(rwb, 0), + MAIN_ROW_FIELD_EQ(rwc, 1), + MAIN_ROW_FIELD_EQ(rwd, 0), + MAIN_ROW_FIELD_EQ(mem_addr_a, addr_a), + MAIN_ROW_FIELD_EQ(mem_addr_b, addr_b), + MAIN_ROW_FIELD_EQ(mem_addr_c, addr_c), + MAIN_ROW_FIELD_EQ(mem_addr_d, addr_d), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_a, static_cast(indirect)), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_b, static_cast(indirect)), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, static_cast(indirect)), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_d, static_cast(indirect)), + MAIN_ROW_FIELD_EQ(sel_op_cmov, 1), + MAIN_ROW_FIELD_EQ(sel_mov_ia_to_ic, mov_a), + MAIN_ROW_FIELD_EQ(sel_mov_ib_to_ic, !mov_a), + MAIN_ROW_FIELD_EQ(r_in_tag, static_cast(mov_tag)), + MAIN_ROW_FIELD_EQ(w_in_tag, static_cast(mov_tag)), + MAIN_ROW_FIELD_EQ(inv, inv))); + + EXPECT_THAT(trace.at(mem_a_addr), + 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)), + MEM_ROW_FIELD_EQ(sel_mov_ia_to_ic, mov_a), + MEM_ROW_FIELD_EQ(addr, addr_a), + MEM_ROW_FIELD_EQ(val, a), + MEM_ROW_FIELD_EQ(rw, 0), + MEM_ROW_FIELD_EQ(skip_check_tag, mov_a ? 0 : 1), + 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), + 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)), + MEM_ROW_FIELD_EQ(tag_err, 0), + MEM_ROW_FIELD_EQ(sel_mov_ib_to_ic, !mov_a), + MEM_ROW_FIELD_EQ(addr, addr_b), + MEM_ROW_FIELD_EQ(val, b), + MEM_ROW_FIELD_EQ(rw, 0), + MEM_ROW_FIELD_EQ(skip_check_tag, mov_a ? 1 : 0), + 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), + 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)), + MEM_ROW_FIELD_EQ(tag_err, 0), + MEM_ROW_FIELD_EQ(addr, addr_c), + MEM_ROW_FIELD_EQ(val, mov_a ? a : b), + MEM_ROW_FIELD_EQ(rw, 1), + MEM_ROW_FIELD_EQ(skip_check_tag, 0), + 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), + 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)), + MEM_ROW_FIELD_EQ(tag_err, 0), + MEM_ROW_FIELD_EQ(addr, addr_d), + MEM_ROW_FIELD_EQ(val, d), + MEM_ROW_FIELD_EQ(rw, 0), + MEM_ROW_FIELD_EQ(skip_check_tag, 1), + MEM_ROW_FIELD_EQ(sel_op_d, 1), + MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_d, 0))); } }; @@ -393,12 +396,12 @@ TEST_F(AvmMemOpcodeTests, indirectMovInvalidAddressTag) compute_mov_indices(true); - EXPECT_EQ(trace.at(main_idx).main_tag_err, 1); - EXPECT_THAT(trace.at(mem_ind_c_idx), - AllOf(Field(&Row::mem_tag_err, 1), - Field(&Row::mem_tag, static_cast(AvmMemoryTag::U128)), - Field(&Row::mem_r_in_tag, static_cast(AvmMemoryTag::U32)), - Field(&Row::mem_ind_op_c, 1))); + EXPECT_EQ(trace.at(main_addr).main_tag_err, 1); + EXPECT_THAT(trace.at(mem_ind_c_addr), + 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); } @@ -526,19 +529,19 @@ TEST_F(AvmMemOpcodeTests, directSet) auto const& row = trace.at(1); EXPECT_THAT(row, - AllOf(Field(&Row::main_tag_err, 0), - Field(&Row::main_ic, 5683), - Field(&Row::main_mem_idx_c, 99), - Field(&Row::main_mem_op_c, 1), - Field(&Row::main_rwc, 1), - Field(&Row::main_ind_op_c, 0))); - - EXPECT_THAT(trace.at(mem_c_idx), - AllOf(Field(&Row::mem_val, 5683), - Field(&Row::mem_addr, 99), - Field(&Row::mem_op_c, 1), - Field(&Row::mem_rw, 1), - Field(&Row::mem_ind_op_c, 0))); + AllOf(MAIN_ROW_FIELD_EQ(tag_err, 0), + MAIN_ROW_FIELD_EQ(ic, 5683), + MAIN_ROW_FIELD_EQ(mem_addr_c, 99), + MAIN_ROW_FIELD_EQ(sel_mem_op_c, 1), + MAIN_ROW_FIELD_EQ(rwc, 1), + MAIN_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 0))); + + EXPECT_THAT(trace.at(mem_c_addr), + AllOf(MEM_ROW_FIELD_EQ(val, 5683), + MEM_ROW_FIELD_EQ(addr, 99), + MEM_ROW_FIELD_EQ(sel_op_c, 1), + MEM_ROW_FIELD_EQ(rw, 1), + MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 0))); validate_trace(std::move(trace), public_inputs); } @@ -554,31 +557,31 @@ TEST_F(AvmMemOpcodeTests, indirectSet) auto const& row = trace.at(2); EXPECT_THAT(row, - AllOf(Field(&Row::main_tag_err, 0), - Field(&Row::main_ic, 1979), - Field(&Row::main_mem_idx_c, 100), - Field(&Row::main_mem_op_c, 1), - Field(&Row::main_rwc, 1), - Field(&Row::main_ind_op_c, 1), - Field(&Row::main_ind_c, 10))); - - EXPECT_THAT(trace.at(mem_c_idx), - AllOf(Field(&Row::mem_val, 1979), - Field(&Row::mem_addr, 100), - Field(&Row::mem_op_c, 1), - Field(&Row::mem_rw, 1), - Field(&Row::mem_ind_op_c, 0), - Field(&Row::mem_w_in_tag, static_cast(AvmMemoryTag::U64)), - Field(&Row::mem_tag, static_cast(AvmMemoryTag::U64)))); - - EXPECT_THAT(trace.at(mem_ind_c_idx), - AllOf(Field(&Row::mem_val, 100), - Field(&Row::mem_addr, 10), - Field(&Row::mem_op_c, 0), - Field(&Row::mem_rw, 0), - Field(&Row::mem_ind_op_c, 1), - Field(&Row::mem_r_in_tag, static_cast(AvmMemoryTag::U32)), - Field(&Row::mem_tag, static_cast(AvmMemoryTag::U32)))); + AllOf(MAIN_ROW_FIELD_EQ(tag_err, 0), + MAIN_ROW_FIELD_EQ(ic, 1979), + MAIN_ROW_FIELD_EQ(mem_addr_c, 100), + MAIN_ROW_FIELD_EQ(sel_mem_op_c, 1), + MAIN_ROW_FIELD_EQ(rwc, 1), + 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), + AllOf(MEM_ROW_FIELD_EQ(val, 1979), + MEM_ROW_FIELD_EQ(addr, 100), + MEM_ROW_FIELD_EQ(sel_op_c, 1), + MEM_ROW_FIELD_EQ(rw, 1), + MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 0), + 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), + AllOf(MEM_ROW_FIELD_EQ(val, 100), + MEM_ROW_FIELD_EQ(addr, 10), + MEM_ROW_FIELD_EQ(sel_op_c, 0), + MEM_ROW_FIELD_EQ(rw, 0), + MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1), + MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U32)), + MEM_ROW_FIELD_EQ(tag, static_cast(AvmMemoryTag::U32)))); validate_trace(std::move(trace), public_inputs); } @@ -594,21 +597,21 @@ TEST_F(AvmMemOpcodeTests, indirectSetWrongTag) auto const& row = trace.at(2); EXPECT_THAT(row, - AllOf(Field(&Row::main_tag_err, 1), - Field(&Row::main_mem_op_c, 1), - Field(&Row::main_rwc, 1), - Field(&Row::main_ind_op_c, 1), - Field(&Row::main_ind_c, 10))); - - EXPECT_THAT(trace.at(mem_ind_c_idx), - AllOf(Field(&Row::mem_val, 100), - Field(&Row::mem_addr, 10), - Field(&Row::mem_op_c, 0), - Field(&Row::mem_rw, 0), - Field(&Row::mem_ind_op_c, 1), - Field(&Row::mem_r_in_tag, static_cast(AvmMemoryTag::U32)), - Field(&Row::mem_tag, static_cast(AvmMemoryTag::U8)), - Field(&Row::mem_tag_err, 1))); + AllOf(MAIN_ROW_FIELD_EQ(tag_err, 1), + MAIN_ROW_FIELD_EQ(sel_mem_op_c, 1), + MAIN_ROW_FIELD_EQ(rwc, 1), + 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), + AllOf(MEM_ROW_FIELD_EQ(val, 100), + MEM_ROW_FIELD_EQ(addr, 10), + MEM_ROW_FIELD_EQ(sel_op_c, 0), + MEM_ROW_FIELD_EQ(rw, 0), + MEM_ROW_FIELD_EQ(sel_resolve_ind_addr_c, 1), + MEM_ROW_FIELD_EQ(r_in_tag, static_cast(AvmMemoryTag::U32)), + MEM_ROW_FIELD_EQ(tag, static_cast(AvmMemoryTag::U8)), + MEM_ROW_FIELD_EQ(tag_err, 1))); validate_trace(std::move(trace), public_inputs); } @@ -627,7 +630,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputErrorTag) { build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(main_idx).main_tag_err = 1; + trace.at(main_addr).main_tag_err = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INCL_MEM_TAG_ERR"); } @@ -636,7 +639,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) { build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(main_idx).main_ic = 233; + trace.at(main_addr).main_ic = 233; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); } @@ -645,7 +648,7 @@ TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) { build_mov_trace(true, 8732, 23, 24, AvmMemoryTag::U16, 432, 876); compute_mov_indices(true); - trace.at(main_idx).main_ic = 8733; + trace.at(main_addr).main_ic = 8733; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); } @@ -665,14 +668,14 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagLoadIa) auto trace_tmp = trace; - trace.at(mem_a_idx).mem_r_in_tag = tag_u64; - trace.at(mem_a_idx).mem_tag_err = 1; - trace.at(mem_a_idx).mem_one_min_inv = one_min_inverse_diff; - trace.at(mem_c_idx).mem_tag = tag_u64; - trace.at(mem_c_idx).mem_w_in_tag = tag_u64; - trace.at(main_idx).main_r_in_tag = tag_u64; - trace.at(main_idx).main_w_in_tag = tag_u64; - trace.at(main_idx).main_tag_err = 1; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_TAG"); } @@ -688,17 +691,17 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagDisabledSelector) build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(mem_a_idx).mem_r_in_tag = tag_u64; - trace.at(mem_a_idx).mem_w_in_tag = tag_u64; - trace.at(mem_a_idx).mem_tag_err = 1; - trace.at(mem_a_idx).mem_one_min_inv = one_min_inverse_diff; - trace.at(mem_a_idx).mem_sel_mov_a = 0; - trace.at(mem_c_idx).mem_tag = tag_u64; - trace.at(mem_c_idx).mem_r_in_tag = tag_u64; - trace.at(mem_c_idx).mem_w_in_tag = tag_u64; - trace.at(main_idx).main_r_in_tag = tag_u64; - trace.at(main_idx).main_w_in_tag = tag_u64; - trace.at(main_idx).main_tag_err = 1; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -712,10 +715,10 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagInMainTrace) build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(mem_c_idx).mem_tag = tag_u64; - trace.at(mem_c_idx).mem_w_in_tag = tag_u64; - trace.at(main_idx).main_w_in_tag = tag_u64; - trace.at(main_idx).main_tag_err = 1; + 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; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_MAIN_SAME_TAG"); } @@ -728,8 +731,8 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagMainTraceRead) build_mov_trace(false, 234, 0, 1, AvmMemoryTag::U8); compute_mov_indices(false); - trace.at(mem_c_idx).mem_tag = tag_u64; - trace.at(mem_c_idx).mem_w_in_tag = tag_u64; + trace.at(mem_c_addr).mem_tag = tag_u64; + trace.at(mem_c_addr).mem_w_in_tag = tag_u64; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } @@ -741,7 +744,7 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovBInsteadA) { build_cmov_trace_neg_test(true); - trace.at(main_idx).main_ic = 1980; + trace.at(main_addr).main_ic = 1980; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); } @@ -749,7 +752,7 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovAInsteadB) { build_cmov_trace_neg_test(false); - trace.at(main_idx).main_ic = 1979; + trace.at(main_addr).main_ic = 1979; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_B"); } @@ -757,9 +760,9 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovAChangeTag) { build_cmov_trace_neg_test(true); - trace.at(mem_c_idx).mem_tag = static_cast(AvmMemoryTag::U32); - trace.at(mem_c_idx).mem_w_in_tag = static_cast(AvmMemoryTag::U32); - trace.at(main_idx).main_w_in_tag = static_cast(AvmMemoryTag::U32); + 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); EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_MAIN_SAME_TAG"); } @@ -768,7 +771,7 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovASkipCheckAbuse) { build_cmov_trace_neg_test(true); - trace.at(mem_a_idx).mem_skip_check_tag = 1; + trace.at(mem_a_addr).mem_skip_check_tag = 1; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SKIP_CHECK_TAG"); } @@ -777,8 +780,8 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovASkipCheckAbuseDisableSelMovA) { build_cmov_trace_neg_test(true); - trace.at(mem_a_idx).mem_skip_check_tag = 1; - trace.at(mem_a_idx).mem_sel_mov_a = 0; + trace.at(mem_a_addr).mem_skip_check_tag = 1; + trace.at(mem_a_addr).mem_sel_mov_ia_to_ic = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } @@ -787,8 +790,8 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovBSkipCheckAbuseDisableSelMovB) { build_cmov_trace_neg_test(false); - trace.at(mem_b_idx).mem_skip_check_tag = 1; - trace.at(mem_b_idx).mem_sel_mov_b = 0; + trace.at(mem_b_addr).mem_skip_check_tag = 1; + trace.at(mem_b_addr).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/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index ff475e14ea6..8d31f30ce9a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -87,7 +87,7 @@ void mutate_ic_in_trace(std::vector& trace, std::function&& sele // Adapt the memory trace to be consistent with the wrong result auto const clk = row->main_clk; - auto const addr = row->main_mem_idx_c; + auto const addr = row->main_mem_addr_c; // Find the relevant memory trace entry. auto mem_row = std::ranges::find_if( diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index cd7c010b94b..c3c665f3490 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -2,6 +2,7 @@ #include "barretenberg/vm/avm_trace/avm_common.hpp" #include "barretenberg/vm/avm_trace/avm_trace.hpp" +#include "gmock/gmock.h" #include #define EXPECT_THROW_WITH_MESSAGE(code, expectedMessage) \ @@ -10,8 +11,11 @@ FAIL() << "An exception was expected"; \ } catch (const std::exception& e) { \ std::string message = e.what(); \ - EXPECT_TRUE(message.find(expectedMessage) != std::string::npos); \ + EXPECT_THAT(message, ::testing::HasSubstr(expectedMessage)); \ } + +#define MAIN_ROW_FIELD_EQ(field_name, expression) Field(#field_name, &Row::main_##field_name, expression) + namespace tests_avm { using Flavor = bb::AvmFlavor;