From 2bb09e59f648e6182f1097d283451afd3c488d27 Mon Sep 17 00:00:00 2001 From: Ilyas Ridhuan Date: Fri, 25 Oct 2024 15:13:41 +0100 Subject: [PATCH] feat: bytecode hashing init (#8535) This adds proper computation of the public bytecode commitment (i.e. pair-wise poseidon hashing of the public bytecode). This hash is also computed in the witgen although the circuit remains unconstrained. Follow up PRs will handle: 1) Deriving class id, including tracing and hinting the artifact hash, etc 2) Deriving the address, including tracing and hinting the contract instance 3) Merkle path hinting and verification in the AVM --- barretenberg/cpp/pil/avm/bytecode.pil | 13 + barretenberg/cpp/pil/avm/constants_gen.pil | 1 + barretenberg/cpp/pil/avm/main.pil | 1 + .../execution_trace/execution_trace.cpp | 2 +- .../vm/avm/generated/circuit_builder.cpp | 4 + .../barretenberg/vm/avm/generated/flavor.cpp | 1404 +++++++++-------- .../barretenberg/vm/avm/generated/flavor.hpp | 6 +- .../vm/avm/generated/full_row.cpp | 8 + .../vm/avm/generated/full_row.hpp | 6 +- .../vm/avm/tests/execution.test.cpp | 88 +- .../vm/avm/trace/bytecode_trace.cpp | 66 + .../vm/avm/trace/bytecode_trace.hpp | 46 + .../barretenberg/vm/avm/trace/execution.cpp | 64 +- .../barretenberg/vm/avm/trace/execution.hpp | 26 +- .../vm/avm/trace/execution_hints.hpp | 2 + .../src/barretenberg/vm/avm/trace/trace.cpp | 28 +- .../src/barretenberg/vm/avm/trace/trace.hpp | 5 +- .../src/barretenberg/vm/aztec_constants.hpp | 3 +- .../contract-deployment/classes.md | 4 +- .../src/core/libraries/ConstantsGen.sol | 2 +- .../src/main.nr | 27 +- .../crates/types/src/constants.nr | 4 +- yarn-project/circuits.js/src/constants.gen.ts | 4 +- .../src/contract/contract_class_id.test.ts | 2 +- .../src/contract/contract_class_id.ts | 24 +- .../contract_class_registered_event.test.ts | 3 +- .../circuits.js/src/scripts/constants.in.ts | 2 + .../circuits.js/src/structs/avm/avm.ts | 20 +- .../circuits.js/src/tests/factories.ts | 1 + .../__snapshots__/noir_test_gen.test.ts.snap | 16 +- .../src/protocol_contract_data.ts | 14 +- .../public/enqueued_call_side_effect_trace.ts | 3 +- .../simulator/src/public/side_effect_trace.ts | 1 + 33 files changed, 1068 insertions(+), 832 deletions(-) create mode 100644 barretenberg/cpp/pil/avm/bytecode.pil create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.cpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.hpp diff --git a/barretenberg/cpp/pil/avm/bytecode.pil b/barretenberg/cpp/pil/avm/bytecode.pil new file mode 100644 index 00000000000..9a8444187a9 --- /dev/null +++ b/barretenberg/cpp/pil/avm/bytecode.pil @@ -0,0 +1,13 @@ +namespace bytecode(256); + + pol commit packed; + pol commit length_remaining; + pol commit running_hash; + + pol commit end_latch; + + // TODO: Come back to this; + // pol commit class_id; + // pol commit contract_address; + + diff --git a/barretenberg/cpp/pil/avm/constants_gen.pil b/barretenberg/cpp/pil/avm/constants_gen.pil index 482f52edd44..e45393a8059 100644 --- a/barretenberg/cpp/pil/avm/constants_gen.pil +++ b/barretenberg/cpp/pil/avm/constants_gen.pil @@ -11,6 +11,7 @@ namespace constants(256); pol MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL = 16; pol MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL = 16; pol MAX_UNENCRYPTED_LOGS_PER_CALL = 4; + pol MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 3000; pol MEM_TAG_FF = 0; pol MEM_TAG_U1 = 1; pol MEM_TAG_U8 = 2; diff --git a/barretenberg/cpp/pil/avm/main.pil b/barretenberg/cpp/pil/avm/main.pil index 188f8dacca2..753cd19c4f5 100644 --- a/barretenberg/cpp/pil/avm/main.pil +++ b/barretenberg/cpp/pil/avm/main.pil @@ -5,6 +5,7 @@ include "constants_gen.pil"; include "constants_misc.pil"; include "gas.pil"; include "kernel.pil"; +include "bytecode.pil"; include "fixed/powers.pil"; include "gadgets/conversion.pil"; include "gadgets/sha256.pil"; diff --git a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp index 684f6269830..93945d1907e 100644 --- a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp @@ -174,4 +174,4 @@ template class ExecutionTrace_; template class ExecutionTrace_; template class ExecutionTrace_; -} // namespace bb \ No newline at end of file +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/generated/circuit_builder.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/generated/circuit_builder.cpp index 99e3cad57ac..928732dc976 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/generated/circuit_builder.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/generated/circuit_builder.cpp @@ -136,6 +136,10 @@ AvmCircuitBuilder::ProverPolynomials AvmCircuitBuilder::compute_polynomials() co polys.binary_op_id.set_if_valid_index(i, rows[i].binary_op_id); polys.binary_sel_bin.set_if_valid_index(i, rows[i].binary_sel_bin); polys.binary_start.set_if_valid_index(i, rows[i].binary_start); + polys.bytecode_end_latch.set_if_valid_index(i, rows[i].bytecode_end_latch); + polys.bytecode_length_remaining.set_if_valid_index(i, rows[i].bytecode_length_remaining); + polys.bytecode_packed.set_if_valid_index(i, rows[i].bytecode_packed); + polys.bytecode_running_hash.set_if_valid_index(i, rows[i].bytecode_running_hash); polys.cmp_a_hi.set_if_valid_index(i, rows[i].cmp_a_hi); polys.cmp_a_lo.set_if_valid_index(i, rows[i].cmp_a_lo); polys.cmp_b_hi.set_if_valid_index(i, rows[i].cmp_b_hi); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.cpp index 3d033a31f1a..4541fca3ea8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.cpp @@ -93,702 +93,706 @@ AvmFlavor::AllConstRefValues::AllConstRefValues( , binary_op_id(il[85]) , binary_sel_bin(il[86]) , binary_start(il[87]) - , cmp_a_hi(il[88]) - , cmp_a_lo(il[89]) - , cmp_b_hi(il[90]) - , cmp_b_lo(il[91]) - , cmp_borrow(il[92]) - , cmp_clk(il[93]) - , cmp_cmp_rng_ctr(il[94]) - , cmp_input_a(il[95]) - , cmp_input_b(il[96]) - , cmp_op_eq(il[97]) - , cmp_op_eq_diff_inv(il[98]) - , cmp_op_gt(il[99]) - , cmp_p_a_borrow(il[100]) - , cmp_p_b_borrow(il[101]) - , cmp_p_sub_a_hi(il[102]) - , cmp_p_sub_a_lo(il[103]) - , cmp_p_sub_b_hi(il[104]) - , cmp_p_sub_b_lo(il[105]) - , cmp_range_chk_clk(il[106]) - , cmp_res_hi(il[107]) - , cmp_res_lo(il[108]) - , cmp_result(il[109]) - , cmp_sel_cmp(il[110]) - , cmp_sel_rng_chk(il[111]) - , cmp_shift_sel(il[112]) - , conversion_clk(il[113]) - , conversion_input(il[114]) - , conversion_num_limbs(il[115]) - , conversion_output_bits(il[116]) - , conversion_radix(il[117]) - , conversion_sel_to_radix_le(il[118]) - , keccakf1600_clk(il[119]) - , keccakf1600_input(il[120]) - , keccakf1600_output(il[121]) - , keccakf1600_sel_keccakf1600(il[122]) - , main_abs_da_rem_gas(il[123]) - , main_abs_l2_rem_gas(il[124]) - , main_alu_in_tag(il[125]) - , main_base_da_gas_op_cost(il[126]) - , main_base_l2_gas_op_cost(il[127]) - , main_bin_op_id(il[128]) - , main_call_ptr(il[129]) - , main_da_gas_remaining(il[130]) - , main_da_out_of_gas(il[131]) - , main_dyn_da_gas_op_cost(il[132]) - , main_dyn_gas_multiplier(il[133]) - , main_dyn_l2_gas_op_cost(il[134]) - , main_emit_l2_to_l1_msg_write_offset(il[135]) - , main_emit_note_hash_write_offset(il[136]) - , main_emit_nullifier_write_offset(il[137]) - , main_emit_unencrypted_log_write_offset(il[138]) - , main_ia(il[139]) - , main_ib(il[140]) - , main_ic(il[141]) - , main_id(il[142]) - , main_id_zero(il[143]) - , main_ind_addr_a(il[144]) - , main_ind_addr_b(il[145]) - , main_ind_addr_c(il[146]) - , main_ind_addr_d(il[147]) - , main_internal_return_ptr(il[148]) - , main_inv(il[149]) - , main_is_fake_row(il[150]) - , main_is_gas_accounted(il[151]) - , main_kernel_in_offset(il[152]) - , main_kernel_out_offset(il[153]) - , main_l1_to_l2_msg_exists_write_offset(il[154]) - , main_l2_gas_remaining(il[155]) - , main_l2_out_of_gas(il[156]) - , main_mem_addr_a(il[157]) - , main_mem_addr_b(il[158]) - , main_mem_addr_c(il[159]) - , main_mem_addr_d(il[160]) - , main_note_hash_exist_write_offset(il[161]) - , main_nullifier_exists_write_offset(il[162]) - , main_nullifier_non_exists_write_offset(il[163]) - , main_op_err(il[164]) - , main_opcode_val(il[165]) - , main_pc(il[166]) - , main_r_in_tag(il[167]) - , main_rwa(il[168]) - , main_rwb(il[169]) - , main_rwc(il[170]) - , main_rwd(il[171]) - , main_sel_alu(il[172]) - , main_sel_bin(il[173]) - , main_sel_calldata(il[174]) - , main_sel_execution_end(il[175]) - , main_sel_execution_row(il[176]) - , main_sel_kernel_inputs(il[177]) - , main_sel_kernel_out(il[178]) - , main_sel_mem_op_a(il[179]) - , main_sel_mem_op_b(il[180]) - , main_sel_mem_op_c(il[181]) - , main_sel_mem_op_d(il[182]) - , main_sel_mov_ia_to_ic(il[183]) - , main_sel_mov_ib_to_ic(il[184]) - , main_sel_op_add(il[185]) - , main_sel_op_address(il[186]) - , main_sel_op_and(il[187]) - , main_sel_op_block_number(il[188]) - , main_sel_op_calldata_copy(il[189]) - , main_sel_op_cast(il[190]) - , main_sel_op_chain_id(il[191]) - , main_sel_op_dagasleft(il[192]) - , main_sel_op_div(il[193]) - , main_sel_op_ecadd(il[194]) - , main_sel_op_emit_l2_to_l1_msg(il[195]) - , main_sel_op_emit_note_hash(il[196]) - , main_sel_op_emit_nullifier(il[197]) - , main_sel_op_emit_unencrypted_log(il[198]) - , main_sel_op_eq(il[199]) - , main_sel_op_external_call(il[200]) - , main_sel_op_external_return(il[201]) - , main_sel_op_external_revert(il[202]) - , main_sel_op_fdiv(il[203]) - , main_sel_op_fee_per_da_gas(il[204]) - , main_sel_op_fee_per_l2_gas(il[205]) - , main_sel_op_function_selector(il[206]) - , main_sel_op_get_contract_instance(il[207]) - , main_sel_op_internal_call(il[208]) - , main_sel_op_internal_return(il[209]) - , main_sel_op_is_static_call(il[210]) - , main_sel_op_jump(il[211]) - , main_sel_op_jumpi(il[212]) - , main_sel_op_keccak(il[213]) - , main_sel_op_l1_to_l2_msg_exists(il[214]) - , main_sel_op_l2gasleft(il[215]) - , main_sel_op_lt(il[216]) - , main_sel_op_lte(il[217]) - , main_sel_op_mov(il[218]) - , main_sel_op_msm(il[219]) - , main_sel_op_mul(il[220]) - , main_sel_op_not(il[221]) - , main_sel_op_note_hash_exists(il[222]) - , main_sel_op_nullifier_exists(il[223]) - , main_sel_op_or(il[224]) - , main_sel_op_poseidon2(il[225]) - , main_sel_op_radix_le(il[226]) - , main_sel_op_sender(il[227]) - , main_sel_op_set(il[228]) - , main_sel_op_sha256(il[229]) - , main_sel_op_shl(il[230]) - , main_sel_op_shr(il[231]) - , main_sel_op_sload(il[232]) - , main_sel_op_sstore(il[233]) - , main_sel_op_static_call(il[234]) - , main_sel_op_sub(il[235]) - , main_sel_op_timestamp(il[236]) - , main_sel_op_transaction_fee(il[237]) - , main_sel_op_version(il[238]) - , main_sel_op_xor(il[239]) - , main_sel_q_kernel_lookup(il[240]) - , main_sel_q_kernel_output_lookup(il[241]) - , main_sel_resolve_ind_addr_a(il[242]) - , main_sel_resolve_ind_addr_b(il[243]) - , main_sel_resolve_ind_addr_c(il[244]) - , main_sel_resolve_ind_addr_d(il[245]) - , main_sel_returndata(il[246]) - , main_sel_rng_16(il[247]) - , main_sel_rng_8(il[248]) - , main_sel_slice_gadget(il[249]) - , main_side_effect_counter(il[250]) - , main_sload_write_offset(il[251]) - , main_space_id(il[252]) - , main_sstore_write_offset(il[253]) - , main_tag_err(il[254]) - , main_w_in_tag(il[255]) - , mem_addr(il[256]) - , mem_clk(il[257]) - , mem_diff(il[258]) - , mem_glob_addr(il[259]) - , mem_last(il[260]) - , mem_lastAccess(il[261]) - , mem_one_min_inv(il[262]) - , mem_r_in_tag(il[263]) - , mem_rw(il[264]) - , mem_sel_mem(il[265]) - , mem_sel_mov_ia_to_ic(il[266]) - , mem_sel_mov_ib_to_ic(il[267]) - , mem_sel_op_a(il[268]) - , mem_sel_op_b(il[269]) - , mem_sel_op_c(il[270]) - , mem_sel_op_d(il[271]) - , mem_sel_op_poseidon_read_a(il[272]) - , mem_sel_op_poseidon_read_b(il[273]) - , mem_sel_op_poseidon_read_c(il[274]) - , mem_sel_op_poseidon_read_d(il[275]) - , mem_sel_op_poseidon_write_a(il[276]) - , mem_sel_op_poseidon_write_b(il[277]) - , mem_sel_op_poseidon_write_c(il[278]) - , mem_sel_op_poseidon_write_d(il[279]) - , mem_sel_op_slice(il[280]) - , mem_sel_resolve_ind_addr_a(il[281]) - , mem_sel_resolve_ind_addr_b(il[282]) - , mem_sel_resolve_ind_addr_c(il[283]) - , mem_sel_resolve_ind_addr_d(il[284]) - , mem_sel_rng_chk(il[285]) - , mem_skip_check_tag(il[286]) - , mem_space_id(il[287]) - , mem_tag(il[288]) - , mem_tag_err(il[289]) - , mem_tsp(il[290]) - , mem_val(il[291]) - , mem_w_in_tag(il[292]) - , poseidon2_B_10_0(il[293]) - , poseidon2_B_10_1(il[294]) - , poseidon2_B_10_2(il[295]) - , poseidon2_B_10_3(il[296]) - , poseidon2_B_11_0(il[297]) - , poseidon2_B_11_1(il[298]) - , poseidon2_B_11_2(il[299]) - , poseidon2_B_11_3(il[300]) - , poseidon2_B_12_0(il[301]) - , poseidon2_B_12_1(il[302]) - , poseidon2_B_12_2(il[303]) - , poseidon2_B_12_3(il[304]) - , poseidon2_B_13_0(il[305]) - , poseidon2_B_13_1(il[306]) - , poseidon2_B_13_2(il[307]) - , poseidon2_B_13_3(il[308]) - , poseidon2_B_14_0(il[309]) - , poseidon2_B_14_1(il[310]) - , poseidon2_B_14_2(il[311]) - , poseidon2_B_14_3(il[312]) - , poseidon2_B_15_0(il[313]) - , poseidon2_B_15_1(il[314]) - , poseidon2_B_15_2(il[315]) - , poseidon2_B_15_3(il[316]) - , poseidon2_B_16_0(il[317]) - , poseidon2_B_16_1(il[318]) - , poseidon2_B_16_2(il[319]) - , poseidon2_B_16_3(il[320]) - , poseidon2_B_17_0(il[321]) - , poseidon2_B_17_1(il[322]) - , poseidon2_B_17_2(il[323]) - , poseidon2_B_17_3(il[324]) - , poseidon2_B_18_0(il[325]) - , poseidon2_B_18_1(il[326]) - , poseidon2_B_18_2(il[327]) - , poseidon2_B_18_3(il[328]) - , poseidon2_B_19_0(il[329]) - , poseidon2_B_19_1(il[330]) - , poseidon2_B_19_2(il[331]) - , poseidon2_B_19_3(il[332]) - , poseidon2_B_20_0(il[333]) - , poseidon2_B_20_1(il[334]) - , poseidon2_B_20_2(il[335]) - , poseidon2_B_20_3(il[336]) - , poseidon2_B_21_0(il[337]) - , poseidon2_B_21_1(il[338]) - , poseidon2_B_21_2(il[339]) - , poseidon2_B_21_3(il[340]) - , poseidon2_B_22_0(il[341]) - , poseidon2_B_22_1(il[342]) - , poseidon2_B_22_2(il[343]) - , poseidon2_B_22_3(il[344]) - , poseidon2_B_23_0(il[345]) - , poseidon2_B_23_1(il[346]) - , poseidon2_B_23_2(il[347]) - , poseidon2_B_23_3(il[348]) - , poseidon2_B_24_0(il[349]) - , poseidon2_B_24_1(il[350]) - , poseidon2_B_24_2(il[351]) - , poseidon2_B_24_3(il[352]) - , poseidon2_B_25_0(il[353]) - , poseidon2_B_25_1(il[354]) - , poseidon2_B_25_2(il[355]) - , poseidon2_B_25_3(il[356]) - , poseidon2_B_26_0(il[357]) - , poseidon2_B_26_1(il[358]) - , poseidon2_B_26_2(il[359]) - , poseidon2_B_26_3(il[360]) - , poseidon2_B_27_0(il[361]) - , poseidon2_B_27_1(il[362]) - , poseidon2_B_27_2(il[363]) - , poseidon2_B_27_3(il[364]) - , poseidon2_B_28_0(il[365]) - , poseidon2_B_28_1(il[366]) - , poseidon2_B_28_2(il[367]) - , poseidon2_B_28_3(il[368]) - , poseidon2_B_29_0(il[369]) - , poseidon2_B_29_1(il[370]) - , poseidon2_B_29_2(il[371]) - , poseidon2_B_29_3(il[372]) - , poseidon2_B_30_0(il[373]) - , poseidon2_B_30_1(il[374]) - , poseidon2_B_30_2(il[375]) - , poseidon2_B_30_3(il[376]) - , poseidon2_B_31_0(il[377]) - , poseidon2_B_31_1(il[378]) - , poseidon2_B_31_2(il[379]) - , poseidon2_B_31_3(il[380]) - , poseidon2_B_32_0(il[381]) - , poseidon2_B_32_1(il[382]) - , poseidon2_B_32_2(il[383]) - , poseidon2_B_32_3(il[384]) - , poseidon2_B_33_0(il[385]) - , poseidon2_B_33_1(il[386]) - , poseidon2_B_33_2(il[387]) - , poseidon2_B_33_3(il[388]) - , poseidon2_B_34_0(il[389]) - , poseidon2_B_34_1(il[390]) - , poseidon2_B_34_2(il[391]) - , poseidon2_B_34_3(il[392]) - , poseidon2_B_35_0(il[393]) - , poseidon2_B_35_1(il[394]) - , poseidon2_B_35_2(il[395]) - , poseidon2_B_35_3(il[396]) - , poseidon2_B_36_0(il[397]) - , poseidon2_B_36_1(il[398]) - , poseidon2_B_36_2(il[399]) - , poseidon2_B_36_3(il[400]) - , poseidon2_B_37_0(il[401]) - , poseidon2_B_37_1(il[402]) - , poseidon2_B_37_2(il[403]) - , poseidon2_B_37_3(il[404]) - , poseidon2_B_38_0(il[405]) - , poseidon2_B_38_1(il[406]) - , poseidon2_B_38_2(il[407]) - , poseidon2_B_38_3(il[408]) - , poseidon2_B_39_0(il[409]) - , poseidon2_B_39_1(il[410]) - , poseidon2_B_39_2(il[411]) - , poseidon2_B_39_3(il[412]) - , poseidon2_B_40_0(il[413]) - , poseidon2_B_40_1(il[414]) - , poseidon2_B_40_2(il[415]) - , poseidon2_B_40_3(il[416]) - , poseidon2_B_41_0(il[417]) - , poseidon2_B_41_1(il[418]) - , poseidon2_B_41_2(il[419]) - , poseidon2_B_41_3(il[420]) - , poseidon2_B_42_0(il[421]) - , poseidon2_B_42_1(il[422]) - , poseidon2_B_42_2(il[423]) - , poseidon2_B_42_3(il[424]) - , poseidon2_B_43_0(il[425]) - , poseidon2_B_43_1(il[426]) - , poseidon2_B_43_2(il[427]) - , poseidon2_B_43_3(il[428]) - , poseidon2_B_44_0(il[429]) - , poseidon2_B_44_1(il[430]) - , poseidon2_B_44_2(il[431]) - , poseidon2_B_44_3(il[432]) - , poseidon2_B_45_0(il[433]) - , poseidon2_B_45_1(il[434]) - , poseidon2_B_45_2(il[435]) - , poseidon2_B_45_3(il[436]) - , poseidon2_B_46_0(il[437]) - , poseidon2_B_46_1(il[438]) - , poseidon2_B_46_2(il[439]) - , poseidon2_B_46_3(il[440]) - , poseidon2_B_47_0(il[441]) - , poseidon2_B_47_1(il[442]) - , poseidon2_B_47_2(il[443]) - , poseidon2_B_47_3(il[444]) - , poseidon2_B_48_0(il[445]) - , poseidon2_B_48_1(il[446]) - , poseidon2_B_48_2(il[447]) - , poseidon2_B_48_3(il[448]) - , poseidon2_B_49_0(il[449]) - , poseidon2_B_49_1(il[450]) - , poseidon2_B_49_2(il[451]) - , poseidon2_B_49_3(il[452]) - , poseidon2_B_4_0(il[453]) - , poseidon2_B_4_1(il[454]) - , poseidon2_B_4_2(il[455]) - , poseidon2_B_4_3(il[456]) - , poseidon2_B_50_0(il[457]) - , poseidon2_B_50_1(il[458]) - , poseidon2_B_50_2(il[459]) - , poseidon2_B_50_3(il[460]) - , poseidon2_B_51_0(il[461]) - , poseidon2_B_51_1(il[462]) - , poseidon2_B_51_2(il[463]) - , poseidon2_B_51_3(il[464]) - , poseidon2_B_52_0(il[465]) - , poseidon2_B_52_1(il[466]) - , poseidon2_B_52_2(il[467]) - , poseidon2_B_52_3(il[468]) - , poseidon2_B_53_0(il[469]) - , poseidon2_B_53_1(il[470]) - , poseidon2_B_53_2(il[471]) - , poseidon2_B_53_3(il[472]) - , poseidon2_B_54_0(il[473]) - , poseidon2_B_54_1(il[474]) - , poseidon2_B_54_2(il[475]) - , poseidon2_B_54_3(il[476]) - , poseidon2_B_55_0(il[477]) - , poseidon2_B_55_1(il[478]) - , poseidon2_B_55_2(il[479]) - , poseidon2_B_55_3(il[480]) - , poseidon2_B_56_0(il[481]) - , poseidon2_B_56_1(il[482]) - , poseidon2_B_56_2(il[483]) - , poseidon2_B_56_3(il[484]) - , poseidon2_B_57_0(il[485]) - , poseidon2_B_57_1(il[486]) - , poseidon2_B_57_2(il[487]) - , poseidon2_B_57_3(il[488]) - , poseidon2_B_58_0(il[489]) - , poseidon2_B_58_1(il[490]) - , poseidon2_B_58_2(il[491]) - , poseidon2_B_58_3(il[492]) - , poseidon2_B_59_0(il[493]) - , poseidon2_B_59_1(il[494]) - , poseidon2_B_59_2(il[495]) - , poseidon2_B_59_3(il[496]) - , poseidon2_B_5_0(il[497]) - , poseidon2_B_5_1(il[498]) - , poseidon2_B_5_2(il[499]) - , poseidon2_B_5_3(il[500]) - , poseidon2_B_6_0(il[501]) - , poseidon2_B_6_1(il[502]) - , poseidon2_B_6_2(il[503]) - , poseidon2_B_6_3(il[504]) - , poseidon2_B_7_0(il[505]) - , poseidon2_B_7_1(il[506]) - , poseidon2_B_7_2(il[507]) - , poseidon2_B_7_3(il[508]) - , poseidon2_B_8_0(il[509]) - , poseidon2_B_8_1(il[510]) - , poseidon2_B_8_2(il[511]) - , poseidon2_B_8_3(il[512]) - , poseidon2_B_9_0(il[513]) - , poseidon2_B_9_1(il[514]) - , poseidon2_B_9_2(il[515]) - , poseidon2_B_9_3(il[516]) - , poseidon2_EXT_LAYER_4(il[517]) - , poseidon2_EXT_LAYER_5(il[518]) - , poseidon2_EXT_LAYER_6(il[519]) - , poseidon2_EXT_LAYER_7(il[520]) - , poseidon2_T_0_4(il[521]) - , poseidon2_T_0_5(il[522]) - , poseidon2_T_0_6(il[523]) - , poseidon2_T_0_7(il[524]) - , poseidon2_T_1_4(il[525]) - , poseidon2_T_1_5(il[526]) - , poseidon2_T_1_6(il[527]) - , poseidon2_T_1_7(il[528]) - , poseidon2_T_2_4(il[529]) - , poseidon2_T_2_5(il[530]) - , poseidon2_T_2_6(il[531]) - , poseidon2_T_2_7(il[532]) - , poseidon2_T_3_4(il[533]) - , poseidon2_T_3_5(il[534]) - , poseidon2_T_3_6(il[535]) - , poseidon2_T_3_7(il[536]) - , poseidon2_T_60_4(il[537]) - , poseidon2_T_60_5(il[538]) - , poseidon2_T_60_6(il[539]) - , poseidon2_T_60_7(il[540]) - , poseidon2_T_61_4(il[541]) - , poseidon2_T_61_5(il[542]) - , poseidon2_T_61_6(il[543]) - , poseidon2_T_61_7(il[544]) - , poseidon2_T_62_4(il[545]) - , poseidon2_T_62_5(il[546]) - , poseidon2_T_62_6(il[547]) - , poseidon2_T_62_7(il[548]) - , poseidon2_T_63_4(il[549]) - , poseidon2_T_63_5(il[550]) - , poseidon2_T_63_6(il[551]) - , poseidon2_T_63_7(il[552]) - , poseidon2_a_0(il[553]) - , poseidon2_a_1(il[554]) - , poseidon2_a_2(il[555]) - , poseidon2_a_3(il[556]) - , poseidon2_b_0(il[557]) - , poseidon2_b_1(il[558]) - , poseidon2_b_2(il[559]) - , poseidon2_b_3(il[560]) - , poseidon2_clk(il[561]) - , poseidon2_full_a_0(il[562]) - , poseidon2_full_a_1(il[563]) - , poseidon2_full_a_2(il[564]) - , poseidon2_full_a_3(il[565]) - , poseidon2_full_b_0(il[566]) - , poseidon2_full_b_1(il[567]) - , poseidon2_full_b_2(il[568]) - , poseidon2_full_b_3(il[569]) - , poseidon2_full_clk(il[570]) - , poseidon2_full_end_poseidon(il[571]) - , poseidon2_full_execute_poseidon_perm(il[572]) - , poseidon2_full_input_0(il[573]) - , poseidon2_full_input_1(il[574]) - , poseidon2_full_input_2(il[575]) - , poseidon2_full_input_len(il[576]) - , poseidon2_full_num_perm_rounds_rem(il[577]) - , poseidon2_full_num_perm_rounds_rem_inv(il[578]) - , poseidon2_full_output(il[579]) - , poseidon2_full_padding(il[580]) - , poseidon2_full_sel_poseidon(il[581]) - , poseidon2_full_start_poseidon(il[582]) - , poseidon2_input_addr(il[583]) - , poseidon2_mem_addr_read_a(il[584]) - , poseidon2_mem_addr_read_b(il[585]) - , poseidon2_mem_addr_read_c(il[586]) - , poseidon2_mem_addr_read_d(il[587]) - , poseidon2_mem_addr_write_a(il[588]) - , poseidon2_mem_addr_write_b(il[589]) - , poseidon2_mem_addr_write_c(il[590]) - , poseidon2_mem_addr_write_d(il[591]) - , poseidon2_output_addr(il[592]) - , poseidon2_sel_poseidon_perm(il[593]) - , poseidon2_sel_poseidon_perm_immediate(il[594]) - , poseidon2_sel_poseidon_perm_mem_op(il[595]) - , poseidon2_space_id(il[596]) - , range_check_alu_rng_chk(il[597]) - , range_check_clk(il[598]) - , range_check_cmp_hi_bits_rng_chk(il[599]) - , range_check_cmp_lo_bits_rng_chk(il[600]) - , range_check_dyn_diff(il[601]) - , range_check_dyn_rng_chk_bits(il[602]) - , range_check_dyn_rng_chk_pow_2(il[603]) - , range_check_gas_da_rng_chk(il[604]) - , range_check_gas_l2_rng_chk(il[605]) - , range_check_is_lte_u112(il[606]) - , range_check_is_lte_u128(il[607]) - , range_check_is_lte_u16(il[608]) - , range_check_is_lte_u32(il[609]) - , range_check_is_lte_u48(il[610]) - , range_check_is_lte_u64(il[611]) - , range_check_is_lte_u80(il[612]) - , range_check_is_lte_u96(il[613]) - , range_check_mem_rng_chk(il[614]) - , range_check_rng_chk_bits(il[615]) - , range_check_sel_lookup_0(il[616]) - , range_check_sel_lookup_1(il[617]) - , range_check_sel_lookup_2(il[618]) - , range_check_sel_lookup_3(il[619]) - , range_check_sel_lookup_4(il[620]) - , range_check_sel_lookup_5(il[621]) - , range_check_sel_lookup_6(il[622]) - , range_check_sel_rng_chk(il[623]) - , range_check_u16_r0(il[624]) - , range_check_u16_r1(il[625]) - , range_check_u16_r2(il[626]) - , range_check_u16_r3(il[627]) - , range_check_u16_r4(il[628]) - , range_check_u16_r5(il[629]) - , range_check_u16_r6(il[630]) - , range_check_u16_r7(il[631]) - , range_check_value(il[632]) - , sha256_clk(il[633]) - , sha256_input(il[634]) - , sha256_output(il[635]) - , sha256_sel_sha256_compression(il[636]) - , sha256_state(il[637]) - , slice_addr(il[638]) - , slice_clk(il[639]) - , slice_cnt(il[640]) - , slice_col_offset(il[641]) - , slice_one_min_inv(il[642]) - , slice_sel_cd_cpy(il[643]) - , slice_sel_mem_active(il[644]) - , slice_sel_return(il[645]) - , slice_sel_start(il[646]) - , slice_space_id(il[647]) - , slice_val(il[648]) - , lookup_rng_chk_pow_2_counts(il[649]) - , lookup_rng_chk_diff_counts(il[650]) - , lookup_rng_chk_0_counts(il[651]) - , lookup_rng_chk_1_counts(il[652]) - , lookup_rng_chk_2_counts(il[653]) - , lookup_rng_chk_3_counts(il[654]) - , lookup_rng_chk_4_counts(il[655]) - , lookup_rng_chk_5_counts(il[656]) - , lookup_rng_chk_6_counts(il[657]) - , lookup_rng_chk_7_counts(il[658]) - , lookup_pow_2_0_counts(il[659]) - , lookup_pow_2_1_counts(il[660]) - , lookup_byte_lengths_counts(il[661]) - , lookup_byte_operations_counts(il[662]) - , lookup_opcode_gas_counts(il[663]) - , kernel_output_lookup_counts(il[664]) - , lookup_into_kernel_counts(il[665]) - , lookup_cd_value_counts(il[666]) - , lookup_ret_value_counts(il[667]) - , incl_main_tag_err_counts(il[668]) - , incl_mem_tag_err_counts(il[669]) - , perm_rng_mem_inv(il[670]) - , perm_rng_cmp_lo_inv(il[671]) - , perm_rng_cmp_hi_inv(il[672]) - , perm_rng_alu_inv(il[673]) - , perm_cmp_alu_inv(il[674]) - , perm_rng_gas_l2_inv(il[675]) - , perm_rng_gas_da_inv(il[676]) - , perm_l2_start_gas_inv(il[677]) - , perm_da_start_gas_inv(il[678]) - , perm_l2_end_gas_inv(il[679]) - , perm_da_end_gas_inv(il[680]) - , perm_pos_mem_read_a_inv(il[681]) - , perm_pos_mem_read_b_inv(il[682]) - , perm_pos_mem_read_c_inv(il[683]) - , perm_pos_mem_read_d_inv(il[684]) - , perm_pos_mem_write_a_inv(il[685]) - , perm_pos_mem_write_b_inv(il[686]) - , perm_pos_mem_write_c_inv(il[687]) - , perm_pos_mem_write_d_inv(il[688]) - , perm_pos2_fixed_pos2_perm_inv(il[689]) - , perm_slice_mem_inv(il[690]) - , perm_main_alu_inv(il[691]) - , perm_main_bin_inv(il[692]) - , perm_main_conv_inv(il[693]) - , perm_main_sha256_inv(il[694]) - , perm_main_pos2_perm_inv(il[695]) - , perm_main_slice_inv(il[696]) - , perm_main_mem_a_inv(il[697]) - , perm_main_mem_b_inv(il[698]) - , perm_main_mem_c_inv(il[699]) - , perm_main_mem_d_inv(il[700]) - , perm_main_mem_ind_addr_a_inv(il[701]) - , perm_main_mem_ind_addr_b_inv(il[702]) - , perm_main_mem_ind_addr_c_inv(il[703]) - , perm_main_mem_ind_addr_d_inv(il[704]) - , lookup_rng_chk_pow_2_inv(il[705]) - , lookup_rng_chk_diff_inv(il[706]) - , lookup_rng_chk_0_inv(il[707]) - , lookup_rng_chk_1_inv(il[708]) - , lookup_rng_chk_2_inv(il[709]) - , lookup_rng_chk_3_inv(il[710]) - , lookup_rng_chk_4_inv(il[711]) - , lookup_rng_chk_5_inv(il[712]) - , lookup_rng_chk_6_inv(il[713]) - , lookup_rng_chk_7_inv(il[714]) - , lookup_pow_2_0_inv(il[715]) - , lookup_pow_2_1_inv(il[716]) - , lookup_byte_lengths_inv(il[717]) - , lookup_byte_operations_inv(il[718]) - , lookup_opcode_gas_inv(il[719]) - , kernel_output_lookup_inv(il[720]) - , lookup_into_kernel_inv(il[721]) - , lookup_cd_value_inv(il[722]) - , lookup_ret_value_inv(il[723]) - , incl_main_tag_err_inv(il[724]) - , incl_mem_tag_err_inv(il[725]) - , binary_acc_ia_shift(il[726]) - , binary_acc_ib_shift(il[727]) - , binary_acc_ic_shift(il[728]) - , binary_mem_tag_ctr_shift(il[729]) - , binary_op_id_shift(il[730]) - , cmp_a_hi_shift(il[731]) - , cmp_a_lo_shift(il[732]) - , cmp_b_hi_shift(il[733]) - , cmp_b_lo_shift(il[734]) - , cmp_cmp_rng_ctr_shift(il[735]) - , cmp_op_gt_shift(il[736]) - , cmp_p_sub_a_hi_shift(il[737]) - , cmp_p_sub_a_lo_shift(il[738]) - , cmp_p_sub_b_hi_shift(il[739]) - , cmp_p_sub_b_lo_shift(il[740]) - , cmp_sel_rng_chk_shift(il[741]) - , main_da_gas_remaining_shift(il[742]) - , main_emit_l2_to_l1_msg_write_offset_shift(il[743]) - , main_emit_note_hash_write_offset_shift(il[744]) - , main_emit_nullifier_write_offset_shift(il[745]) - , main_emit_unencrypted_log_write_offset_shift(il[746]) - , main_internal_return_ptr_shift(il[747]) - , main_l1_to_l2_msg_exists_write_offset_shift(il[748]) - , main_l2_gas_remaining_shift(il[749]) - , main_note_hash_exist_write_offset_shift(il[750]) - , main_nullifier_exists_write_offset_shift(il[751]) - , main_nullifier_non_exists_write_offset_shift(il[752]) - , main_pc_shift(il[753]) - , main_sel_execution_end_shift(il[754]) - , main_sel_execution_row_shift(il[755]) - , main_sload_write_offset_shift(il[756]) - , main_sstore_write_offset_shift(il[757]) - , mem_glob_addr_shift(il[758]) - , mem_rw_shift(il[759]) - , mem_sel_mem_shift(il[760]) - , mem_tag_shift(il[761]) - , mem_tsp_shift(il[762]) - , mem_val_shift(il[763]) - , poseidon2_full_a_0_shift(il[764]) - , poseidon2_full_a_1_shift(il[765]) - , poseidon2_full_a_2_shift(il[766]) - , poseidon2_full_a_3_shift(il[767]) - , poseidon2_full_execute_poseidon_perm_shift(il[768]) - , poseidon2_full_input_0_shift(il[769]) - , poseidon2_full_input_1_shift(il[770]) - , poseidon2_full_input_2_shift(il[771]) - , poseidon2_full_num_perm_rounds_rem_shift(il[772]) - , poseidon2_full_sel_poseidon_shift(il[773]) - , poseidon2_full_start_poseidon_shift(il[774]) - , slice_addr_shift(il[775]) - , slice_clk_shift(il[776]) - , slice_cnt_shift(il[777]) - , slice_col_offset_shift(il[778]) - , slice_sel_cd_cpy_shift(il[779]) - , slice_sel_mem_active_shift(il[780]) - , slice_sel_return_shift(il[781]) - , slice_sel_start_shift(il[782]) - , slice_space_id_shift(il[783]) + , bytecode_end_latch(il[88]) + , bytecode_length_remaining(il[89]) + , bytecode_packed(il[90]) + , bytecode_running_hash(il[91]) + , cmp_a_hi(il[92]) + , cmp_a_lo(il[93]) + , cmp_b_hi(il[94]) + , cmp_b_lo(il[95]) + , cmp_borrow(il[96]) + , cmp_clk(il[97]) + , cmp_cmp_rng_ctr(il[98]) + , cmp_input_a(il[99]) + , cmp_input_b(il[100]) + , cmp_op_eq(il[101]) + , cmp_op_eq_diff_inv(il[102]) + , cmp_op_gt(il[103]) + , cmp_p_a_borrow(il[104]) + , cmp_p_b_borrow(il[105]) + , cmp_p_sub_a_hi(il[106]) + , cmp_p_sub_a_lo(il[107]) + , cmp_p_sub_b_hi(il[108]) + , cmp_p_sub_b_lo(il[109]) + , cmp_range_chk_clk(il[110]) + , cmp_res_hi(il[111]) + , cmp_res_lo(il[112]) + , cmp_result(il[113]) + , cmp_sel_cmp(il[114]) + , cmp_sel_rng_chk(il[115]) + , cmp_shift_sel(il[116]) + , conversion_clk(il[117]) + , conversion_input(il[118]) + , conversion_num_limbs(il[119]) + , conversion_output_bits(il[120]) + , conversion_radix(il[121]) + , conversion_sel_to_radix_le(il[122]) + , keccakf1600_clk(il[123]) + , keccakf1600_input(il[124]) + , keccakf1600_output(il[125]) + , keccakf1600_sel_keccakf1600(il[126]) + , main_abs_da_rem_gas(il[127]) + , main_abs_l2_rem_gas(il[128]) + , main_alu_in_tag(il[129]) + , main_base_da_gas_op_cost(il[130]) + , main_base_l2_gas_op_cost(il[131]) + , main_bin_op_id(il[132]) + , main_call_ptr(il[133]) + , main_da_gas_remaining(il[134]) + , main_da_out_of_gas(il[135]) + , main_dyn_da_gas_op_cost(il[136]) + , main_dyn_gas_multiplier(il[137]) + , main_dyn_l2_gas_op_cost(il[138]) + , main_emit_l2_to_l1_msg_write_offset(il[139]) + , main_emit_note_hash_write_offset(il[140]) + , main_emit_nullifier_write_offset(il[141]) + , main_emit_unencrypted_log_write_offset(il[142]) + , main_ia(il[143]) + , main_ib(il[144]) + , main_ic(il[145]) + , main_id(il[146]) + , main_id_zero(il[147]) + , main_ind_addr_a(il[148]) + , main_ind_addr_b(il[149]) + , main_ind_addr_c(il[150]) + , main_ind_addr_d(il[151]) + , main_internal_return_ptr(il[152]) + , main_inv(il[153]) + , main_is_fake_row(il[154]) + , main_is_gas_accounted(il[155]) + , main_kernel_in_offset(il[156]) + , main_kernel_out_offset(il[157]) + , main_l1_to_l2_msg_exists_write_offset(il[158]) + , main_l2_gas_remaining(il[159]) + , main_l2_out_of_gas(il[160]) + , main_mem_addr_a(il[161]) + , main_mem_addr_b(il[162]) + , main_mem_addr_c(il[163]) + , main_mem_addr_d(il[164]) + , main_note_hash_exist_write_offset(il[165]) + , main_nullifier_exists_write_offset(il[166]) + , main_nullifier_non_exists_write_offset(il[167]) + , main_op_err(il[168]) + , main_opcode_val(il[169]) + , main_pc(il[170]) + , main_r_in_tag(il[171]) + , main_rwa(il[172]) + , main_rwb(il[173]) + , main_rwc(il[174]) + , main_rwd(il[175]) + , main_sel_alu(il[176]) + , main_sel_bin(il[177]) + , main_sel_calldata(il[178]) + , main_sel_execution_end(il[179]) + , main_sel_execution_row(il[180]) + , main_sel_kernel_inputs(il[181]) + , main_sel_kernel_out(il[182]) + , main_sel_mem_op_a(il[183]) + , main_sel_mem_op_b(il[184]) + , main_sel_mem_op_c(il[185]) + , main_sel_mem_op_d(il[186]) + , main_sel_mov_ia_to_ic(il[187]) + , main_sel_mov_ib_to_ic(il[188]) + , main_sel_op_add(il[189]) + , main_sel_op_address(il[190]) + , main_sel_op_and(il[191]) + , main_sel_op_block_number(il[192]) + , main_sel_op_calldata_copy(il[193]) + , main_sel_op_cast(il[194]) + , main_sel_op_chain_id(il[195]) + , main_sel_op_dagasleft(il[196]) + , main_sel_op_div(il[197]) + , main_sel_op_ecadd(il[198]) + , main_sel_op_emit_l2_to_l1_msg(il[199]) + , main_sel_op_emit_note_hash(il[200]) + , main_sel_op_emit_nullifier(il[201]) + , main_sel_op_emit_unencrypted_log(il[202]) + , main_sel_op_eq(il[203]) + , main_sel_op_external_call(il[204]) + , main_sel_op_external_return(il[205]) + , main_sel_op_external_revert(il[206]) + , main_sel_op_fdiv(il[207]) + , main_sel_op_fee_per_da_gas(il[208]) + , main_sel_op_fee_per_l2_gas(il[209]) + , main_sel_op_function_selector(il[210]) + , main_sel_op_get_contract_instance(il[211]) + , main_sel_op_internal_call(il[212]) + , main_sel_op_internal_return(il[213]) + , main_sel_op_is_static_call(il[214]) + , main_sel_op_jump(il[215]) + , main_sel_op_jumpi(il[216]) + , main_sel_op_keccak(il[217]) + , main_sel_op_l1_to_l2_msg_exists(il[218]) + , main_sel_op_l2gasleft(il[219]) + , main_sel_op_lt(il[220]) + , main_sel_op_lte(il[221]) + , main_sel_op_mov(il[222]) + , main_sel_op_msm(il[223]) + , main_sel_op_mul(il[224]) + , main_sel_op_not(il[225]) + , main_sel_op_note_hash_exists(il[226]) + , main_sel_op_nullifier_exists(il[227]) + , main_sel_op_or(il[228]) + , main_sel_op_poseidon2(il[229]) + , main_sel_op_radix_le(il[230]) + , main_sel_op_sender(il[231]) + , main_sel_op_set(il[232]) + , main_sel_op_sha256(il[233]) + , main_sel_op_shl(il[234]) + , main_sel_op_shr(il[235]) + , main_sel_op_sload(il[236]) + , main_sel_op_sstore(il[237]) + , main_sel_op_static_call(il[238]) + , main_sel_op_sub(il[239]) + , main_sel_op_timestamp(il[240]) + , main_sel_op_transaction_fee(il[241]) + , main_sel_op_version(il[242]) + , main_sel_op_xor(il[243]) + , main_sel_q_kernel_lookup(il[244]) + , main_sel_q_kernel_output_lookup(il[245]) + , main_sel_resolve_ind_addr_a(il[246]) + , main_sel_resolve_ind_addr_b(il[247]) + , main_sel_resolve_ind_addr_c(il[248]) + , main_sel_resolve_ind_addr_d(il[249]) + , main_sel_returndata(il[250]) + , main_sel_rng_16(il[251]) + , main_sel_rng_8(il[252]) + , main_sel_slice_gadget(il[253]) + , main_side_effect_counter(il[254]) + , main_sload_write_offset(il[255]) + , main_space_id(il[256]) + , main_sstore_write_offset(il[257]) + , main_tag_err(il[258]) + , main_w_in_tag(il[259]) + , mem_addr(il[260]) + , mem_clk(il[261]) + , mem_diff(il[262]) + , mem_glob_addr(il[263]) + , mem_last(il[264]) + , mem_lastAccess(il[265]) + , mem_one_min_inv(il[266]) + , mem_r_in_tag(il[267]) + , mem_rw(il[268]) + , mem_sel_mem(il[269]) + , mem_sel_mov_ia_to_ic(il[270]) + , mem_sel_mov_ib_to_ic(il[271]) + , mem_sel_op_a(il[272]) + , mem_sel_op_b(il[273]) + , mem_sel_op_c(il[274]) + , mem_sel_op_d(il[275]) + , mem_sel_op_poseidon_read_a(il[276]) + , mem_sel_op_poseidon_read_b(il[277]) + , mem_sel_op_poseidon_read_c(il[278]) + , mem_sel_op_poseidon_read_d(il[279]) + , mem_sel_op_poseidon_write_a(il[280]) + , mem_sel_op_poseidon_write_b(il[281]) + , mem_sel_op_poseidon_write_c(il[282]) + , mem_sel_op_poseidon_write_d(il[283]) + , mem_sel_op_slice(il[284]) + , mem_sel_resolve_ind_addr_a(il[285]) + , mem_sel_resolve_ind_addr_b(il[286]) + , mem_sel_resolve_ind_addr_c(il[287]) + , mem_sel_resolve_ind_addr_d(il[288]) + , mem_sel_rng_chk(il[289]) + , mem_skip_check_tag(il[290]) + , mem_space_id(il[291]) + , mem_tag(il[292]) + , mem_tag_err(il[293]) + , mem_tsp(il[294]) + , mem_val(il[295]) + , mem_w_in_tag(il[296]) + , poseidon2_B_10_0(il[297]) + , poseidon2_B_10_1(il[298]) + , poseidon2_B_10_2(il[299]) + , poseidon2_B_10_3(il[300]) + , poseidon2_B_11_0(il[301]) + , poseidon2_B_11_1(il[302]) + , poseidon2_B_11_2(il[303]) + , poseidon2_B_11_3(il[304]) + , poseidon2_B_12_0(il[305]) + , poseidon2_B_12_1(il[306]) + , poseidon2_B_12_2(il[307]) + , poseidon2_B_12_3(il[308]) + , poseidon2_B_13_0(il[309]) + , poseidon2_B_13_1(il[310]) + , poseidon2_B_13_2(il[311]) + , poseidon2_B_13_3(il[312]) + , poseidon2_B_14_0(il[313]) + , poseidon2_B_14_1(il[314]) + , poseidon2_B_14_2(il[315]) + , poseidon2_B_14_3(il[316]) + , poseidon2_B_15_0(il[317]) + , poseidon2_B_15_1(il[318]) + , poseidon2_B_15_2(il[319]) + , poseidon2_B_15_3(il[320]) + , poseidon2_B_16_0(il[321]) + , poseidon2_B_16_1(il[322]) + , poseidon2_B_16_2(il[323]) + , poseidon2_B_16_3(il[324]) + , poseidon2_B_17_0(il[325]) + , poseidon2_B_17_1(il[326]) + , poseidon2_B_17_2(il[327]) + , poseidon2_B_17_3(il[328]) + , poseidon2_B_18_0(il[329]) + , poseidon2_B_18_1(il[330]) + , poseidon2_B_18_2(il[331]) + , poseidon2_B_18_3(il[332]) + , poseidon2_B_19_0(il[333]) + , poseidon2_B_19_1(il[334]) + , poseidon2_B_19_2(il[335]) + , poseidon2_B_19_3(il[336]) + , poseidon2_B_20_0(il[337]) + , poseidon2_B_20_1(il[338]) + , poseidon2_B_20_2(il[339]) + , poseidon2_B_20_3(il[340]) + , poseidon2_B_21_0(il[341]) + , poseidon2_B_21_1(il[342]) + , poseidon2_B_21_2(il[343]) + , poseidon2_B_21_3(il[344]) + , poseidon2_B_22_0(il[345]) + , poseidon2_B_22_1(il[346]) + , poseidon2_B_22_2(il[347]) + , poseidon2_B_22_3(il[348]) + , poseidon2_B_23_0(il[349]) + , poseidon2_B_23_1(il[350]) + , poseidon2_B_23_2(il[351]) + , poseidon2_B_23_3(il[352]) + , poseidon2_B_24_0(il[353]) + , poseidon2_B_24_1(il[354]) + , poseidon2_B_24_2(il[355]) + , poseidon2_B_24_3(il[356]) + , poseidon2_B_25_0(il[357]) + , poseidon2_B_25_1(il[358]) + , poseidon2_B_25_2(il[359]) + , poseidon2_B_25_3(il[360]) + , poseidon2_B_26_0(il[361]) + , poseidon2_B_26_1(il[362]) + , poseidon2_B_26_2(il[363]) + , poseidon2_B_26_3(il[364]) + , poseidon2_B_27_0(il[365]) + , poseidon2_B_27_1(il[366]) + , poseidon2_B_27_2(il[367]) + , poseidon2_B_27_3(il[368]) + , poseidon2_B_28_0(il[369]) + , poseidon2_B_28_1(il[370]) + , poseidon2_B_28_2(il[371]) + , poseidon2_B_28_3(il[372]) + , poseidon2_B_29_0(il[373]) + , poseidon2_B_29_1(il[374]) + , poseidon2_B_29_2(il[375]) + , poseidon2_B_29_3(il[376]) + , poseidon2_B_30_0(il[377]) + , poseidon2_B_30_1(il[378]) + , poseidon2_B_30_2(il[379]) + , poseidon2_B_30_3(il[380]) + , poseidon2_B_31_0(il[381]) + , poseidon2_B_31_1(il[382]) + , poseidon2_B_31_2(il[383]) + , poseidon2_B_31_3(il[384]) + , poseidon2_B_32_0(il[385]) + , poseidon2_B_32_1(il[386]) + , poseidon2_B_32_2(il[387]) + , poseidon2_B_32_3(il[388]) + , poseidon2_B_33_0(il[389]) + , poseidon2_B_33_1(il[390]) + , poseidon2_B_33_2(il[391]) + , poseidon2_B_33_3(il[392]) + , poseidon2_B_34_0(il[393]) + , poseidon2_B_34_1(il[394]) + , poseidon2_B_34_2(il[395]) + , poseidon2_B_34_3(il[396]) + , poseidon2_B_35_0(il[397]) + , poseidon2_B_35_1(il[398]) + , poseidon2_B_35_2(il[399]) + , poseidon2_B_35_3(il[400]) + , poseidon2_B_36_0(il[401]) + , poseidon2_B_36_1(il[402]) + , poseidon2_B_36_2(il[403]) + , poseidon2_B_36_3(il[404]) + , poseidon2_B_37_0(il[405]) + , poseidon2_B_37_1(il[406]) + , poseidon2_B_37_2(il[407]) + , poseidon2_B_37_3(il[408]) + , poseidon2_B_38_0(il[409]) + , poseidon2_B_38_1(il[410]) + , poseidon2_B_38_2(il[411]) + , poseidon2_B_38_3(il[412]) + , poseidon2_B_39_0(il[413]) + , poseidon2_B_39_1(il[414]) + , poseidon2_B_39_2(il[415]) + , poseidon2_B_39_3(il[416]) + , poseidon2_B_40_0(il[417]) + , poseidon2_B_40_1(il[418]) + , poseidon2_B_40_2(il[419]) + , poseidon2_B_40_3(il[420]) + , poseidon2_B_41_0(il[421]) + , poseidon2_B_41_1(il[422]) + , poseidon2_B_41_2(il[423]) + , poseidon2_B_41_3(il[424]) + , poseidon2_B_42_0(il[425]) + , poseidon2_B_42_1(il[426]) + , poseidon2_B_42_2(il[427]) + , poseidon2_B_42_3(il[428]) + , poseidon2_B_43_0(il[429]) + , poseidon2_B_43_1(il[430]) + , poseidon2_B_43_2(il[431]) + , poseidon2_B_43_3(il[432]) + , poseidon2_B_44_0(il[433]) + , poseidon2_B_44_1(il[434]) + , poseidon2_B_44_2(il[435]) + , poseidon2_B_44_3(il[436]) + , poseidon2_B_45_0(il[437]) + , poseidon2_B_45_1(il[438]) + , poseidon2_B_45_2(il[439]) + , poseidon2_B_45_3(il[440]) + , poseidon2_B_46_0(il[441]) + , poseidon2_B_46_1(il[442]) + , poseidon2_B_46_2(il[443]) + , poseidon2_B_46_3(il[444]) + , poseidon2_B_47_0(il[445]) + , poseidon2_B_47_1(il[446]) + , poseidon2_B_47_2(il[447]) + , poseidon2_B_47_3(il[448]) + , poseidon2_B_48_0(il[449]) + , poseidon2_B_48_1(il[450]) + , poseidon2_B_48_2(il[451]) + , poseidon2_B_48_3(il[452]) + , poseidon2_B_49_0(il[453]) + , poseidon2_B_49_1(il[454]) + , poseidon2_B_49_2(il[455]) + , poseidon2_B_49_3(il[456]) + , poseidon2_B_4_0(il[457]) + , poseidon2_B_4_1(il[458]) + , poseidon2_B_4_2(il[459]) + , poseidon2_B_4_3(il[460]) + , poseidon2_B_50_0(il[461]) + , poseidon2_B_50_1(il[462]) + , poseidon2_B_50_2(il[463]) + , poseidon2_B_50_3(il[464]) + , poseidon2_B_51_0(il[465]) + , poseidon2_B_51_1(il[466]) + , poseidon2_B_51_2(il[467]) + , poseidon2_B_51_3(il[468]) + , poseidon2_B_52_0(il[469]) + , poseidon2_B_52_1(il[470]) + , poseidon2_B_52_2(il[471]) + , poseidon2_B_52_3(il[472]) + , poseidon2_B_53_0(il[473]) + , poseidon2_B_53_1(il[474]) + , poseidon2_B_53_2(il[475]) + , poseidon2_B_53_3(il[476]) + , poseidon2_B_54_0(il[477]) + , poseidon2_B_54_1(il[478]) + , poseidon2_B_54_2(il[479]) + , poseidon2_B_54_3(il[480]) + , poseidon2_B_55_0(il[481]) + , poseidon2_B_55_1(il[482]) + , poseidon2_B_55_2(il[483]) + , poseidon2_B_55_3(il[484]) + , poseidon2_B_56_0(il[485]) + , poseidon2_B_56_1(il[486]) + , poseidon2_B_56_2(il[487]) + , poseidon2_B_56_3(il[488]) + , poseidon2_B_57_0(il[489]) + , poseidon2_B_57_1(il[490]) + , poseidon2_B_57_2(il[491]) + , poseidon2_B_57_3(il[492]) + , poseidon2_B_58_0(il[493]) + , poseidon2_B_58_1(il[494]) + , poseidon2_B_58_2(il[495]) + , poseidon2_B_58_3(il[496]) + , poseidon2_B_59_0(il[497]) + , poseidon2_B_59_1(il[498]) + , poseidon2_B_59_2(il[499]) + , poseidon2_B_59_3(il[500]) + , poseidon2_B_5_0(il[501]) + , poseidon2_B_5_1(il[502]) + , poseidon2_B_5_2(il[503]) + , poseidon2_B_5_3(il[504]) + , poseidon2_B_6_0(il[505]) + , poseidon2_B_6_1(il[506]) + , poseidon2_B_6_2(il[507]) + , poseidon2_B_6_3(il[508]) + , poseidon2_B_7_0(il[509]) + , poseidon2_B_7_1(il[510]) + , poseidon2_B_7_2(il[511]) + , poseidon2_B_7_3(il[512]) + , poseidon2_B_8_0(il[513]) + , poseidon2_B_8_1(il[514]) + , poseidon2_B_8_2(il[515]) + , poseidon2_B_8_3(il[516]) + , poseidon2_B_9_0(il[517]) + , poseidon2_B_9_1(il[518]) + , poseidon2_B_9_2(il[519]) + , poseidon2_B_9_3(il[520]) + , poseidon2_EXT_LAYER_4(il[521]) + , poseidon2_EXT_LAYER_5(il[522]) + , poseidon2_EXT_LAYER_6(il[523]) + , poseidon2_EXT_LAYER_7(il[524]) + , poseidon2_T_0_4(il[525]) + , poseidon2_T_0_5(il[526]) + , poseidon2_T_0_6(il[527]) + , poseidon2_T_0_7(il[528]) + , poseidon2_T_1_4(il[529]) + , poseidon2_T_1_5(il[530]) + , poseidon2_T_1_6(il[531]) + , poseidon2_T_1_7(il[532]) + , poseidon2_T_2_4(il[533]) + , poseidon2_T_2_5(il[534]) + , poseidon2_T_2_6(il[535]) + , poseidon2_T_2_7(il[536]) + , poseidon2_T_3_4(il[537]) + , poseidon2_T_3_5(il[538]) + , poseidon2_T_3_6(il[539]) + , poseidon2_T_3_7(il[540]) + , poseidon2_T_60_4(il[541]) + , poseidon2_T_60_5(il[542]) + , poseidon2_T_60_6(il[543]) + , poseidon2_T_60_7(il[544]) + , poseidon2_T_61_4(il[545]) + , poseidon2_T_61_5(il[546]) + , poseidon2_T_61_6(il[547]) + , poseidon2_T_61_7(il[548]) + , poseidon2_T_62_4(il[549]) + , poseidon2_T_62_5(il[550]) + , poseidon2_T_62_6(il[551]) + , poseidon2_T_62_7(il[552]) + , poseidon2_T_63_4(il[553]) + , poseidon2_T_63_5(il[554]) + , poseidon2_T_63_6(il[555]) + , poseidon2_T_63_7(il[556]) + , poseidon2_a_0(il[557]) + , poseidon2_a_1(il[558]) + , poseidon2_a_2(il[559]) + , poseidon2_a_3(il[560]) + , poseidon2_b_0(il[561]) + , poseidon2_b_1(il[562]) + , poseidon2_b_2(il[563]) + , poseidon2_b_3(il[564]) + , poseidon2_clk(il[565]) + , poseidon2_full_a_0(il[566]) + , poseidon2_full_a_1(il[567]) + , poseidon2_full_a_2(il[568]) + , poseidon2_full_a_3(il[569]) + , poseidon2_full_b_0(il[570]) + , poseidon2_full_b_1(il[571]) + , poseidon2_full_b_2(il[572]) + , poseidon2_full_b_3(il[573]) + , poseidon2_full_clk(il[574]) + , poseidon2_full_end_poseidon(il[575]) + , poseidon2_full_execute_poseidon_perm(il[576]) + , poseidon2_full_input_0(il[577]) + , poseidon2_full_input_1(il[578]) + , poseidon2_full_input_2(il[579]) + , poseidon2_full_input_len(il[580]) + , poseidon2_full_num_perm_rounds_rem(il[581]) + , poseidon2_full_num_perm_rounds_rem_inv(il[582]) + , poseidon2_full_output(il[583]) + , poseidon2_full_padding(il[584]) + , poseidon2_full_sel_poseidon(il[585]) + , poseidon2_full_start_poseidon(il[586]) + , poseidon2_input_addr(il[587]) + , poseidon2_mem_addr_read_a(il[588]) + , poseidon2_mem_addr_read_b(il[589]) + , poseidon2_mem_addr_read_c(il[590]) + , poseidon2_mem_addr_read_d(il[591]) + , poseidon2_mem_addr_write_a(il[592]) + , poseidon2_mem_addr_write_b(il[593]) + , poseidon2_mem_addr_write_c(il[594]) + , poseidon2_mem_addr_write_d(il[595]) + , poseidon2_output_addr(il[596]) + , poseidon2_sel_poseidon_perm(il[597]) + , poseidon2_sel_poseidon_perm_immediate(il[598]) + , poseidon2_sel_poseidon_perm_mem_op(il[599]) + , poseidon2_space_id(il[600]) + , range_check_alu_rng_chk(il[601]) + , range_check_clk(il[602]) + , range_check_cmp_hi_bits_rng_chk(il[603]) + , range_check_cmp_lo_bits_rng_chk(il[604]) + , range_check_dyn_diff(il[605]) + , range_check_dyn_rng_chk_bits(il[606]) + , range_check_dyn_rng_chk_pow_2(il[607]) + , range_check_gas_da_rng_chk(il[608]) + , range_check_gas_l2_rng_chk(il[609]) + , range_check_is_lte_u112(il[610]) + , range_check_is_lte_u128(il[611]) + , range_check_is_lte_u16(il[612]) + , range_check_is_lte_u32(il[613]) + , range_check_is_lte_u48(il[614]) + , range_check_is_lte_u64(il[615]) + , range_check_is_lte_u80(il[616]) + , range_check_is_lte_u96(il[617]) + , range_check_mem_rng_chk(il[618]) + , range_check_rng_chk_bits(il[619]) + , range_check_sel_lookup_0(il[620]) + , range_check_sel_lookup_1(il[621]) + , range_check_sel_lookup_2(il[622]) + , range_check_sel_lookup_3(il[623]) + , range_check_sel_lookup_4(il[624]) + , range_check_sel_lookup_5(il[625]) + , range_check_sel_lookup_6(il[626]) + , range_check_sel_rng_chk(il[627]) + , range_check_u16_r0(il[628]) + , range_check_u16_r1(il[629]) + , range_check_u16_r2(il[630]) + , range_check_u16_r3(il[631]) + , range_check_u16_r4(il[632]) + , range_check_u16_r5(il[633]) + , range_check_u16_r6(il[634]) + , range_check_u16_r7(il[635]) + , range_check_value(il[636]) + , sha256_clk(il[637]) + , sha256_input(il[638]) + , sha256_output(il[639]) + , sha256_sel_sha256_compression(il[640]) + , sha256_state(il[641]) + , slice_addr(il[642]) + , slice_clk(il[643]) + , slice_cnt(il[644]) + , slice_col_offset(il[645]) + , slice_one_min_inv(il[646]) + , slice_sel_cd_cpy(il[647]) + , slice_sel_mem_active(il[648]) + , slice_sel_return(il[649]) + , slice_sel_start(il[650]) + , slice_space_id(il[651]) + , slice_val(il[652]) + , lookup_rng_chk_pow_2_counts(il[653]) + , lookup_rng_chk_diff_counts(il[654]) + , lookup_rng_chk_0_counts(il[655]) + , lookup_rng_chk_1_counts(il[656]) + , lookup_rng_chk_2_counts(il[657]) + , lookup_rng_chk_3_counts(il[658]) + , lookup_rng_chk_4_counts(il[659]) + , lookup_rng_chk_5_counts(il[660]) + , lookup_rng_chk_6_counts(il[661]) + , lookup_rng_chk_7_counts(il[662]) + , lookup_pow_2_0_counts(il[663]) + , lookup_pow_2_1_counts(il[664]) + , lookup_byte_lengths_counts(il[665]) + , lookup_byte_operations_counts(il[666]) + , lookup_opcode_gas_counts(il[667]) + , kernel_output_lookup_counts(il[668]) + , lookup_into_kernel_counts(il[669]) + , lookup_cd_value_counts(il[670]) + , lookup_ret_value_counts(il[671]) + , incl_main_tag_err_counts(il[672]) + , incl_mem_tag_err_counts(il[673]) + , perm_rng_mem_inv(il[674]) + , perm_rng_cmp_lo_inv(il[675]) + , perm_rng_cmp_hi_inv(il[676]) + , perm_rng_alu_inv(il[677]) + , perm_cmp_alu_inv(il[678]) + , perm_rng_gas_l2_inv(il[679]) + , perm_rng_gas_da_inv(il[680]) + , perm_l2_start_gas_inv(il[681]) + , perm_da_start_gas_inv(il[682]) + , perm_l2_end_gas_inv(il[683]) + , perm_da_end_gas_inv(il[684]) + , perm_pos_mem_read_a_inv(il[685]) + , perm_pos_mem_read_b_inv(il[686]) + , perm_pos_mem_read_c_inv(il[687]) + , perm_pos_mem_read_d_inv(il[688]) + , perm_pos_mem_write_a_inv(il[689]) + , perm_pos_mem_write_b_inv(il[690]) + , perm_pos_mem_write_c_inv(il[691]) + , perm_pos_mem_write_d_inv(il[692]) + , perm_pos2_fixed_pos2_perm_inv(il[693]) + , perm_slice_mem_inv(il[694]) + , perm_main_alu_inv(il[695]) + , perm_main_bin_inv(il[696]) + , perm_main_conv_inv(il[697]) + , perm_main_sha256_inv(il[698]) + , perm_main_pos2_perm_inv(il[699]) + , perm_main_slice_inv(il[700]) + , perm_main_mem_a_inv(il[701]) + , perm_main_mem_b_inv(il[702]) + , perm_main_mem_c_inv(il[703]) + , perm_main_mem_d_inv(il[704]) + , perm_main_mem_ind_addr_a_inv(il[705]) + , perm_main_mem_ind_addr_b_inv(il[706]) + , perm_main_mem_ind_addr_c_inv(il[707]) + , perm_main_mem_ind_addr_d_inv(il[708]) + , lookup_rng_chk_pow_2_inv(il[709]) + , lookup_rng_chk_diff_inv(il[710]) + , lookup_rng_chk_0_inv(il[711]) + , lookup_rng_chk_1_inv(il[712]) + , lookup_rng_chk_2_inv(il[713]) + , lookup_rng_chk_3_inv(il[714]) + , lookup_rng_chk_4_inv(il[715]) + , lookup_rng_chk_5_inv(il[716]) + , lookup_rng_chk_6_inv(il[717]) + , lookup_rng_chk_7_inv(il[718]) + , lookup_pow_2_0_inv(il[719]) + , lookup_pow_2_1_inv(il[720]) + , lookup_byte_lengths_inv(il[721]) + , lookup_byte_operations_inv(il[722]) + , lookup_opcode_gas_inv(il[723]) + , kernel_output_lookup_inv(il[724]) + , lookup_into_kernel_inv(il[725]) + , lookup_cd_value_inv(il[726]) + , lookup_ret_value_inv(il[727]) + , incl_main_tag_err_inv(il[728]) + , incl_mem_tag_err_inv(il[729]) + , binary_acc_ia_shift(il[730]) + , binary_acc_ib_shift(il[731]) + , binary_acc_ic_shift(il[732]) + , binary_mem_tag_ctr_shift(il[733]) + , binary_op_id_shift(il[734]) + , cmp_a_hi_shift(il[735]) + , cmp_a_lo_shift(il[736]) + , cmp_b_hi_shift(il[737]) + , cmp_b_lo_shift(il[738]) + , cmp_cmp_rng_ctr_shift(il[739]) + , cmp_op_gt_shift(il[740]) + , cmp_p_sub_a_hi_shift(il[741]) + , cmp_p_sub_a_lo_shift(il[742]) + , cmp_p_sub_b_hi_shift(il[743]) + , cmp_p_sub_b_lo_shift(il[744]) + , cmp_sel_rng_chk_shift(il[745]) + , main_da_gas_remaining_shift(il[746]) + , main_emit_l2_to_l1_msg_write_offset_shift(il[747]) + , main_emit_note_hash_write_offset_shift(il[748]) + , main_emit_nullifier_write_offset_shift(il[749]) + , main_emit_unencrypted_log_write_offset_shift(il[750]) + , main_internal_return_ptr_shift(il[751]) + , main_l1_to_l2_msg_exists_write_offset_shift(il[752]) + , main_l2_gas_remaining_shift(il[753]) + , main_note_hash_exist_write_offset_shift(il[754]) + , main_nullifier_exists_write_offset_shift(il[755]) + , main_nullifier_non_exists_write_offset_shift(il[756]) + , main_pc_shift(il[757]) + , main_sel_execution_end_shift(il[758]) + , main_sel_execution_row_shift(il[759]) + , main_sload_write_offset_shift(il[760]) + , main_sstore_write_offset_shift(il[761]) + , mem_glob_addr_shift(il[762]) + , mem_rw_shift(il[763]) + , mem_sel_mem_shift(il[764]) + , mem_tag_shift(il[765]) + , mem_tsp_shift(il[766]) + , mem_val_shift(il[767]) + , poseidon2_full_a_0_shift(il[768]) + , poseidon2_full_a_1_shift(il[769]) + , poseidon2_full_a_2_shift(il[770]) + , poseidon2_full_a_3_shift(il[771]) + , poseidon2_full_execute_poseidon_perm_shift(il[772]) + , poseidon2_full_input_0_shift(il[773]) + , poseidon2_full_input_1_shift(il[774]) + , poseidon2_full_input_2_shift(il[775]) + , poseidon2_full_num_perm_rounds_rem_shift(il[776]) + , poseidon2_full_sel_poseidon_shift(il[777]) + , poseidon2_full_start_poseidon_shift(il[778]) + , slice_addr_shift(il[779]) + , slice_clk_shift(il[780]) + , slice_cnt_shift(il[781]) + , slice_col_offset_shift(il[782]) + , slice_sel_cd_cpy_shift(il[783]) + , slice_sel_mem_active_shift(il[784]) + , slice_sel_return_shift(il[785]) + , slice_sel_start_shift(il[786]) + , slice_space_id_shift(il[787]) {} AvmFlavor::ProverPolynomials::ProverPolynomials(ProvingKey& proving_key) @@ -893,6 +897,10 @@ AvmFlavor::AllConstRefValues AvmFlavor::ProverPolynomials::get_row(size_t row_id binary_op_id[row_idx], binary_sel_bin[row_idx], binary_start[row_idx], + bytecode_end_latch[row_idx], + bytecode_length_remaining[row_idx], + bytecode_packed[row_idx], + bytecode_running_hash[row_idx], cmp_a_hi[row_idx], cmp_a_lo[row_idx], cmp_b_hi[row_idx], @@ -1681,6 +1689,10 @@ AvmFlavor::CommitmentLabels::CommitmentLabels() Base::binary_op_id = "BINARY_OP_ID"; Base::binary_sel_bin = "BINARY_SEL_BIN"; Base::binary_start = "BINARY_START"; + Base::bytecode_end_latch = "BYTECODE_END_LATCH"; + Base::bytecode_length_remaining = "BYTECODE_LENGTH_REMAINING"; + Base::bytecode_packed = "BYTECODE_PACKED"; + Base::bytecode_running_hash = "BYTECODE_RUNNING_HASH"; Base::cmp_a_hi = "CMP_A_HI"; Base::cmp_a_lo = "CMP_A_LO"; Base::cmp_b_hi = "CMP_B_HI"; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.hpp index e43fb6f2a99..711a694ad24 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.hpp @@ -95,7 +95,7 @@ template using tuple_cat_t = decltype(std::tuple_cat(std:: // The entities that will be used in the flavor. // clang-format off #define PRECOMPUTED_ENTITIES byte_lookup_sel_bin, byte_lookup_table_byte_lengths, byte_lookup_table_in_tags, byte_lookup_table_input_a, byte_lookup_table_input_b, byte_lookup_table_op_id, byte_lookup_table_output, gas_base_da_gas_fixed_table, gas_base_l2_gas_fixed_table, gas_dyn_da_gas_fixed_table, gas_dyn_l2_gas_fixed_table, gas_sel_gas_cost, main_clk, main_sel_da_end_gas_kernel_input, main_sel_da_start_gas_kernel_input, main_sel_first, main_sel_l2_end_gas_kernel_input, main_sel_l2_start_gas_kernel_input, main_sel_start_exec, main_zeroes, powers_power_of_2 -#define WIRE_ENTITIES main_kernel_inputs, main_kernel_value_out, main_kernel_side_effect_out, main_kernel_metadata_out, main_calldata, main_returndata, alu_a_hi, alu_a_lo, alu_b_hi, alu_b_lo, alu_b_pow, alu_c_hi, alu_c_lo, alu_cf, alu_clk, alu_cmp_gadget_gt, alu_cmp_gadget_input_a, alu_cmp_gadget_input_b, alu_cmp_gadget_result, alu_cmp_gadget_sel, alu_ff_tag, alu_ia, alu_ib, alu_ic, alu_in_tag, alu_max_bits_sub_b_bits, alu_max_bits_sub_b_pow, alu_op_add, alu_op_cast, alu_op_div, alu_op_eq, alu_op_lt, alu_op_lte, alu_op_mul, alu_op_not, alu_op_shl, alu_op_shr, alu_op_sub, alu_partial_prod_hi, alu_partial_prod_lo, alu_range_check_input_value, alu_range_check_num_bits, alu_range_check_sel, alu_remainder, alu_sel_alu, alu_sel_cmp, alu_sel_shift_which, alu_u128_tag, alu_u16_tag, alu_u1_tag, alu_u32_tag, alu_u64_tag, alu_u8_tag, alu_zero_shift, binary_acc_ia, binary_acc_ib, binary_acc_ic, binary_clk, binary_ia_bytes, binary_ib_bytes, binary_ic_bytes, binary_in_tag, binary_mem_tag_ctr, binary_mem_tag_ctr_inv, binary_op_id, binary_sel_bin, binary_start, cmp_a_hi, cmp_a_lo, cmp_b_hi, cmp_b_lo, cmp_borrow, cmp_clk, cmp_cmp_rng_ctr, cmp_input_a, cmp_input_b, cmp_op_eq, cmp_op_eq_diff_inv, cmp_op_gt, cmp_p_a_borrow, cmp_p_b_borrow, cmp_p_sub_a_hi, cmp_p_sub_a_lo, cmp_p_sub_b_hi, cmp_p_sub_b_lo, cmp_range_chk_clk, cmp_res_hi, cmp_res_lo, cmp_result, cmp_sel_cmp, cmp_sel_rng_chk, cmp_shift_sel, conversion_clk, conversion_input, conversion_num_limbs, conversion_output_bits, conversion_radix, conversion_sel_to_radix_le, keccakf1600_clk, keccakf1600_input, keccakf1600_output, keccakf1600_sel_keccakf1600, main_abs_da_rem_gas, main_abs_l2_rem_gas, main_alu_in_tag, main_base_da_gas_op_cost, main_base_l2_gas_op_cost, main_bin_op_id, main_call_ptr, main_da_gas_remaining, main_da_out_of_gas, main_dyn_da_gas_op_cost, main_dyn_gas_multiplier, main_dyn_l2_gas_op_cost, main_emit_l2_to_l1_msg_write_offset, main_emit_note_hash_write_offset, main_emit_nullifier_write_offset, main_emit_unencrypted_log_write_offset, main_ia, main_ib, main_ic, main_id, main_id_zero, main_ind_addr_a, main_ind_addr_b, main_ind_addr_c, main_ind_addr_d, main_internal_return_ptr, main_inv, main_is_fake_row, main_is_gas_accounted, main_kernel_in_offset, main_kernel_out_offset, main_l1_to_l2_msg_exists_write_offset, main_l2_gas_remaining, main_l2_out_of_gas, main_mem_addr_a, main_mem_addr_b, main_mem_addr_c, main_mem_addr_d, main_note_hash_exist_write_offset, main_nullifier_exists_write_offset, main_nullifier_non_exists_write_offset, main_op_err, main_opcode_val, main_pc, main_r_in_tag, main_rwa, main_rwb, main_rwc, main_rwd, main_sel_alu, main_sel_bin, main_sel_calldata, main_sel_execution_end, main_sel_execution_row, main_sel_kernel_inputs, main_sel_kernel_out, main_sel_mem_op_a, main_sel_mem_op_b, main_sel_mem_op_c, main_sel_mem_op_d, main_sel_mov_ia_to_ic, main_sel_mov_ib_to_ic, main_sel_op_add, main_sel_op_address, main_sel_op_and, main_sel_op_block_number, main_sel_op_calldata_copy, main_sel_op_cast, main_sel_op_chain_id, main_sel_op_dagasleft, main_sel_op_div, main_sel_op_ecadd, main_sel_op_emit_l2_to_l1_msg, main_sel_op_emit_note_hash, main_sel_op_emit_nullifier, main_sel_op_emit_unencrypted_log, main_sel_op_eq, main_sel_op_external_call, main_sel_op_external_return, main_sel_op_external_revert, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, main_sel_op_function_selector, main_sel_op_get_contract_instance, main_sel_op_internal_call, main_sel_op_internal_return, main_sel_op_is_static_call, 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_msm, main_sel_op_mul, main_sel_op_not, main_sel_op_note_hash_exists, main_sel_op_nullifier_exists, main_sel_op_or, main_sel_op_poseidon2, main_sel_op_radix_le, main_sel_op_sender, main_sel_op_set, main_sel_op_sha256, main_sel_op_shl, main_sel_op_shr, main_sel_op_sload, main_sel_op_sstore, main_sel_op_static_call, main_sel_op_sub, main_sel_op_timestamp, main_sel_op_transaction_fee, main_sel_op_version, main_sel_op_xor, main_sel_q_kernel_lookup, main_sel_q_kernel_output_lookup, main_sel_resolve_ind_addr_a, main_sel_resolve_ind_addr_b, main_sel_resolve_ind_addr_c, main_sel_resolve_ind_addr_d, main_sel_returndata, main_sel_rng_16, main_sel_rng_8, main_sel_slice_gadget, main_side_effect_counter, main_sload_write_offset, main_space_id, main_sstore_write_offset, main_tag_err, main_w_in_tag, mem_addr, mem_clk, mem_diff, mem_glob_addr, mem_last, mem_lastAccess, mem_one_min_inv, mem_r_in_tag, mem_rw, mem_sel_mem, mem_sel_mov_ia_to_ic, mem_sel_mov_ib_to_ic, mem_sel_op_a, mem_sel_op_b, mem_sel_op_c, mem_sel_op_d, mem_sel_op_poseidon_read_a, mem_sel_op_poseidon_read_b, mem_sel_op_poseidon_read_c, mem_sel_op_poseidon_read_d, mem_sel_op_poseidon_write_a, mem_sel_op_poseidon_write_b, mem_sel_op_poseidon_write_c, mem_sel_op_poseidon_write_d, mem_sel_op_slice, mem_sel_resolve_ind_addr_a, mem_sel_resolve_ind_addr_b, mem_sel_resolve_ind_addr_c, mem_sel_resolve_ind_addr_d, mem_sel_rng_chk, mem_skip_check_tag, mem_space_id, mem_tag, mem_tag_err, mem_tsp, mem_val, mem_w_in_tag, poseidon2_B_10_0, poseidon2_B_10_1, poseidon2_B_10_2, poseidon2_B_10_3, poseidon2_B_11_0, poseidon2_B_11_1, poseidon2_B_11_2, poseidon2_B_11_3, poseidon2_B_12_0, poseidon2_B_12_1, poseidon2_B_12_2, poseidon2_B_12_3, poseidon2_B_13_0, poseidon2_B_13_1, poseidon2_B_13_2, poseidon2_B_13_3, poseidon2_B_14_0, poseidon2_B_14_1, poseidon2_B_14_2, poseidon2_B_14_3, poseidon2_B_15_0, poseidon2_B_15_1, poseidon2_B_15_2, poseidon2_B_15_3, poseidon2_B_16_0, poseidon2_B_16_1, poseidon2_B_16_2, poseidon2_B_16_3, poseidon2_B_17_0, poseidon2_B_17_1, poseidon2_B_17_2, poseidon2_B_17_3, poseidon2_B_18_0, poseidon2_B_18_1, poseidon2_B_18_2, poseidon2_B_18_3, poseidon2_B_19_0, poseidon2_B_19_1, poseidon2_B_19_2, poseidon2_B_19_3, poseidon2_B_20_0, poseidon2_B_20_1, poseidon2_B_20_2, poseidon2_B_20_3, poseidon2_B_21_0, poseidon2_B_21_1, poseidon2_B_21_2, poseidon2_B_21_3, poseidon2_B_22_0, poseidon2_B_22_1, poseidon2_B_22_2, poseidon2_B_22_3, poseidon2_B_23_0, poseidon2_B_23_1, poseidon2_B_23_2, poseidon2_B_23_3, poseidon2_B_24_0, poseidon2_B_24_1, poseidon2_B_24_2, poseidon2_B_24_3, poseidon2_B_25_0, poseidon2_B_25_1, poseidon2_B_25_2, poseidon2_B_25_3, poseidon2_B_26_0, poseidon2_B_26_1, poseidon2_B_26_2, poseidon2_B_26_3, poseidon2_B_27_0, poseidon2_B_27_1, poseidon2_B_27_2, poseidon2_B_27_3, poseidon2_B_28_0, poseidon2_B_28_1, poseidon2_B_28_2, poseidon2_B_28_3, poseidon2_B_29_0, poseidon2_B_29_1, poseidon2_B_29_2, poseidon2_B_29_3, poseidon2_B_30_0, poseidon2_B_30_1, poseidon2_B_30_2, poseidon2_B_30_3, poseidon2_B_31_0, poseidon2_B_31_1, poseidon2_B_31_2, poseidon2_B_31_3, poseidon2_B_32_0, poseidon2_B_32_1, poseidon2_B_32_2, poseidon2_B_32_3, poseidon2_B_33_0, poseidon2_B_33_1, poseidon2_B_33_2, poseidon2_B_33_3, poseidon2_B_34_0, poseidon2_B_34_1, poseidon2_B_34_2, poseidon2_B_34_3, poseidon2_B_35_0, poseidon2_B_35_1, poseidon2_B_35_2, poseidon2_B_35_3, poseidon2_B_36_0, poseidon2_B_36_1, poseidon2_B_36_2, poseidon2_B_36_3, poseidon2_B_37_0, poseidon2_B_37_1, poseidon2_B_37_2, poseidon2_B_37_3, poseidon2_B_38_0, poseidon2_B_38_1, poseidon2_B_38_2, poseidon2_B_38_3, poseidon2_B_39_0, poseidon2_B_39_1, poseidon2_B_39_2, poseidon2_B_39_3, poseidon2_B_40_0, poseidon2_B_40_1, poseidon2_B_40_2, poseidon2_B_40_3, poseidon2_B_41_0, poseidon2_B_41_1, poseidon2_B_41_2, poseidon2_B_41_3, poseidon2_B_42_0, poseidon2_B_42_1, poseidon2_B_42_2, poseidon2_B_42_3, poseidon2_B_43_0, poseidon2_B_43_1, poseidon2_B_43_2, poseidon2_B_43_3, poseidon2_B_44_0, poseidon2_B_44_1, poseidon2_B_44_2, poseidon2_B_44_3, poseidon2_B_45_0, poseidon2_B_45_1, poseidon2_B_45_2, poseidon2_B_45_3, poseidon2_B_46_0, poseidon2_B_46_1, poseidon2_B_46_2, poseidon2_B_46_3, poseidon2_B_47_0, poseidon2_B_47_1, poseidon2_B_47_2, poseidon2_B_47_3, poseidon2_B_48_0, poseidon2_B_48_1, poseidon2_B_48_2, poseidon2_B_48_3, poseidon2_B_49_0, poseidon2_B_49_1, poseidon2_B_49_2, poseidon2_B_49_3, poseidon2_B_4_0, poseidon2_B_4_1, poseidon2_B_4_2, poseidon2_B_4_3, poseidon2_B_50_0, poseidon2_B_50_1, poseidon2_B_50_2, poseidon2_B_50_3, poseidon2_B_51_0, poseidon2_B_51_1, poseidon2_B_51_2, poseidon2_B_51_3, poseidon2_B_52_0, poseidon2_B_52_1, poseidon2_B_52_2, poseidon2_B_52_3, poseidon2_B_53_0, poseidon2_B_53_1, poseidon2_B_53_2, poseidon2_B_53_3, poseidon2_B_54_0, poseidon2_B_54_1, poseidon2_B_54_2, poseidon2_B_54_3, poseidon2_B_55_0, poseidon2_B_55_1, poseidon2_B_55_2, poseidon2_B_55_3, poseidon2_B_56_0, poseidon2_B_56_1, poseidon2_B_56_2, poseidon2_B_56_3, poseidon2_B_57_0, poseidon2_B_57_1, poseidon2_B_57_2, poseidon2_B_57_3, poseidon2_B_58_0, poseidon2_B_58_1, poseidon2_B_58_2, poseidon2_B_58_3, poseidon2_B_59_0, poseidon2_B_59_1, poseidon2_B_59_2, poseidon2_B_59_3, poseidon2_B_5_0, poseidon2_B_5_1, poseidon2_B_5_2, poseidon2_B_5_3, poseidon2_B_6_0, poseidon2_B_6_1, poseidon2_B_6_2, poseidon2_B_6_3, poseidon2_B_7_0, poseidon2_B_7_1, poseidon2_B_7_2, poseidon2_B_7_3, poseidon2_B_8_0, poseidon2_B_8_1, poseidon2_B_8_2, poseidon2_B_8_3, poseidon2_B_9_0, poseidon2_B_9_1, poseidon2_B_9_2, poseidon2_B_9_3, poseidon2_EXT_LAYER_4, poseidon2_EXT_LAYER_5, poseidon2_EXT_LAYER_6, poseidon2_EXT_LAYER_7, poseidon2_T_0_4, poseidon2_T_0_5, poseidon2_T_0_6, poseidon2_T_0_7, poseidon2_T_1_4, poseidon2_T_1_5, poseidon2_T_1_6, poseidon2_T_1_7, poseidon2_T_2_4, poseidon2_T_2_5, poseidon2_T_2_6, poseidon2_T_2_7, poseidon2_T_3_4, poseidon2_T_3_5, poseidon2_T_3_6, poseidon2_T_3_7, poseidon2_T_60_4, poseidon2_T_60_5, poseidon2_T_60_6, poseidon2_T_60_7, poseidon2_T_61_4, poseidon2_T_61_5, poseidon2_T_61_6, poseidon2_T_61_7, poseidon2_T_62_4, poseidon2_T_62_5, poseidon2_T_62_6, poseidon2_T_62_7, poseidon2_T_63_4, poseidon2_T_63_5, poseidon2_T_63_6, poseidon2_T_63_7, poseidon2_a_0, poseidon2_a_1, poseidon2_a_2, poseidon2_a_3, poseidon2_b_0, poseidon2_b_1, poseidon2_b_2, poseidon2_b_3, poseidon2_clk, poseidon2_full_a_0, poseidon2_full_a_1, poseidon2_full_a_2, poseidon2_full_a_3, poseidon2_full_b_0, poseidon2_full_b_1, poseidon2_full_b_2, poseidon2_full_b_3, poseidon2_full_clk, poseidon2_full_end_poseidon, poseidon2_full_execute_poseidon_perm, poseidon2_full_input_0, poseidon2_full_input_1, poseidon2_full_input_2, poseidon2_full_input_len, poseidon2_full_num_perm_rounds_rem, poseidon2_full_num_perm_rounds_rem_inv, poseidon2_full_output, poseidon2_full_padding, poseidon2_full_sel_poseidon, poseidon2_full_start_poseidon, poseidon2_input_addr, poseidon2_mem_addr_read_a, poseidon2_mem_addr_read_b, poseidon2_mem_addr_read_c, poseidon2_mem_addr_read_d, poseidon2_mem_addr_write_a, poseidon2_mem_addr_write_b, poseidon2_mem_addr_write_c, poseidon2_mem_addr_write_d, poseidon2_output_addr, poseidon2_sel_poseidon_perm, poseidon2_sel_poseidon_perm_immediate, poseidon2_sel_poseidon_perm_mem_op, poseidon2_space_id, range_check_alu_rng_chk, range_check_clk, range_check_cmp_hi_bits_rng_chk, range_check_cmp_lo_bits_rng_chk, range_check_dyn_diff, range_check_dyn_rng_chk_bits, range_check_dyn_rng_chk_pow_2, range_check_gas_da_rng_chk, range_check_gas_l2_rng_chk, range_check_is_lte_u112, range_check_is_lte_u128, range_check_is_lte_u16, range_check_is_lte_u32, range_check_is_lte_u48, range_check_is_lte_u64, range_check_is_lte_u80, range_check_is_lte_u96, range_check_mem_rng_chk, range_check_rng_chk_bits, range_check_sel_lookup_0, range_check_sel_lookup_1, range_check_sel_lookup_2, range_check_sel_lookup_3, range_check_sel_lookup_4, range_check_sel_lookup_5, range_check_sel_lookup_6, range_check_sel_rng_chk, range_check_u16_r0, range_check_u16_r1, range_check_u16_r2, range_check_u16_r3, range_check_u16_r4, range_check_u16_r5, range_check_u16_r6, range_check_u16_r7, range_check_value, sha256_clk, sha256_input, sha256_output, sha256_sel_sha256_compression, sha256_state, slice_addr, slice_clk, slice_cnt, slice_col_offset, slice_one_min_inv, slice_sel_cd_cpy, slice_sel_mem_active, slice_sel_return, slice_sel_start, slice_space_id, slice_val, lookup_rng_chk_pow_2_counts, lookup_rng_chk_diff_counts, lookup_rng_chk_0_counts, lookup_rng_chk_1_counts, lookup_rng_chk_2_counts, lookup_rng_chk_3_counts, lookup_rng_chk_4_counts, lookup_rng_chk_5_counts, lookup_rng_chk_6_counts, lookup_rng_chk_7_counts, lookup_pow_2_0_counts, lookup_pow_2_1_counts, lookup_byte_lengths_counts, lookup_byte_operations_counts, lookup_opcode_gas_counts, kernel_output_lookup_counts, lookup_into_kernel_counts, lookup_cd_value_counts, lookup_ret_value_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts +#define WIRE_ENTITIES main_kernel_inputs, main_kernel_value_out, main_kernel_side_effect_out, main_kernel_metadata_out, main_calldata, main_returndata, alu_a_hi, alu_a_lo, alu_b_hi, alu_b_lo, alu_b_pow, alu_c_hi, alu_c_lo, alu_cf, alu_clk, alu_cmp_gadget_gt, alu_cmp_gadget_input_a, alu_cmp_gadget_input_b, alu_cmp_gadget_result, alu_cmp_gadget_sel, alu_ff_tag, alu_ia, alu_ib, alu_ic, alu_in_tag, alu_max_bits_sub_b_bits, alu_max_bits_sub_b_pow, alu_op_add, alu_op_cast, alu_op_div, alu_op_eq, alu_op_lt, alu_op_lte, alu_op_mul, alu_op_not, alu_op_shl, alu_op_shr, alu_op_sub, alu_partial_prod_hi, alu_partial_prod_lo, alu_range_check_input_value, alu_range_check_num_bits, alu_range_check_sel, alu_remainder, alu_sel_alu, alu_sel_cmp, alu_sel_shift_which, alu_u128_tag, alu_u16_tag, alu_u1_tag, alu_u32_tag, alu_u64_tag, alu_u8_tag, alu_zero_shift, binary_acc_ia, binary_acc_ib, binary_acc_ic, binary_clk, binary_ia_bytes, binary_ib_bytes, binary_ic_bytes, binary_in_tag, binary_mem_tag_ctr, binary_mem_tag_ctr_inv, binary_op_id, binary_sel_bin, binary_start, bytecode_end_latch, bytecode_length_remaining, bytecode_packed, bytecode_running_hash, cmp_a_hi, cmp_a_lo, cmp_b_hi, cmp_b_lo, cmp_borrow, cmp_clk, cmp_cmp_rng_ctr, cmp_input_a, cmp_input_b, cmp_op_eq, cmp_op_eq_diff_inv, cmp_op_gt, cmp_p_a_borrow, cmp_p_b_borrow, cmp_p_sub_a_hi, cmp_p_sub_a_lo, cmp_p_sub_b_hi, cmp_p_sub_b_lo, cmp_range_chk_clk, cmp_res_hi, cmp_res_lo, cmp_result, cmp_sel_cmp, cmp_sel_rng_chk, cmp_shift_sel, conversion_clk, conversion_input, conversion_num_limbs, conversion_output_bits, conversion_radix, conversion_sel_to_radix_le, keccakf1600_clk, keccakf1600_input, keccakf1600_output, keccakf1600_sel_keccakf1600, main_abs_da_rem_gas, main_abs_l2_rem_gas, main_alu_in_tag, main_base_da_gas_op_cost, main_base_l2_gas_op_cost, main_bin_op_id, main_call_ptr, main_da_gas_remaining, main_da_out_of_gas, main_dyn_da_gas_op_cost, main_dyn_gas_multiplier, main_dyn_l2_gas_op_cost, main_emit_l2_to_l1_msg_write_offset, main_emit_note_hash_write_offset, main_emit_nullifier_write_offset, main_emit_unencrypted_log_write_offset, main_ia, main_ib, main_ic, main_id, main_id_zero, main_ind_addr_a, main_ind_addr_b, main_ind_addr_c, main_ind_addr_d, main_internal_return_ptr, main_inv, main_is_fake_row, main_is_gas_accounted, main_kernel_in_offset, main_kernel_out_offset, main_l1_to_l2_msg_exists_write_offset, main_l2_gas_remaining, main_l2_out_of_gas, main_mem_addr_a, main_mem_addr_b, main_mem_addr_c, main_mem_addr_d, main_note_hash_exist_write_offset, main_nullifier_exists_write_offset, main_nullifier_non_exists_write_offset, main_op_err, main_opcode_val, main_pc, main_r_in_tag, main_rwa, main_rwb, main_rwc, main_rwd, main_sel_alu, main_sel_bin, main_sel_calldata, main_sel_execution_end, main_sel_execution_row, main_sel_kernel_inputs, main_sel_kernel_out, main_sel_mem_op_a, main_sel_mem_op_b, main_sel_mem_op_c, main_sel_mem_op_d, main_sel_mov_ia_to_ic, main_sel_mov_ib_to_ic, main_sel_op_add, main_sel_op_address, main_sel_op_and, main_sel_op_block_number, main_sel_op_calldata_copy, main_sel_op_cast, main_sel_op_chain_id, main_sel_op_dagasleft, main_sel_op_div, main_sel_op_ecadd, main_sel_op_emit_l2_to_l1_msg, main_sel_op_emit_note_hash, main_sel_op_emit_nullifier, main_sel_op_emit_unencrypted_log, main_sel_op_eq, main_sel_op_external_call, main_sel_op_external_return, main_sel_op_external_revert, main_sel_op_fdiv, main_sel_op_fee_per_da_gas, main_sel_op_fee_per_l2_gas, main_sel_op_function_selector, main_sel_op_get_contract_instance, main_sel_op_internal_call, main_sel_op_internal_return, main_sel_op_is_static_call, 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_msm, main_sel_op_mul, main_sel_op_not, main_sel_op_note_hash_exists, main_sel_op_nullifier_exists, main_sel_op_or, main_sel_op_poseidon2, main_sel_op_radix_le, main_sel_op_sender, main_sel_op_set, main_sel_op_sha256, main_sel_op_shl, main_sel_op_shr, main_sel_op_sload, main_sel_op_sstore, main_sel_op_static_call, main_sel_op_sub, main_sel_op_timestamp, main_sel_op_transaction_fee, main_sel_op_version, main_sel_op_xor, main_sel_q_kernel_lookup, main_sel_q_kernel_output_lookup, main_sel_resolve_ind_addr_a, main_sel_resolve_ind_addr_b, main_sel_resolve_ind_addr_c, main_sel_resolve_ind_addr_d, main_sel_returndata, main_sel_rng_16, main_sel_rng_8, main_sel_slice_gadget, main_side_effect_counter, main_sload_write_offset, main_space_id, main_sstore_write_offset, main_tag_err, main_w_in_tag, mem_addr, mem_clk, mem_diff, mem_glob_addr, mem_last, mem_lastAccess, mem_one_min_inv, mem_r_in_tag, mem_rw, mem_sel_mem, mem_sel_mov_ia_to_ic, mem_sel_mov_ib_to_ic, mem_sel_op_a, mem_sel_op_b, mem_sel_op_c, mem_sel_op_d, mem_sel_op_poseidon_read_a, mem_sel_op_poseidon_read_b, mem_sel_op_poseidon_read_c, mem_sel_op_poseidon_read_d, mem_sel_op_poseidon_write_a, mem_sel_op_poseidon_write_b, mem_sel_op_poseidon_write_c, mem_sel_op_poseidon_write_d, mem_sel_op_slice, mem_sel_resolve_ind_addr_a, mem_sel_resolve_ind_addr_b, mem_sel_resolve_ind_addr_c, mem_sel_resolve_ind_addr_d, mem_sel_rng_chk, mem_skip_check_tag, mem_space_id, mem_tag, mem_tag_err, mem_tsp, mem_val, mem_w_in_tag, poseidon2_B_10_0, poseidon2_B_10_1, poseidon2_B_10_2, poseidon2_B_10_3, poseidon2_B_11_0, poseidon2_B_11_1, poseidon2_B_11_2, poseidon2_B_11_3, poseidon2_B_12_0, poseidon2_B_12_1, poseidon2_B_12_2, poseidon2_B_12_3, poseidon2_B_13_0, poseidon2_B_13_1, poseidon2_B_13_2, poseidon2_B_13_3, poseidon2_B_14_0, poseidon2_B_14_1, poseidon2_B_14_2, poseidon2_B_14_3, poseidon2_B_15_0, poseidon2_B_15_1, poseidon2_B_15_2, poseidon2_B_15_3, poseidon2_B_16_0, poseidon2_B_16_1, poseidon2_B_16_2, poseidon2_B_16_3, poseidon2_B_17_0, poseidon2_B_17_1, poseidon2_B_17_2, poseidon2_B_17_3, poseidon2_B_18_0, poseidon2_B_18_1, poseidon2_B_18_2, poseidon2_B_18_3, poseidon2_B_19_0, poseidon2_B_19_1, poseidon2_B_19_2, poseidon2_B_19_3, poseidon2_B_20_0, poseidon2_B_20_1, poseidon2_B_20_2, poseidon2_B_20_3, poseidon2_B_21_0, poseidon2_B_21_1, poseidon2_B_21_2, poseidon2_B_21_3, poseidon2_B_22_0, poseidon2_B_22_1, poseidon2_B_22_2, poseidon2_B_22_3, poseidon2_B_23_0, poseidon2_B_23_1, poseidon2_B_23_2, poseidon2_B_23_3, poseidon2_B_24_0, poseidon2_B_24_1, poseidon2_B_24_2, poseidon2_B_24_3, poseidon2_B_25_0, poseidon2_B_25_1, poseidon2_B_25_2, poseidon2_B_25_3, poseidon2_B_26_0, poseidon2_B_26_1, poseidon2_B_26_2, poseidon2_B_26_3, poseidon2_B_27_0, poseidon2_B_27_1, poseidon2_B_27_2, poseidon2_B_27_3, poseidon2_B_28_0, poseidon2_B_28_1, poseidon2_B_28_2, poseidon2_B_28_3, poseidon2_B_29_0, poseidon2_B_29_1, poseidon2_B_29_2, poseidon2_B_29_3, poseidon2_B_30_0, poseidon2_B_30_1, poseidon2_B_30_2, poseidon2_B_30_3, poseidon2_B_31_0, poseidon2_B_31_1, poseidon2_B_31_2, poseidon2_B_31_3, poseidon2_B_32_0, poseidon2_B_32_1, poseidon2_B_32_2, poseidon2_B_32_3, poseidon2_B_33_0, poseidon2_B_33_1, poseidon2_B_33_2, poseidon2_B_33_3, poseidon2_B_34_0, poseidon2_B_34_1, poseidon2_B_34_2, poseidon2_B_34_3, poseidon2_B_35_0, poseidon2_B_35_1, poseidon2_B_35_2, poseidon2_B_35_3, poseidon2_B_36_0, poseidon2_B_36_1, poseidon2_B_36_2, poseidon2_B_36_3, poseidon2_B_37_0, poseidon2_B_37_1, poseidon2_B_37_2, poseidon2_B_37_3, poseidon2_B_38_0, poseidon2_B_38_1, poseidon2_B_38_2, poseidon2_B_38_3, poseidon2_B_39_0, poseidon2_B_39_1, poseidon2_B_39_2, poseidon2_B_39_3, poseidon2_B_40_0, poseidon2_B_40_1, poseidon2_B_40_2, poseidon2_B_40_3, poseidon2_B_41_0, poseidon2_B_41_1, poseidon2_B_41_2, poseidon2_B_41_3, poseidon2_B_42_0, poseidon2_B_42_1, poseidon2_B_42_2, poseidon2_B_42_3, poseidon2_B_43_0, poseidon2_B_43_1, poseidon2_B_43_2, poseidon2_B_43_3, poseidon2_B_44_0, poseidon2_B_44_1, poseidon2_B_44_2, poseidon2_B_44_3, poseidon2_B_45_0, poseidon2_B_45_1, poseidon2_B_45_2, poseidon2_B_45_3, poseidon2_B_46_0, poseidon2_B_46_1, poseidon2_B_46_2, poseidon2_B_46_3, poseidon2_B_47_0, poseidon2_B_47_1, poseidon2_B_47_2, poseidon2_B_47_3, poseidon2_B_48_0, poseidon2_B_48_1, poseidon2_B_48_2, poseidon2_B_48_3, poseidon2_B_49_0, poseidon2_B_49_1, poseidon2_B_49_2, poseidon2_B_49_3, poseidon2_B_4_0, poseidon2_B_4_1, poseidon2_B_4_2, poseidon2_B_4_3, poseidon2_B_50_0, poseidon2_B_50_1, poseidon2_B_50_2, poseidon2_B_50_3, poseidon2_B_51_0, poseidon2_B_51_1, poseidon2_B_51_2, poseidon2_B_51_3, poseidon2_B_52_0, poseidon2_B_52_1, poseidon2_B_52_2, poseidon2_B_52_3, poseidon2_B_53_0, poseidon2_B_53_1, poseidon2_B_53_2, poseidon2_B_53_3, poseidon2_B_54_0, poseidon2_B_54_1, poseidon2_B_54_2, poseidon2_B_54_3, poseidon2_B_55_0, poseidon2_B_55_1, poseidon2_B_55_2, poseidon2_B_55_3, poseidon2_B_56_0, poseidon2_B_56_1, poseidon2_B_56_2, poseidon2_B_56_3, poseidon2_B_57_0, poseidon2_B_57_1, poseidon2_B_57_2, poseidon2_B_57_3, poseidon2_B_58_0, poseidon2_B_58_1, poseidon2_B_58_2, poseidon2_B_58_3, poseidon2_B_59_0, poseidon2_B_59_1, poseidon2_B_59_2, poseidon2_B_59_3, poseidon2_B_5_0, poseidon2_B_5_1, poseidon2_B_5_2, poseidon2_B_5_3, poseidon2_B_6_0, poseidon2_B_6_1, poseidon2_B_6_2, poseidon2_B_6_3, poseidon2_B_7_0, poseidon2_B_7_1, poseidon2_B_7_2, poseidon2_B_7_3, poseidon2_B_8_0, poseidon2_B_8_1, poseidon2_B_8_2, poseidon2_B_8_3, poseidon2_B_9_0, poseidon2_B_9_1, poseidon2_B_9_2, poseidon2_B_9_3, poseidon2_EXT_LAYER_4, poseidon2_EXT_LAYER_5, poseidon2_EXT_LAYER_6, poseidon2_EXT_LAYER_7, poseidon2_T_0_4, poseidon2_T_0_5, poseidon2_T_0_6, poseidon2_T_0_7, poseidon2_T_1_4, poseidon2_T_1_5, poseidon2_T_1_6, poseidon2_T_1_7, poseidon2_T_2_4, poseidon2_T_2_5, poseidon2_T_2_6, poseidon2_T_2_7, poseidon2_T_3_4, poseidon2_T_3_5, poseidon2_T_3_6, poseidon2_T_3_7, poseidon2_T_60_4, poseidon2_T_60_5, poseidon2_T_60_6, poseidon2_T_60_7, poseidon2_T_61_4, poseidon2_T_61_5, poseidon2_T_61_6, poseidon2_T_61_7, poseidon2_T_62_4, poseidon2_T_62_5, poseidon2_T_62_6, poseidon2_T_62_7, poseidon2_T_63_4, poseidon2_T_63_5, poseidon2_T_63_6, poseidon2_T_63_7, poseidon2_a_0, poseidon2_a_1, poseidon2_a_2, poseidon2_a_3, poseidon2_b_0, poseidon2_b_1, poseidon2_b_2, poseidon2_b_3, poseidon2_clk, poseidon2_full_a_0, poseidon2_full_a_1, poseidon2_full_a_2, poseidon2_full_a_3, poseidon2_full_b_0, poseidon2_full_b_1, poseidon2_full_b_2, poseidon2_full_b_3, poseidon2_full_clk, poseidon2_full_end_poseidon, poseidon2_full_execute_poseidon_perm, poseidon2_full_input_0, poseidon2_full_input_1, poseidon2_full_input_2, poseidon2_full_input_len, poseidon2_full_num_perm_rounds_rem, poseidon2_full_num_perm_rounds_rem_inv, poseidon2_full_output, poseidon2_full_padding, poseidon2_full_sel_poseidon, poseidon2_full_start_poseidon, poseidon2_input_addr, poseidon2_mem_addr_read_a, poseidon2_mem_addr_read_b, poseidon2_mem_addr_read_c, poseidon2_mem_addr_read_d, poseidon2_mem_addr_write_a, poseidon2_mem_addr_write_b, poseidon2_mem_addr_write_c, poseidon2_mem_addr_write_d, poseidon2_output_addr, poseidon2_sel_poseidon_perm, poseidon2_sel_poseidon_perm_immediate, poseidon2_sel_poseidon_perm_mem_op, poseidon2_space_id, range_check_alu_rng_chk, range_check_clk, range_check_cmp_hi_bits_rng_chk, range_check_cmp_lo_bits_rng_chk, range_check_dyn_diff, range_check_dyn_rng_chk_bits, range_check_dyn_rng_chk_pow_2, range_check_gas_da_rng_chk, range_check_gas_l2_rng_chk, range_check_is_lte_u112, range_check_is_lte_u128, range_check_is_lte_u16, range_check_is_lte_u32, range_check_is_lte_u48, range_check_is_lte_u64, range_check_is_lte_u80, range_check_is_lte_u96, range_check_mem_rng_chk, range_check_rng_chk_bits, range_check_sel_lookup_0, range_check_sel_lookup_1, range_check_sel_lookup_2, range_check_sel_lookup_3, range_check_sel_lookup_4, range_check_sel_lookup_5, range_check_sel_lookup_6, range_check_sel_rng_chk, range_check_u16_r0, range_check_u16_r1, range_check_u16_r2, range_check_u16_r3, range_check_u16_r4, range_check_u16_r5, range_check_u16_r6, range_check_u16_r7, range_check_value, sha256_clk, sha256_input, sha256_output, sha256_sel_sha256_compression, sha256_state, slice_addr, slice_clk, slice_cnt, slice_col_offset, slice_one_min_inv, slice_sel_cd_cpy, slice_sel_mem_active, slice_sel_return, slice_sel_start, slice_space_id, slice_val, lookup_rng_chk_pow_2_counts, lookup_rng_chk_diff_counts, lookup_rng_chk_0_counts, lookup_rng_chk_1_counts, lookup_rng_chk_2_counts, lookup_rng_chk_3_counts, lookup_rng_chk_4_counts, lookup_rng_chk_5_counts, lookup_rng_chk_6_counts, lookup_rng_chk_7_counts, lookup_pow_2_0_counts, lookup_pow_2_1_counts, lookup_byte_lengths_counts, lookup_byte_operations_counts, lookup_opcode_gas_counts, kernel_output_lookup_counts, lookup_into_kernel_counts, lookup_cd_value_counts, lookup_ret_value_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts #define DERIVED_WITNESS_ENTITIES perm_rng_mem_inv, perm_rng_cmp_lo_inv, perm_rng_cmp_hi_inv, perm_rng_alu_inv, perm_cmp_alu_inv, perm_rng_gas_l2_inv, perm_rng_gas_da_inv, perm_l2_start_gas_inv, perm_da_start_gas_inv, perm_l2_end_gas_inv, perm_da_end_gas_inv, perm_pos_mem_read_a_inv, perm_pos_mem_read_b_inv, perm_pos_mem_read_c_inv, perm_pos_mem_read_d_inv, perm_pos_mem_write_a_inv, perm_pos_mem_write_b_inv, perm_pos_mem_write_c_inv, perm_pos_mem_write_d_inv, perm_pos2_fixed_pos2_perm_inv, perm_slice_mem_inv, perm_main_alu_inv, perm_main_bin_inv, perm_main_conv_inv, perm_main_sha256_inv, perm_main_pos2_perm_inv, perm_main_slice_inv, perm_main_mem_a_inv, perm_main_mem_b_inv, perm_main_mem_c_inv, perm_main_mem_d_inv, perm_main_mem_ind_addr_a_inv, perm_main_mem_ind_addr_b_inv, perm_main_mem_ind_addr_c_inv, perm_main_mem_ind_addr_d_inv, lookup_rng_chk_pow_2_inv, lookup_rng_chk_diff_inv, lookup_rng_chk_0_inv, lookup_rng_chk_1_inv, lookup_rng_chk_2_inv, lookup_rng_chk_3_inv, lookup_rng_chk_4_inv, lookup_rng_chk_5_inv, lookup_rng_chk_6_inv, lookup_rng_chk_7_inv, lookup_pow_2_0_inv, lookup_pow_2_1_inv, lookup_byte_lengths_inv, lookup_byte_operations_inv, lookup_opcode_gas_inv, kernel_output_lookup_inv, lookup_into_kernel_inv, lookup_cd_value_inv, lookup_ret_value_inv, incl_main_tag_err_inv, incl_mem_tag_err_inv #define SHIFTED_ENTITIES binary_acc_ia_shift, binary_acc_ib_shift, binary_acc_ic_shift, binary_mem_tag_ctr_shift, binary_op_id_shift, cmp_a_hi_shift, cmp_a_lo_shift, cmp_b_hi_shift, cmp_b_lo_shift, cmp_cmp_rng_ctr_shift, cmp_op_gt_shift, cmp_p_sub_a_hi_shift, cmp_p_sub_a_lo_shift, cmp_p_sub_b_hi_shift, cmp_p_sub_b_lo_shift, cmp_sel_rng_chk_shift, main_da_gas_remaining_shift, main_emit_l2_to_l1_msg_write_offset_shift, main_emit_note_hash_write_offset_shift, main_emit_nullifier_write_offset_shift, main_emit_unencrypted_log_write_offset_shift, main_internal_return_ptr_shift, main_l1_to_l2_msg_exists_write_offset_shift, main_l2_gas_remaining_shift, main_note_hash_exist_write_offset_shift, main_nullifier_exists_write_offset_shift, main_nullifier_non_exists_write_offset_shift, main_pc_shift, main_sel_execution_end_shift, main_sel_execution_row_shift, main_sload_write_offset_shift, main_sstore_write_offset_shift, mem_glob_addr_shift, mem_rw_shift, mem_sel_mem_shift, mem_tag_shift, mem_tsp_shift, mem_val_shift, poseidon2_full_a_0_shift, poseidon2_full_a_1_shift, poseidon2_full_a_2_shift, poseidon2_full_a_3_shift, poseidon2_full_execute_poseidon_perm_shift, poseidon2_full_input_0_shift, poseidon2_full_input_1_shift, poseidon2_full_input_2_shift, poseidon2_full_num_perm_rounds_rem_shift, poseidon2_full_sel_poseidon_shift, poseidon2_full_start_poseidon_shift, slice_addr_shift, slice_clk_shift, slice_cnt_shift, slice_col_offset_shift, slice_sel_cd_cpy_shift, slice_sel_mem_active_shift, slice_sel_return_shift, slice_sel_start_shift, slice_space_id_shift #define TO_BE_SHIFTED(e) e.binary_acc_ia, e.binary_acc_ib, e.binary_acc_ic, e.binary_mem_tag_ctr, e.binary_op_id, e.cmp_a_hi, e.cmp_a_lo, e.cmp_b_hi, e.cmp_b_lo, e.cmp_cmp_rng_ctr, e.cmp_op_gt, e.cmp_p_sub_a_hi, e.cmp_p_sub_a_lo, e.cmp_p_sub_b_hi, e.cmp_p_sub_b_lo, e.cmp_sel_rng_chk, e.main_da_gas_remaining, e.main_emit_l2_to_l1_msg_write_offset, e.main_emit_note_hash_write_offset, e.main_emit_nullifier_write_offset, e.main_emit_unencrypted_log_write_offset, e.main_internal_return_ptr, e.main_l1_to_l2_msg_exists_write_offset, e.main_l2_gas_remaining, e.main_note_hash_exist_write_offset, e.main_nullifier_exists_write_offset, e.main_nullifier_non_exists_write_offset, e.main_pc, e.main_sel_execution_end, e.main_sel_execution_row, e.main_sload_write_offset, e.main_sstore_write_offset, e.mem_glob_addr, e.mem_rw, e.mem_sel_mem, e.mem_tag, e.mem_tsp, e.mem_val, e.poseidon2_full_a_0, e.poseidon2_full_a_1, e.poseidon2_full_a_2, e.poseidon2_full_a_3, e.poseidon2_full_execute_poseidon_perm, e.poseidon2_full_input_0, e.poseidon2_full_input_1, e.poseidon2_full_input_2, e.poseidon2_full_num_perm_rounds_rem, e.poseidon2_full_sel_poseidon, e.poseidon2_full_start_poseidon, e.slice_addr, e.slice_clk, e.slice_cnt, e.slice_col_offset, e.slice_sel_cd_cpy, e.slice_sel_mem_active, e.slice_sel_return, e.slice_sel_start, e.slice_space_id @@ -124,12 +124,12 @@ class AvmFlavor { static constexpr bool HasZK = false; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 21; - static constexpr size_t NUM_WITNESS_ENTITIES = 705; + static constexpr size_t NUM_WITNESS_ENTITIES = 709; static constexpr size_t NUM_SHIFTED_ENTITIES = 58; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for // the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 784; + static constexpr size_t NUM_ALL_ENTITIES = 788; // The total number of witnesses including shifts and derived entities. static constexpr size_t NUM_ALL_WITNESS_ENTITIES = NUM_WITNESS_ENTITIES + NUM_SHIFTED_ENTITIES; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.cpp index f27062c3865..76c4e64bb98 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.cpp @@ -107,6 +107,10 @@ template std::vector AvmFullRow::names() "binary_op_id", "binary_sel_bin", "binary_start", + "bytecode_end_latch", + "bytecode_length_remaining", + "bytecode_packed", + "bytecode_running_hash", "cmp_a_hi", "cmp_a_lo", "cmp_b_hi", @@ -838,6 +842,10 @@ template RefVector AvmFullRow::as_vector() const binary_op_id, binary_sel_bin, binary_start, + bytecode_end_latch, + bytecode_length_remaining, + bytecode_packed, + bytecode_running_hash, cmp_a_hi, cmp_a_lo, cmp_b_hi, diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.hpp b/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.hpp index b2775561aac..68a3b8f4457 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/generated/full_row.hpp @@ -98,6 +98,10 @@ template struct AvmFullRow { FF binary_op_id{}; FF binary_sel_bin{}; FF binary_start{}; + FF bytecode_end_latch{}; + FF bytecode_length_remaining{}; + FF bytecode_packed{}; + FF bytecode_running_hash{}; FF cmp_a_hi{}; FF cmp_a_lo{}; FF cmp_b_hi{}; @@ -740,7 +744,7 @@ template struct AvmFullRow { RefVector as_vector() const; static std::vector names(); - static constexpr size_t SIZE = 726; + static constexpr size_t SIZE = 730; }; template std::ostream& operator<<(std::ostream& os, AvmFullRow const& row); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/tests/execution.test.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/tests/execution.test.cpp index 03cce00a6a8..52d87b837a7 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/tests/execution.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/tests/execution.test.cpp @@ -36,9 +36,13 @@ class AvmExecutionTests : public ::testing::Test { Execution::set_trace_builder_constructor([](VmPublicInputsNT public_inputs, ExecutionHints execution_hints, uint32_t side_effect_counter, - std::vector calldata) { - return AvmTraceBuilder( - std::move(public_inputs), std::move(execution_hints), side_effect_counter, std::move(calldata)) + std::vector calldata, + const std::vector>& all_contracts_bytecode) { + return AvmTraceBuilder(std::move(public_inputs), + std::move(execution_hints), + side_effect_counter, + std::move(calldata), + all_contracts_bytecode) .set_full_precomputed_tables(false) .set_range_check_required(false); }); @@ -62,10 +66,12 @@ class AvmExecutionTests : public ::testing::Test { * @param instructions A vector of the instructions to be executed. * @return The trace as a vector of Row. */ - std::vector gen_trace_from_instr(std::vector const& instructions) const + std::vector gen_trace_from_instr(std::vector bytecode) const { std::vector calldata{}; - return Execution::gen_trace(instructions, calldata, public_inputs_vec); + std::vector returndata{}; + + return Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); } void feed_output(uint32_t output_offset, FF const& value, FF const& side_effect_counter, FF const& metadata) @@ -121,7 +127,7 @@ TEST_F(AvmExecutionTests, basicAddReturn) Field(&Instruction::operands, ElementsAre(VariantWith(0), VariantWith(0), VariantWith(0))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); validate_trace(std::move(trace), public_inputs, {}, {}); } @@ -180,7 +186,7 @@ TEST_F(AvmExecutionTests, setAndSubOpcodes) VariantWith(51), VariantWith(1))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Find the first row enabling the subtraction selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_sub == 1; }); @@ -253,7 +259,7 @@ TEST_F(AvmExecutionTests, powerWithMulOpcodes) Field(&Instruction::operands, ElementsAre(VariantWith(0), VariantWith(0), VariantWith(0))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Find the first row enabling the multiplication selector and pc = 13 auto row = std::ranges::find_if( @@ -313,7 +319,7 @@ TEST_F(AvmExecutionTests, simpleInternalCall) // INTERNALRETURN EXPECT_EQ(instructions.at(5).op_code, OpCode::INTERNALRETURN); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Expected sequence of PCs during execution std::vector pc_sequence{ 0, 1, 4, 5, 2, 3 }; @@ -388,7 +394,7 @@ TEST_F(AvmExecutionTests, nestedInternalCalls) EXPECT_EQ(instructions.at(i).op_code, opcode_sequence.at(i)); } - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Expected sequence of PCs during execution std::vector pc_sequence{ 0, 1, 2, 8, 6, 7, 9, 10, 4, 5, 11, 3 }; @@ -468,7 +474,8 @@ TEST_F(AvmExecutionTests, jumpAndCalldatacopy) Field(&Instruction::operands, ElementsAre(VariantWith(5))))); std::vector returndata; - auto trace = Execution::gen_trace(instructions, returndata, std::vector{ 13, 156 }, public_inputs_vec); + auto trace = + Execution::gen_trace(bytecode, std::vector{ 13, 156 }, public_inputs_vec, returndata, ExecutionHints()); // Expected sequence of PCs during execution std::vector pc_sequence{ @@ -557,8 +564,10 @@ TEST_F(AvmExecutionTests, jumpiAndCalldatacopy) ElementsAre(VariantWith(0), VariantWith(6), VariantWith(10))))); std::vector returndata; - auto trace_jump = Execution::gen_trace(instructions, returndata, std::vector{ 9873123 }, public_inputs_vec); - auto trace_no_jump = Execution::gen_trace(instructions, returndata, std::vector{ 0 }, public_inputs_vec); + auto trace_jump = + Execution::gen_trace(bytecode, std::vector{ 9873123 }, public_inputs_vec, returndata, ExecutionHints()); + auto trace_no_jump = + Execution::gen_trace(bytecode, std::vector{ 0 }, public_inputs_vec, returndata, ExecutionHints()); // Expected sequence of PCs during execution with jump std::vector pc_sequence_jump{ 0, 1, 2, 3, 4, 6, 7 }; @@ -616,7 +625,7 @@ TEST_F(AvmExecutionTests, movOpcode) Field(&Instruction::operands, ElementsAre(VariantWith(0), VariantWith(171), VariantWith(33))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Find the first row enabling the MOV selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_mov == 1; }); @@ -664,7 +673,7 @@ TEST_F(AvmExecutionTests, indMovOpcode) Field(&Instruction::operands, ElementsAre(VariantWith(1), VariantWith(1), VariantWith(2))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Find the first row enabling the MOV selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_mov == 1; }); @@ -706,7 +715,7 @@ TEST_F(AvmExecutionTests, setAndCastOpcodes) VariantWith(17), VariantWith(18))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Find the first row enabling the cast selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_cast == 1; }); @@ -765,8 +774,8 @@ TEST_F(AvmExecutionTests, toRadixLeOpcode) // Assign a vector that we will mutate internally in gen_trace to store the return values; std::vector returndata; - auto trace = - Execution::gen_trace(instructions, returndata, std::vector{ FF::modulus - FF(1) }, public_inputs_vec); + auto trace = Execution::gen_trace( + bytecode, std::vector{ FF::modulus - FF(1) }, public_inputs_vec, returndata, ExecutionHints()); // Find the first row enabling the TORADIXLE selector // Expected output is bitwise decomposition of MODULUS - 1..could hardcode the result but it's a bit long @@ -831,8 +840,8 @@ TEST_F(AvmExecutionTests, toRadixLeOpcodeBitsMode) // Assign a vector that we will mutate internally in gen_trace to store the return values; std::vector returndata; - auto trace = - Execution::gen_trace(instructions, returndata, std::vector{ FF::modulus - FF(1) }, public_inputs_vec); + auto trace = Execution::gen_trace( + bytecode, std::vector{ FF::modulus - FF(1) }, public_inputs_vec, returndata, ExecutionHints()); // Find the first row enabling the TORADIXLE selector // Expected output is bitwise decomposition of MODULUS - 1..could hardcode the result but it's a bit long @@ -906,7 +915,7 @@ TEST_F(AvmExecutionTests, sha256CompressionOpcode) // 4091010797,3974542186]), std::vector expected_output = { 1862536192, 526086805, 2067405084, 593147560, 726610467, 813867028, 4091010797ULL, 3974542186ULL }; - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); EXPECT_EQ(returndata, expected_output); @@ -967,7 +976,7 @@ TEST_F(AvmExecutionTests, poseidon2PermutationOpCode) FF(std::string("0x018555a8eb50cf07f64b019ebaf3af3c925c93e631f3ecd455db07bbb52bbdd3")), FF(std::string("0x0cbea457c91c22c6c31fd89afd2541efc2edf31736b9f721e823b2165c90fd41")) }; - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); EXPECT_EQ(returndata, expected_output); @@ -1034,7 +1043,7 @@ TEST_F(AvmExecutionTests, keccakf1600OpCode) // Assign a vector that we will mutate internally in gen_trace to store the return values; std::vector calldata = std::vector(); std::vector returndata = std::vector(); - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); EXPECT_EQ(returndata, expected_output); @@ -1101,7 +1110,7 @@ TEST_F(AvmExecutionTests, embeddedCurveAddOpCode) // Assign a vector that we will mutate internally in gen_trace to store the return values; std::vector returndata; std::vector calldata = { a.x, a.y, FF(a_is_inf ? 1 : 0), b.x, b.y, FF(b_is_inf ? 1 : 0) }; - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); EXPECT_EQ(returndata, expected_output); @@ -1188,7 +1197,7 @@ TEST_F(AvmExecutionTests, msmOpCode) // Assign a vector that we will mutate internally in gen_trace to store the return values; std::vector returndata; - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); EXPECT_EQ(returndata, expected_output); @@ -1384,7 +1393,7 @@ TEST_F(AvmExecutionTests, kernelInputOpcodes) public_inputs_vec[FEE_PER_L2_GAS_PCPI_OFFSET] = feeperl2gas; std::vector returndata; - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); // Validate returndata EXPECT_EQ(returndata, expected_returndata); @@ -1477,7 +1486,7 @@ TEST_F(AvmExecutionTests, l2GasLeft) VariantWith(static_cast(EnvironmentVariable::L2GASLEFT)), VariantWith(17))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Find the first row enabling the L2GASLEFT selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_l2gasleft == 1; }); @@ -1521,7 +1530,7 @@ TEST_F(AvmExecutionTests, daGasLeft) VariantWith(static_cast(EnvironmentVariable::DAGASLEFT)), VariantWith(39))))); - auto trace = gen_trace_from_instr(instructions); + auto trace = gen_trace_from_instr(bytecode); // Find the first row enabling the DAGASLEFT selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_dagasleft == 1; }); @@ -1550,9 +1559,9 @@ TEST_F(AvmExecutionTests, ExecutorThrowsWithTooMuchGasAllocated) auto bytecode = hex_to_bytes(bytecode_hex); auto instructions = Deserialization::parse(bytecode); - EXPECT_THROW_WITH_MESSAGE( - Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec), - "Cannot allocate more than MAX_L2_GAS_PER_ENQUEUED_CALL to the AVM for execution of an enqueued call"); + EXPECT_THROW_WITH_MESSAGE(Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()), + "Cannot allocate more than MAX_L2_GAS_PER_ENQUEUED_CALL to the AVM for " + "execution of an enqueued call"); } // Should throw whenever the wrong number of public inputs are provided @@ -1569,7 +1578,7 @@ TEST_F(AvmExecutionTests, ExecutorThrowsWithIncorrectNumberOfPublicInputs) auto bytecode = hex_to_bytes(bytecode_hex); auto instructions = Deserialization::parse(bytecode); - EXPECT_THROW_WITH_MESSAGE(Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec), + EXPECT_THROW_WITH_MESSAGE(Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()), "Public inputs vector is not of PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH"); } @@ -1612,7 +1621,7 @@ TEST_F(AvmExecutionTests, kernelOutputEmitOpcodes) std::vector calldata = {}; std::vector returndata = {}; - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); // CHECK EMIT NOTE HASH // Check output data + side effect counters have been set correctly @@ -1713,7 +1722,7 @@ TEST_F(AvmExecutionTests, kernelOutputStorageLoadOpcodeSimple) // side effect counter 0 = value 42 auto execution_hints = ExecutionHints().with_storage_value_hints({ { 0, 42 } }); - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, execution_hints); // CHECK SLOAD // Check output data + side effect counters have been set correctly @@ -1767,7 +1776,7 @@ TEST_F(AvmExecutionTests, kernelOutputStorageStoreOpcodeSimple) std::vector returndata; - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, ExecutionHints()); // CHECK SSTORE auto sstore_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.main_sel_op_sstore == 1; }); EXPECT_EQ(sstore_row->main_ia, 42); // Read value @@ -1830,7 +1839,7 @@ TEST_F(AvmExecutionTests, kernelOutputStorageOpcodes) // side effect counter 0 = value 42 auto execution_hints = ExecutionHints().with_storage_value_hints({ { 0, 42 } }); - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, execution_hints); // CHECK SLOAD // Check output data + side effect counters have been set correctly @@ -1913,7 +1922,7 @@ TEST_F(AvmExecutionTests, kernelOutputHashExistsOpcodes) .with_storage_value_hints({ { 0, 1 }, { 1, 1 }, { 2, 1 } }) .with_note_hash_exists_hints({ { 0, 1 }, { 1, 1 }, { 2, 1 } }); - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, execution_hints); // CHECK NOTEHASHEXISTS auto note_hash_row = @@ -2047,9 +2056,10 @@ TEST_F(AvmExecutionTests, opCallOpcodes) .l2_gas_used = 0, .da_gas_used = 0, .end_side_effect_counter = 0, + .bytecode = {}, } }); - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, execution_hints); EXPECT_EQ(returndata, std::vector({ 9, 8, 1 })); // The 1 represents the success validate_trace(std::move(trace), public_inputs, calldata, returndata); @@ -2106,7 +2116,7 @@ TEST_F(AvmExecutionTests, opGetContractInstanceOpcodes) auto execution_hints = ExecutionHints().with_contract_instance_hints({ { address, { address, 1, 2, 3, 4, 5, public_keys_hints } } }); - auto trace = Execution::gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints); + auto trace = Execution::gen_trace(bytecode, calldata, public_inputs_vec, returndata, execution_hints); EXPECT_EQ(returndata, std::vector({ 1, 2, 3, 4, 5, returned_point.x })); // The first one represents true validate_trace(std::move(trace), public_inputs, calldata, returndata); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.cpp new file mode 100644 index 00000000000..82041e02871 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.cpp @@ -0,0 +1,66 @@ +#include "barretenberg/vm/avm/trace/bytecode_trace.hpp" +#include "barretenberg/crypto/poseidon2/poseidon2.hpp" +#include "barretenberg/crypto/poseidon2/poseidon2_params.hpp" + +namespace bb::avm_trace { +using poseidon2 = crypto::Poseidon2; +AvmBytecodeTraceBuilder::AvmBytecodeTraceBuilder(const std::vector>& all_contracts_bytecode) + : all_contracts_bytecode(all_contracts_bytecode) +{} + +std::vector AvmBytecodeTraceBuilder::pack_bytecode(const std::vector& contract_bytes) +{ + // To make from_buffer work properly, we need to make sure the contract is a multiple of 31 bytes + // Otherwise we will end up over-reading the buffer + size_t padding = 31 - (contract_bytes.size() % 31); + // We dont want to mutate the original contract bytes, since we will (probably) need them later in the trace + // unpadded + std::vector contract_bytes_padded = contract_bytes; + contract_bytes_padded.resize(contract_bytes_padded.size() + padding, 0); + std::vector contract_bytecode_fields; + for (size_t i = 0; i < contract_bytes_padded.size(); i += 31) { + uint256_t u256_elem = from_buffer(contract_bytes_padded, i); + // Drop the last byte + contract_bytecode_fields.emplace_back(u256_elem >> 8); + } + return contract_bytecode_fields; +} + +void AvmBytecodeTraceBuilder::build_bytecode_columns() +{ + // This is the main loop that will generate the bytecode trace + for (auto& contract_bytecode : all_contracts_bytecode) { + FF running_hash = FF::zero(); + auto packed_bytecode = pack_bytecode(contract_bytecode); + // This size is already based on the number of fields + for (size_t i = 0; i < packed_bytecode.size(); ++i) { + bytecode_trace.push_back(BytecodeTraceEntry{ + .packed_bytecode = packed_bytecode[i], + .running_hash = running_hash, + .bytecode_length_remaining = static_cast(packed_bytecode.size() - i), + }); + running_hash = poseidon2::hash({ packed_bytecode[i], running_hash }); + } + // Now running_hash actually contains the bytecode hash + BytecodeTraceEntry last_entry; + last_entry.running_hash = running_hash; + last_entry.bytecode_length_remaining = 0; + // TODO: Come back to this later + // last_entry.class_id = _ + // last_entry.contract_address = _ + } +} + +void AvmBytecodeTraceBuilder::finalize(std::vector>& main_trace) +{ + for (size_t i = 0; i < bytecode_trace.size(); i++) { + auto const& src = bytecode_trace.at(i); + auto& dest = main_trace.at(i); + dest.bytecode_running_hash = src.running_hash; + dest.bytecode_length_remaining = src.bytecode_length_remaining; + dest.bytecode_packed = src.packed_bytecode; + dest.bytecode_end_latch = src.bytecode_length_remaining == 0 ? FF::one() : FF::zero(); + } +} + +} // namespace bb::avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.hpp new file mode 100644 index 00000000000..a62784fe59e --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm/trace/bytecode_trace.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include + +#include "barretenberg/vm/avm/trace/common.hpp" +#include "barretenberg/vm/avm/trace/execution_hints.hpp" +namespace bb::avm_trace { + +class AvmBytecodeTraceBuilder { + public: + struct BytecodeTraceEntry { + // The field packed bytecode + FF packed_bytecode{}; + // Calculate the bytecode hash + FF running_hash{}; + // This is the length in fields, not bytes - max 3000 fields + uint16_t bytecode_length_remaining = 0; + + // Derive the class Id + FF class_id{}; + + // Derive the contract address + FF contract_address{}; + }; + AvmBytecodeTraceBuilder() = default; + // These interfaces will change when we start feeding in more inputs and hints + AvmBytecodeTraceBuilder(const std::vector>& all_contracts_bytecode); + + size_t size() const { return bytecode_trace.size(); } + void reset(); + void finalize(std::vector>& main_trace); + + void build_bytecode_columns(); + + private: + // Converts the bytecode into field elements (chunks of 31 bytes) + static std::vector pack_bytecode(const std::vector& contract_bytes); + + std::vector bytecode_trace; + // The first element is the main top-level contract, the rest are external calls + std::vector> all_contracts_bytecode; + // TODO: Come back to this + // VmPublicInputs public_inputs; + // ExecutionHints hints; +}; +} // namespace bb::avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.cpp index 0c276efe07d..b3edc6f5826 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.cpp @@ -146,13 +146,18 @@ void show_trace_info(const auto& trace) } // namespace // Needed for dependency injection in tests. -Execution::TraceBuilderConstructor Execution::trace_builder_constructor = [](VmPublicInputs public_inputs, - ExecutionHints execution_hints, - uint32_t side_effect_counter, - std::vector calldata) { - return AvmTraceBuilder( - std::move(public_inputs), std::move(execution_hints), side_effect_counter, std::move(calldata)); -}; +Execution::TraceBuilderConstructor Execution::trace_builder_constructor = + [](VmPublicInputs public_inputs, + ExecutionHints execution_hints, + uint32_t side_effect_counter, + std::vector calldata, + std::vector> all_contract_bytecode) { + return AvmTraceBuilder(std::move(public_inputs), + std::move(execution_hints), + side_effect_counter, + std::move(calldata), + all_contract_bytecode); + }; /** * @brief Temporary routine to generate default public inputs (gas values) until we get @@ -184,12 +189,9 @@ std::tuple Execution::prove(std::vector returndata; std::vector trace = AVM_TRACK_TIME_V( - "prove/gen_trace", gen_trace(instructions, returndata, calldata, public_inputs_vec, execution_hints)); + "prove/gen_trace", gen_trace(bytecode, calldata, public_inputs_vec, returndata, execution_hints)); if (!avm_dump_trace_path.empty()) { info("Dumping trace as CSV to: " + avm_dump_trace_path.string()); dump_trace_as_csv(trace, avm_dump_trace_path); @@ -252,27 +254,12 @@ bool Execution::verify(AvmFlavor::VerificationKey vk, HonkProof const& proof) std::copy(returndata_offset, raw_proof_offset, std::back_inserter(returndata)); std::copy(raw_proof_offset, proof.end(), std::back_inserter(raw_proof)); - VmPublicInputs public_inputs = convert_public_inputs(public_inputs_vec); + VmPublicInputs public_inputs = avm_trace::convert_public_inputs(public_inputs_vec); std::vector> public_inputs_columns = copy_public_inputs_columns(public_inputs, calldata, returndata); return verifier.verify_proof(raw_proof, public_inputs_columns); } -/** - * @brief Generate the execution trace pertaining to the supplied instructions. - * - * @param instructions A vector of the instructions to be executed. - * @param calldata expressed as a vector of finite field elements. - * @return The trace as a vector of Row. - */ -std::vector Execution::gen_trace(std::vector const& instructions, - std::vector const& calldata, - std::vector const& public_inputs_vec) -{ - std::vector returndata{}; - return gen_trace(instructions, returndata, calldata, public_inputs_vec); -} - /** * @brief Generate the execution trace pertaining to the supplied instructions returns the return data. * @@ -281,23 +268,31 @@ std::vector Execution::gen_trace(std::vector const& instructio * @param public_inputs expressed as a vector of finite field elements. * @return The trace as a vector of Row. */ -std::vector Execution::gen_trace(std::vector const& instructions, - std::vector& returndata, +std::vector Execution::gen_trace(std::vector const& bytecode, std::vector const& calldata, std::vector const& public_inputs_vec, + std::vector& returndata, ExecutionHints const& execution_hints) { + std::vector instructions = Deserialization::parse(bytecode); + vinfo("Deserialized " + std::to_string(instructions.size()) + " instructions"); vinfo("------- GENERATING TRACE -------"); // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6718): construction of the public input columns // should be done in the kernel - this is stubbed and underconstrained - VmPublicInputs public_inputs = convert_public_inputs(public_inputs_vec); + VmPublicInputs public_inputs = avm_trace::convert_public_inputs(public_inputs_vec); uint32_t start_side_effect_counter = !public_inputs_vec.empty() ? static_cast(public_inputs_vec[START_SIDE_EFFECT_COUNTER_PCPI_OFFSET]) : 0; - - AvmTraceBuilder trace_builder = - Execution::trace_builder_constructor(public_inputs, execution_hints, start_side_effect_counter, calldata); + std::vector> all_contract_bytecode; + all_contract_bytecode.reserve(execution_hints.externalcall_hints.size() + 1); + // Start with the main, top-level contract bytecode + all_contract_bytecode.push_back(bytecode); + for (const auto& externalcall_hint : execution_hints.externalcall_hints) { + all_contract_bytecode.emplace_back(externalcall_hint.bytecode); + } + AvmTraceBuilder trace_builder = Execution::trace_builder_constructor( + public_inputs, execution_hints, start_side_effect_counter, calldata, all_contract_bytecode); // Copied version of pc maintained in trace builder. The value of pc is evolving based // on opcode logic and therefore is not maintained here. However, the next opcode in the execution @@ -307,8 +302,6 @@ std::vector Execution::gen_trace(std::vector const& instructio auto inst = instructions.at(pc); debug("[@" + std::to_string(pc) + "] " + inst.to_string()); - // TODO: We do not yet support the indirect flag. Therefore we do not extract - // inst.operands(0) (i.e. the indirect flag) when processiing the instructions. switch (inst.op_code) { // Compute // Compute - Arithmetic @@ -750,6 +743,7 @@ std::vector Execution::gen_trace(std::vector const& instructio } auto trace = trace_builder.finalize(); + show_trace_info(trace); return trace; } diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.hpp b/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.hpp index 17f696e6043..da222b87f67 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution.hpp @@ -15,27 +15,25 @@ namespace bb::avm_trace { class Execution { public: static constexpr size_t SRS_SIZE = 1 << 22; - using TraceBuilderConstructor = std::function calldata)>; + using TraceBuilderConstructor = + std::function calldata, + const std::vector>& all_contract_bytecode)>; Execution() = default; static std::vector getDefaultPublicInputs(); - // TODO: Clean these overloaded functions. We probably need less and confusing overloading. - static std::vector gen_trace(std::vector const& instructions, - std::vector& returndata, - std::vector const& calldata, - std::vector const& public_inputs, - ExecutionHints const& execution_hints = {}); - static std::vector gen_trace(std::vector const& instructions, - std::vector const& calldata = {}, - std::vector const& public_inputs = {}); - static std::vector gen_trace(std::vector const& instructions, + static VmPublicInputs convert_public_inputs(std::vector const& public_inputs_vec); + + // Bytecode is currently the bytecode of the top-level function call + // Eventually this will be the bytecode of the dispatch function of top-level contract + static std::vector gen_trace(std::vector const& bytecode, std::vector const& calldata, std::vector const& public_inputs, + std::vector& returndata, ExecutionHints const& execution_hints); // For testing purposes only. diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution_hints.hpp b/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution_hints.hpp index 1183c99576e..0b3065982d1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution_hints.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/trace/execution_hints.hpp @@ -14,6 +14,7 @@ struct ExternalCallHint { uint32_t l2_gas_used; uint32_t da_gas_used; FF end_side_effect_counter; + std::vector bytecode; }; // Add support for deserialization of ExternalCallHint. This is implicitly used by serialize::read @@ -26,6 +27,7 @@ inline void read(uint8_t const*& it, ExternalCallHint& hint) read(it, hint.da_gas_used); read(it, hint.l2_gas_used); read(it, hint.end_side_effect_counter); + read(it, hint.bytecode); } struct PublicKeysHint { diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.cpp index e7133c81dbb..26b321810aa 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.cpp @@ -21,6 +21,7 @@ #include "barretenberg/polynomials/univariate.hpp" #include "barretenberg/vm/avm/generated/full_row.hpp" #include "barretenberg/vm/avm/trace/addressing_mode.hpp" +#include "barretenberg/vm/avm/trace/bytecode_trace.hpp" #include "barretenberg/vm/avm/trace/common.hpp" #include "barretenberg/vm/avm/trace/fixed_bytes.hpp" #include "barretenberg/vm/avm/trace/fixed_gas.hpp" @@ -260,12 +261,14 @@ void AvmTraceBuilder::finalise_mem_trace_lookup_counts() AvmTraceBuilder::AvmTraceBuilder(VmPublicInputs public_inputs, ExecutionHints execution_hints_, uint32_t side_effect_counter, - std::vector calldata) + std::vector calldata, + const std::vector>& all_contract_bytecode) // NOTE: we initialise the environment builder here as it requires public inputs : calldata(std::move(calldata)) , side_effect_counter(side_effect_counter) , execution_hints(std::move(execution_hints_)) , kernel_trace_builder(side_effect_counter, public_inputs, execution_hints) + , bytecode_trace_builder(all_contract_bytecode) { // TODO: think about cast gas_trace_builder.set_initial_gas( @@ -2449,12 +2452,12 @@ void AvmTraceBuilder::op_emit_unencrypted_log(uint8_t indirect, // Truncate the hash to 31 bytes so it will be a valid field element FF trunc_hash = FF(from_buffer(output.data()) >> 8); - // The + 32 here is for the contract_address in bytes, the +4 is for the extra 4 bytes that contain log_size and is - // prefixed to message see toBuffer in unencrypted_l2_log.ts + // The + 32 here is for the contract_address in bytes, the +4 is for the extra 4 bytes that contain log_size and + // is prefixed to message see toBuffer in unencrypted_l2_log.ts FF length_of_preimage = num_bytes + 32 + 4; // The + 4 is because the kernels store the length of the - // processed log as 4 bytes; thus for this length value to match the log length stored in the kernels, we need to - // add four to the length here. [Copied from unencrypted_l2_log.ts] + // processed log as 4 bytes; thus for this length value to match the log length stored in the kernels, we need + // to add four to the length here. [Copied from unencrypted_l2_log.ts] FF metadata_log_length = length_of_preimage + 4; Row row = Row{ .main_clk = clk, @@ -3510,6 +3513,18 @@ std::vector AvmTraceBuilder::finalize() kernel_trace_builder.finalize(main_trace); + /********************************************************************************************** + * BYTECODE TRACE INCLUSION + **********************************************************************************************/ + + bytecode_trace_builder.build_bytecode_columns(); + // Should not have to resize in the future, but for now we do + if (bytecode_trace_builder.size() > main_trace_size) { + main_trace_size = bytecode_trace_builder.size(); + main_trace.resize(main_trace_size); + } + bytecode_trace_builder.finalize(main_trace); + /********************************************************************************************** * ONLY FIXED TABLES FROM HERE ON **********************************************************************************************/ @@ -3595,7 +3610,8 @@ std::vector AvmTraceBuilder::finalize() } } // In case the range entries are larger than the main trace, we need to resize the main trace - // Normally this would happen at the start of finalize, but we cannot finalize the range checks until after gas :( + // Normally this would happen at the start of finalize, but we cannot finalize the range checks until after gas + // :( if (range_entries.size() > new_trace_size) { main_trace.resize(range_entries.size(), {}); new_trace_size = range_entries.size(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.hpp index 9380c36846e..3113dd58b4a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm/trace/trace.hpp @@ -3,6 +3,7 @@ #include "barretenberg/vm/avm/trace/addressing_mode.hpp" #include "barretenberg/vm/avm/trace/alu_trace.hpp" #include "barretenberg/vm/avm/trace/binary_trace.hpp" +#include "barretenberg/vm/avm/trace/bytecode_trace.hpp" #include "barretenberg/vm/avm/trace/common.hpp" #include "barretenberg/vm/avm/trace/execution_hints.hpp" #include "barretenberg/vm/avm/trace/gadgets/conversion_trace.hpp" @@ -32,7 +33,8 @@ class AvmTraceBuilder { AvmTraceBuilder(VmPublicInputs public_inputs = {}, ExecutionHints execution_hints = {}, uint32_t side_effect_counter = 0, - std::vector calldata = {}); + std::vector calldata = {}, + const std::vector>& all_contract_bytecode = {}); uint32_t getPc() const { return pc; } @@ -218,6 +220,7 @@ class AvmTraceBuilder { AvmEccTraceBuilder ecc_trace_builder; AvmSliceTraceBuilder slice_trace_builder; AvmRangeCheckBuilder range_check_builder; + AvmBytecodeTraceBuilder bytecode_trace_builder; Row create_kernel_lookup_opcode(uint8_t indirect, uint32_t dst_offset, FF value, AvmMemoryTag w_tag); diff --git a/barretenberg/cpp/src/barretenberg/vm/aztec_constants.hpp b/barretenberg/cpp/src/barretenberg/vm/aztec_constants.hpp index 905e0ab1231..9e0746ab7c0 100644 --- a/barretenberg/cpp/src/barretenberg/vm/aztec_constants.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/aztec_constants.hpp @@ -12,6 +12,7 @@ #define MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL 16 #define MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL 16 #define MAX_UNENCRYPTED_LOGS_PER_CALL 4 +#define MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS 3000 #define MAX_L2_GAS_PER_ENQUEUED_CALL 6000000 #define AZTEC_ADDRESS_LENGTH 1 #define GAS_FEES_LENGTH 2 @@ -35,7 +36,7 @@ #define PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH 674 #define PUBLIC_CONTEXT_INPUTS_LENGTH 41 #define AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS 86 -#define AVM_PROOF_LENGTH_IN_FIELDS 3973 +#define AVM_PROOF_LENGTH_IN_FIELDS 3993 #define AVM_PUBLIC_COLUMN_MAX_SIZE 1024 #define AVM_PUBLIC_INPUTS_FLATTENED_SIZE 2722 #define MEM_TAG_FF 0 diff --git a/docs/docs/protocol-specs/contract-deployment/classes.md b/docs/docs/protocol-specs/contract-deployment/classes.md index d5da5e24d50..47a244707c1 100644 --- a/docs/docs/protocol-specs/contract-deployment/classes.md +++ b/docs/docs/protocol-specs/contract-deployment/classes.md @@ -12,7 +12,7 @@ Read the following discussions for additional context: - [Abstracting contract deployment](https://forum.aztec.network/t/proposal-abstracting-contract-deployment/2576) - [Implementing contract upgrades](https://forum.aztec.network/t/implementing-contract-upgrades/2570) - [Contract classes, upgrades, and default accounts](https://forum.aztec.network/t/contract-classes-upgrades-and-default-accounts/433) - + ::: ## `ContractClass` @@ -351,7 +351,7 @@ It is strongly recommended for developers registering new classes to broadcast t The `register`, `broadcast_unconstrained_function`, and `broadcast_private_function` functions all receive and emit variable-length bytecode in unencrypted events. In every function, bytecode is encoded in a fixed-length array of field elements, which sets a maximum length for each: -- `MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS`: 32000 field elements, used for a contract's public bytecode in the `register` function. +- `MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS`: 3000 field elements, used for a contract's public bytecode in the `register` function. - `MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS`: 3000 field elements, used for the ACIR and Brillig bytecode of a broadcasted private function in `broadcast_private_function`. - `MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS`: 3000 field elements, used for the Brillig bytecode of a broadcasted unconstrained function in `broadcast_unconstrained_function`. diff --git a/l1-contracts/src/core/libraries/ConstantsGen.sol b/l1-contracts/src/core/libraries/ConstantsGen.sol index b2146dd56d0..bddd1f821a7 100644 --- a/l1-contracts/src/core/libraries/ConstantsGen.sol +++ b/l1-contracts/src/core/libraries/ConstantsGen.sol @@ -104,7 +104,7 @@ library Constants { 8142738430000951296386584486068033372964809139261822027365426310856631083550; uint256 internal constant FEE_JUICE_INITIAL_MINT = 20000000000; uint256 internal constant PUBLIC_DISPATCH_SELECTOR = 3578010381; - uint256 internal constant MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 20000; + uint256 internal constant MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 3000; uint256 internal constant MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS = 3000; uint256 internal constant MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS = 3000; uint256 internal constant REGISTERER_PRIVATE_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS = 19; diff --git a/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr b/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr index f268b7d3318..58122d06881 100644 --- a/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr +++ b/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr @@ -34,6 +34,7 @@ contract ContractClassRegisterer { // docs:start:import_pop_capsule use crate::capsule::pop_capsule; + // docs:end:import_pop_capsule #[private] @@ -43,11 +44,35 @@ contract ContractClassRegisterer { public_bytecode_commitment: Field, ) { // TODO: Validate public_bytecode_commitment is the correct commitment of packed_public_bytecode - // TODO: Validate packed_public_bytecode is legit public bytecode + // TODO: We should be able to remove public_bytecode_commitment from the input if it's calculated in this function // docs:start:pop_capsule let packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS] = pop_capsule(); // docs:end:pop_capsule + // First field element contains the length of the bytecode + let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32; + let bytecode_length_in_fields: u32 = + (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32; + assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS); + + let mut computed_public_bytecode_commitment = 0; + // We can hash up to MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1, since the first element is the length + for i in 0..(MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1) { + // While we are forced to run the hash MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS times in the circuit, + // we want the bytecode commitment to be based on the actual length + if (i < bytecode_length_in_fields) { + // We skip the first element when hashing since it is the length + computed_public_bytecode_commitment = std::hash::poseidon2::Poseidon2::hash( + [packed_public_bytecode[i + 1], computed_public_bytecode_commitment], + 2, + ); + } else { + // Any bytes after the bytecode length must be 0 + assert_eq(packed_public_bytecode[i + 1], 0); + } + } + assert_eq(computed_public_bytecode_commitment, public_bytecode_commitment); + // Compute contract class id from preimage let contract_class_id = ContractClassId::compute( artifact_hash, diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr index 2ba9a28ba67..7a6d5ed32df 100644 --- a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr +++ b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr @@ -153,7 +153,7 @@ global FEE_JUICE_INITIAL_MINT: Field = 20000000000; global PUBLIC_DISPATCH_SELECTOR: Field = 0xd5441b0d; // CONTRACT CLASS CONSTANTS -global MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS: u32 = 20000; +global MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS: u32 = 3000; // Bytecode size for private functions is per function, not for the entire contract. // Note that private functions bytecode includes a mix of acir and brillig. global MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS: u32 = 3000; @@ -491,7 +491,7 @@ global AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS: u32 = 2 + 21 * 4; // `AVM_PROOF_LENGTH_IN_FIELDS` must be updated when AVM circuit changes. // To determine latest value, hover `COMPUTED_AVM_PROOF_LENGTH_IN_FIELDS` // in barretenberg/cpp/src/barretenberg/vm/avm/generated/flavor.hpp -global AVM_PROOF_LENGTH_IN_FIELDS: u32 = 3973; +global AVM_PROOF_LENGTH_IN_FIELDS: u32 = 3993; global AVM_PUBLIC_COLUMN_MAX_SIZE: u32 = 1024; global AVM_PUBLIC_INPUTS_FLATTENED_SIZE: u32 = 2 * AVM_PUBLIC_COLUMN_MAX_SIZE + PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH; diff --git a/yarn-project/circuits.js/src/constants.gen.ts b/yarn-project/circuits.js/src/constants.gen.ts index 85d68fbe58c..7c7dde12b1c 100644 --- a/yarn-project/circuits.js/src/constants.gen.ts +++ b/yarn-project/circuits.js/src/constants.gen.ts @@ -89,7 +89,7 @@ export const AZTEC_EPOCH_PROOF_CLAIM_WINDOW_IN_L2_SLOTS = 13; export const GENESIS_ARCHIVE_ROOT = 8142738430000951296386584486068033372964809139261822027365426310856631083550n; export const FEE_JUICE_INITIAL_MINT = 20000000000; export const PUBLIC_DISPATCH_SELECTOR = 3578010381; -export const MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 20000; +export const MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 3000; export const MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS = 3000; export const MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS = 3000; export const REGISTERER_PRIVATE_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS = 19; @@ -224,7 +224,7 @@ export const TUBE_PROOF_LENGTH = 463; export const HONK_VERIFICATION_KEY_LENGTH_IN_FIELDS = 128; export const CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS = 145; export const AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS = 86; -export const AVM_PROOF_LENGTH_IN_FIELDS = 3973; +export const AVM_PROOF_LENGTH_IN_FIELDS = 3993; export const AVM_PUBLIC_COLUMN_MAX_SIZE = 1024; export const AVM_PUBLIC_INPUTS_FLATTENED_SIZE = 2722; export const MEM_TAG_FF = 0; diff --git a/yarn-project/circuits.js/src/contract/contract_class_id.test.ts b/yarn-project/circuits.js/src/contract/contract_class_id.test.ts index 919211008d2..29abd4adc68 100644 --- a/yarn-project/circuits.js/src/contract/contract_class_id.test.ts +++ b/yarn-project/circuits.js/src/contract/contract_class_id.test.ts @@ -25,7 +25,7 @@ describe('ContractClass', () => { }; expect(computeContractClassId(contractClass).toString()).toMatchInlineSnapshot( - `"0x174bf0daff21f2b8b88f7d2b7ef7ed6a7b083c979a2996a4e78963ad4b84ff8d"`, + `"0x2d5c712c483891d42e5bca539e8516fc52b5b024568ac71e4fe47c0c0157f851"`, ); }); }); diff --git a/yarn-project/circuits.js/src/contract/contract_class_id.ts b/yarn-project/circuits.js/src/contract/contract_class_id.ts index 07d812c8af4..935e0c5b6e3 100644 --- a/yarn-project/circuits.js/src/contract/contract_class_id.ts +++ b/yarn-project/circuits.js/src/contract/contract_class_id.ts @@ -1,7 +1,10 @@ -import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto'; +import { bufferAsFields } from '@aztec/foundation/abi'; +import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto'; import { Fr } from '@aztec/foundation/fields'; -import { GeneratorIndex } from '../constants.gen.js'; +import { strict as assert } from 'assert'; + +import { GeneratorIndex, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } from '../constants.gen.js'; import { type ContractClass } from './interfaces/contract_class.js'; import { computePrivateFunctionsRoot } from './private_function.js'; @@ -56,8 +59,17 @@ export type ContractClassIdPreimage = { publicBytecodeCommitment: Fr; }; -// TODO(#5860): Replace with actual implementation -// Changed to work with canonical contracts that may have non-deterministic noir compiles and we want to keep the address constant -export function computePublicBytecodeCommitment(_bytecode: Buffer) { - return new Fr(5); +export function computePublicBytecodeCommitment(packedBytecode: Buffer) { + // Encode the buffer into field elements (chunked into 31 bytes each) + const encodedBytecode: Fr[] = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS); + // The first element is the length of the bytecode (in bytes) + const bytecodeLength = Math.ceil(encodedBytecode[0].toNumber() / (Fr.SIZE_IN_BYTES - 1)); + assert(bytecodeLength < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, 'Bytecode exceeds maximum deployable size'); + + let bytecodeCommitment = new Fr(0); + for (let i = 0; i < bytecodeLength; i++) { + // We skip the first element, which is the length of the bytecode + bytecodeCommitment = poseidon2Hash([encodedBytecode[i + 1], bytecodeCommitment]); + } + return bytecodeCommitment; } diff --git a/yarn-project/circuits.js/src/contract/events/contract_class_registered_event.test.ts b/yarn-project/circuits.js/src/contract/events/contract_class_registered_event.test.ts index 4fec2f49d4a..77d9e760fae 100644 --- a/yarn-project/circuits.js/src/contract/events/contract_class_registered_event.test.ts +++ b/yarn-project/circuits.js/src/contract/events/contract_class_registered_event.test.ts @@ -11,9 +11,8 @@ describe('ContractClassRegisteredEvent', () => { ); expect(event.artifactHash.toString()).toEqual('0x072dce903b1a299d6820eeed695480fe9ec46658b1101885816aed6dd86037f0'); expect(event.packedPublicBytecode.length).toEqual(27090); - // TODO: #5860 expect(computePublicBytecodeCommitment(event.packedPublicBytecode).toString()).toEqual( - '0x0000000000000000000000000000000000000000000000000000000000000005', + '0x0378491b34825cd67d1e13e140bbc80f2cd3a9b52171ea577f8f11620d4198ba', ); }); }); diff --git a/yarn-project/circuits.js/src/scripts/constants.in.ts b/yarn-project/circuits.js/src/scripts/constants.in.ts index a306bf93546..b5af3fcc576 100644 --- a/yarn-project/circuits.js/src/scripts/constants.in.ts +++ b/yarn-project/circuits.js/src/scripts/constants.in.ts @@ -78,6 +78,7 @@ const CPP_CONSTANTS = [ 'MEM_TAG_U128', 'MEM_TAG_FF', 'MAX_L2_GAS_PER_ENQUEUED_CALL', + 'MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS', ]; const CPP_GENERATORS: string[] = []; @@ -126,6 +127,7 @@ const PIL_CONSTANTS = [ 'MEM_TAG_U64', 'MEM_TAG_U128', 'MEM_TAG_FF', + 'MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS', ]; /** diff --git a/yarn-project/circuits.js/src/structs/avm/avm.ts b/yarn-project/circuits.js/src/structs/avm/avm.ts index 38a22f2647d..a53226c429d 100644 --- a/yarn-project/circuits.js/src/structs/avm/avm.ts +++ b/yarn-project/circuits.js/src/structs/avm/avm.ts @@ -82,12 +82,14 @@ export class AvmExternalCallHint { * @param returnData the data returned by the external call. * @param gasUsed gas used by the external call (not including the cost of the CALL opcode itself). * @param endSideEffectCounter value of side effect counter at the end of the external call. + * @param bytecode currently the bytecode of the nested call function, will be changed to the contract bytecode (via the dispatch function) of the nested call */ constructor( public readonly success: Fr, returnData: Fr[], public readonly gasUsed: Gas, public readonly endSideEffectCounter: Fr, + public readonly bytecode: Buffer, ) { this.returnData = new Vector(returnData); } @@ -117,7 +119,8 @@ export class AvmExternalCallHint { this.success.isZero() && this.returnData.items.length == 0 && this.gasUsed.isEmpty() && - this.endSideEffectCounter.isZero() + this.endSideEffectCounter.isZero() && + this.bytecode.length == 0 ); } @@ -132,6 +135,7 @@ export class AvmExternalCallHint { fields.returnData.items, fields.gasUsed, fields.endSideEffectCounter, + fields.bytecode, ); } @@ -141,7 +145,18 @@ export class AvmExternalCallHint { * @returns An array of fields. */ static getFields(fields: FieldsOf) { - return [fields.success, fields.returnData, fields.gasUsed, fields.endSideEffectCounter] as const; + // Buffers aren't serialised the same way as they are read (lenth prefixed), so we need to do this manually. + const lengthPrefixedBytecode = Buffer.alloc(fields.bytecode.length + 4); + // Add a 4-byte length prefix to the bytecode. + lengthPrefixedBytecode.writeUInt32BE(fields.bytecode.length); + fields.bytecode.copy(lengthPrefixedBytecode, 4); + return [ + fields.success, + fields.returnData, + fields.gasUsed, + fields.endSideEffectCounter, + lengthPrefixedBytecode, + ] as const; } /** @@ -156,6 +171,7 @@ export class AvmExternalCallHint { reader.readVector(Fr), reader.readObject(Gas), Fr.fromBuffer(reader), + reader.readBuffer(), ); } diff --git a/yarn-project/circuits.js/src/tests/factories.ts b/yarn-project/circuits.js/src/tests/factories.ts index 7d07a1a6d3e..c8e16d52986 100644 --- a/yarn-project/circuits.js/src/tests/factories.ts +++ b/yarn-project/circuits.js/src/tests/factories.ts @@ -1376,6 +1376,7 @@ export function makeAvmExternalCallHint(seed = 0): AvmExternalCallHint { makeArray((seed % 100) + 10, i => new Fr(i), seed + 0x1000), new Gas(seed + 0x200, seed), new Fr(seed + 0x300), + makeBytes((seed % 100) + 10, seed + 0x400), ); } diff --git a/yarn-project/noir-protocol-circuits-types/src/__snapshots__/noir_test_gen.test.ts.snap b/yarn-project/noir-protocol-circuits-types/src/__snapshots__/noir_test_gen.test.ts.snap index 0ccb39080a9..c5b038f46bb 100644 --- a/yarn-project/noir-protocol-circuits-types/src/__snapshots__/noir_test_gen.test.ts.snap +++ b/yarn-project/noir-protocol-circuits-types/src/__snapshots__/noir_test_gen.test.ts.snap @@ -4,11 +4,11 @@ exports[`Data generation for noir tests Computes contract info for defaultContra "{ contract_address_salt: 0x000000000000000000000000000000000000000000000000000000000000ddd5, artifact_hash: 0x0000000000000000000000000000000000000000000000000000000000003039, - public_bytecode_commitment: 0x0000000000000000000000000000000000000000000000000000000000000005, + public_bytecode_commitment: 0x11fb08be2c55e530172e671f647b16dddf9b66acf42489d0236785d8f7bc8b48, private_functions_root: 0x25d76df45434ec75a83321daf941cfc667ff3a9027942e17105da4f50d1d13f9, - address: AztecAddress { inner: 0x07a6b468dff245b1d9482de2b5048383549766d3641760aed17727525cd9baa1 }, - partial_address: PartialAddress { inner: 0x0cf203c94c91bed28440b00ecd888d88cce1f86ddf2aa8d33acbb9b6fc06d382 }, - contract_class_id: ContractClassId { inner: 0x28e91aaf764bc6083e2796ff884079ad895d4b948d6ce8f37f01b29d0bc95a21 }, + address: AztecAddress { inner: 0x29bc2e90ff6ec5f4a7c7f502e368af01eb74131a2eec6320e0e45419cddc7b6d }, + partial_address: PartialAddress { inner: 0x1a68423cf4f04eaede2b0e93131916b8b7330dae6e8ee202679d12a4eb49cc0b }, + contract_class_id: ContractClassId { inner: 0x1195b865ef122d75c8c4d6102d536193b69bbb712c85bafcbf7694f52e2d8c36 }, public_keys: PublicKeys { inner: 01498945581e0eb9f8427ad6021184c700ef091d570892c437d12c7d90364bbd170ae506787c5c43d6ca9255d571c10fa9ffa9d141666e290c347c5c9ab7e34400c044b05b6ca83b9c2dbae79cc1135155956a64e136819136e9947fe5e5866c1c1f0ca244c7cd46b682552bff8ae77dea40b966a71de076ec3b7678f2bdb1511b00316144359e9a3ec8e49c1cdb7eeb0cedd190dfd9dc90eea5115aa779e287080ffc74d7a8b0bccb88ac11f45874172f3847eb8b92654aaa58a3d2b8dc7833019c111f36ad3fc1d9b7a7a14344314d2864b94f030594cd67f753ef774a1efb2039907fe37f08d10739255141bb066c506a12f7d1e8dfec21abc58494705b6f }, salted_initialization_hash: SaltedInitializationHash { inner: 0x13a939daa511233e5446905ed2cadbee14948fa75df183b53b5c14b612bffe88 }, deployer: AztecAddress { inner: 0x0000000000000000000000000000000000000000000000000000000000000000 } @@ -19,11 +19,11 @@ exports[`Data generation for noir tests Computes contract info for parentContrac "{ contract_address_salt: 0x0000000000000000000000000000000000000000000000000000000000001618, artifact_hash: 0x00000000000000000000000000000000000000000000000000000000000004bc, - public_bytecode_commitment: 0x0000000000000000000000000000000000000000000000000000000000000005, + public_bytecode_commitment: 0x1c5009dd5e8baedc8dfb2e801c9f97361b1ae152ff52f82104119c476b369bef, private_functions_root: 0x1228b39ba6702af03e595300e8484c6373f00790d0148cc3d4ff0fd1c778a83a, - address: AztecAddress { inner: 0x030a8041016cd781040145827932d85ef3c9211204aafd6cf033f91295fc4946 }, - partial_address: PartialAddress { inner: 0x245df9f519d616473880260dd64b19a838081bb44dc17cd6ea5d870a63d2bf57 }, - contract_class_id: ContractClassId { inner: 0x00236b0dc6c537d5106543053c5b85c4cbe95b0474f8238b094bae63f1cbcfee }, + address: AztecAddress { inner: 0x2749b685f752f6dfe1d4e532fc036839004926b7c18abf1a4f69ddf97d62f40e }, + partial_address: PartialAddress { inner: 0x1c30ee02dcd41bcdfc5191dc36ccaae15cdc7e1fc6bd8a0cbe1baeaf1335a771 }, + contract_class_id: ContractClassId { inner: 0x24f1b8df215c10ee7edd213b439c8f8e99198a802a3e1e41597b6554b17049a3 }, public_keys: PublicKeys { inner: 01498945581e0eb9f8427ad6021184c700ef091d570892c437d12c7d90364bbd170ae506787c5c43d6ca9255d571c10fa9ffa9d141666e290c347c5c9ab7e34400c044b05b6ca83b9c2dbae79cc1135155956a64e136819136e9947fe5e5866c1c1f0ca244c7cd46b682552bff8ae77dea40b966a71de076ec3b7678f2bdb1511b00316144359e9a3ec8e49c1cdb7eeb0cedd190dfd9dc90eea5115aa779e287080ffc74d7a8b0bccb88ac11f45874172f3847eb8b92654aaa58a3d2b8dc7833019c111f36ad3fc1d9b7a7a14344314d2864b94f030594cd67f753ef774a1efb2039907fe37f08d10739255141bb066c506a12f7d1e8dfec21abc58494705b6f }, salted_initialization_hash: SaltedInitializationHash { inner: 0x24bd6ac7a182e2cf25e437c72f53544ef81dfd97d9afee23abb07a638e7be749 }, deployer: AztecAddress { inner: 0x0000000000000000000000000000000000000000000000000000000000000000 } diff --git a/yarn-project/protocol-contracts/src/protocol_contract_data.ts b/yarn-project/protocol-contracts/src/protocol_contract_data.ts index 4096a51b165..c5e4b30fb85 100644 --- a/yarn-project/protocol-contracts/src/protocol_contract_data.ts +++ b/yarn-project/protocol-contracts/src/protocol_contract_data.ts @@ -50,14 +50,14 @@ export const ProtocolContractAddress: Record }; export const ProtocolContractLeaf = { - AuthRegistry: Fr.fromString('0x25287d474d84b6ecb5d4f5e90b8efe5969a35ddb9d605077e5df17dac0f2aa58'), - ContractInstanceDeployer: Fr.fromString('0x1b92794557c9c6694ede81d4ea8909f786fe37ec51018d673f9ed6d8df09fcb2'), - ContractClassRegisterer: Fr.fromString('0x034af167c41eeb46cb695f9fc56824b3339b23aa670ebfef7bf5d3c8dd5c13d4'), - MultiCallEntrypoint: Fr.fromString('0x009d1fc8ca80534c2de293ce6eedc71cc145e0562fd1af0826c734c77b1543a5'), - FeeJuice: Fr.fromString('0x07c4d7db5027bcdb7b71a60186a5e137d22bd8412d11fee0676d070c68d0f7ee'), - Router: Fr.fromString('0x12df324157fddc5be72e52e527416e3f7c70240deab1c953613d904232e1eb78'), + AuthRegistry: Fr.fromString('0x0f482caa8a420dd90facb7763f742e2cb456e89d0a85eb55b840569b61ed2083'), + ContractInstanceDeployer: Fr.fromString('0x04a661c9d4d295fc485a7e0f3de40c09b35366343bce8ad229106a8ef4076fe5'), + ContractClassRegisterer: Fr.fromString('0x147ba3294403576dbad10f86d3ffd4eb83fb230ffbcd5c8b153dd02942d0611f'), + MultiCallEntrypoint: Fr.fromString('0x154b701b41d6cf6da7204fef36b2ee9578b449d21b3792a9287bf45eba48fd26'), + FeeJuice: Fr.fromString('0x02f0c22c8c8f8bcc9707383fbb2ca57278c6554af0b3e2a7ca046cd6f956fb62'), + Router: Fr.fromString('0x299546b7c3804dfc5842d3713c7f238f7075af008e4828405f9a1eb4897ac9c2'), }; export const protocolContractTreeRoot = Fr.fromString( - '0x04180f14bbf7d65ec020746102a118a58c4aa4016cdd85a41614fc4d972607cf', + '0x120eb84242cae2f2eb6bdbe86ddd2787a2b9e043da0b80f4a5b7f504e3d03ffb', ); diff --git a/yarn-project/simulator/src/public/enqueued_call_side_effect_trace.ts b/yarn-project/simulator/src/public/enqueued_call_side_effect_trace.ts index 0e7036a37ef..516771d30f5 100644 --- a/yarn-project/simulator/src/public/enqueued_call_side_effect_trace.ts +++ b/yarn-project/simulator/src/public/enqueued_call_side_effect_trace.ts @@ -340,7 +340,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI /** How much gas was left after this public execution. */ endGasLeft: Gas, /** Bytecode used for this execution. */ - _bytecode: Buffer, + bytecode: Buffer, /** The call's results */ avmCallResults: AvmContractCallResult, /** Function name for logging */ @@ -368,6 +368,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI avmCallResults.output, gasUsed, endSideEffectCounter, + bytecode, ), ); } diff --git a/yarn-project/simulator/src/public/side_effect_trace.ts b/yarn-project/simulator/src/public/side_effect_trace.ts index 1c24a9f9117..7b58742af8a 100644 --- a/yarn-project/simulator/src/public/side_effect_trace.ts +++ b/yarn-project/simulator/src/public/side_effect_trace.ts @@ -288,6 +288,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface { result.returnValues, gasUsed, result.endSideEffectCounter, + bytecode, ), ); }